Status and roadmap

This page summarizes the release history and the future work that is actually stated in the repository. The release by release detail lives in the changelog on GitHub.

Current status

The current release is 0.3.3. The compiler runs the whole pipeline: it lexes, parses, resolves names, type checks, monomorphizes, and emits code, backed by a golden and unit test suite. The standard library and the multi module sample both build and run.

0.3.3 completes the concurrency line. The submit builtin queues fire and forget tasks on a global worker pool without ever blocking the submitter, chan_try_send, chan_try_recv, and chan_recv_timeout refuse or time out instead of parking forever, and the offload example rehearses the park, wake, and offload loop the 0.4.x async releases build on. See Concurrency and the concurrency reference for the language surface.

Release history

Development has proceeded in three lines, each a minor version series with one theme.

0.1.x: the core language, end to end

0.1.0 delivered the core language through the whole pipeline: paradigm directives gating procedural, functional, and OOP features per file, structs, methods, enums with exhaustive match, interfaces with vtables, closures, monomorphized generics, functional builtins, do notation, errors as values under the must-handle rule, explicit memory with alloc, free, and defer, a module system with a stdlib seed, and a golden test suite compiling and running every example.

The point releases filled in the planned core:

• 0.1.1: correctness and diagnostics, char semantics, errors as values lowered end to end, per file source tracking in diagnostics.
• 0.1.2: pointer receivers for methods and the using Allocator interface working end to end, with Heap, FixedBuffer, Arena, and Debug in the stdlib.
• 0.1.3: qualified call syntax, std.map (a string keyed Map<V> written in dusk), and file I/O with read_file and write_file.
• 0.1.4: console input and parsing, read_line, read_all, parse_int, parse_int_radix, parse_float, and the std.io compositions.
• 0.1.5: formatted printing, print and println take a format string whose {} holes expand at compile time into typed prints.

0.2.x: memory safety

Releases 0.2.0 through 0.2.6 built the memory safety story described in the memory guide and the memory reference:

• 0.2.0: mutable strings, StringBuilder, concat, and the cstr builtin.
• 0.2.1: generational references, the runtime foundation. A managed *T is a fat pointer carrying a remembered generation checked at every dereference, so a use after free, a double free, or a stale pointer to a reused block faults instead of corrupting memory. The thin layer, *raw T and *void, landed alongside.
• 0.2.2: single owner pointers, the static half. The checker tracks owners and borrows, move transfers ownership and invalidates the source, and ref makes a non owning alias.
• 0.2.3: escaping value lifetimes. Returning a slice viewing a frame local array or a closure capturing a frame local is a compile error.
• 0.2.4: the minimal foreign function interface, foreign "C" blocks calling libc across the raw pointer boundary.
• 0.2.5: closed the gaps a specification review found, generation checked free, bounds checked indexing, the first enforcement of the must-handle rule, interface conformance at call sites, and more.
• 0.2.6: hardened the whole line one level deeper, type sized alloc(), integer and float widths tracked so int32 + int64 is a compile error, immutability covering element and field stores, the binding level must-handle rule, module private name isolation, and Display gated printing.

0.3.x: concurrency

Releases 0.3.0 through 0.3.3 built concurrency in four phases, each covered in the concurrency guide:

• 0.3.0: threads. spawn starts an OS thread running a lambda whose captures copy into a private heap environment, join waits and retires the handle, the generational heap is thread safe, and std.concurrent.atomic carries the sequentially consistent counter.
• 0.3.1: channels. std.concurrent.channel carries a bounded, thread safe queue, with ownership moved across threads through chan_send(c, move(p)) and the sender’s name dead at compile time.
• 0.3.2: mutexes and condition variables. std.concurrent.sync ships Mutex and Condvar, with every classic pthread misuse turned into a named fault.
• 0.3.3: the thread pool and the async substrate, the non blocking and timed channel operations, the submit builtin over a global worker pool, and pool_start, pool_shutdown, and ncpu in std.concurrent.pool.

Future work

Only the work the sources state is listed here.

The 0.4.x async line

The changelog names the 0.4.x async line as what comes next, built on the 0.3.3 substrate. The 0.3.3 offload example rehearses the exact park, wake, and offload shape the 0.4.0 event loop lowers onto, and submit’s never blocking contract is the one the event loop needs for its offload path. No further 0.4.x detail is specified yet.

dawn: versioning and repeatable builds

The dawn package tool is a minimal working seed today: an import resolves against the latest clone in the cache, and there is no version selection, no lock file, no fetch past the root file’s direct imports, and no integrity check. Its stated roadmap, in order:

1. Version selection: pin a git tag or commit per package, chosen by a minimal version selection rule like Go’s and recorded so builds repeat.
2. A lock file: a checked in manifest at the project root listing every package and its resolved version, so a fresh machine builds the same bytes.
3. Graph fetch: walk the imports of fetched packages, not the root file alone, and resolve the whole graph before a build.
4. Integrity: a hash per fetched module, verified on use, to catch a moved or rewritten tag.
5. Quality of life: a vendor mode that copies dependencies into the tree, offline builds from the cache, and private repositories with authentication.

Standard library plans

The repository sketches the shape the standard library grows into. This is a direction, not a schedule. Some entries have since landed, a string keyed std.map in 0.1.3 and mutable strings in 0.2.0, while the rest remain planned:

• std.map generic over key and value, where today’s map is string keyed.
• std.functional.result: Result<T, E>, a typed failure channel beside the error builtin.
• std.functional.io: IO<T>, a monad wrapping side effecting work so it composes with do notation.
• std.logging: structured logging with levels and output redirection, built on std.io.
• std.memory.collector: a garbage collector exposed as an allocator, shipping first as a conservative collector, with a precise collector much later.
• Unicode aware string operations.
• More monads: List<T> and a wider set of helpers across Maybe, Either, and Result.

Following along

The full history, newest first, is in the changelog, and the source lives at github.com/choice404/dusk.