A gilded and silver celestial globe from 1579, driven by clockwork and carried on a winged horse.

Progress tracker

This page mirrors the tracker maintained inside the repository. Every "shipped" claim below is backed by a passing test; the suite stands at 907 passed, 0 failed, 0 ignored for the v0.13.11-alpha release.

v0.13.11-alpha: Released, with 907 tests, for macOS and WebAssembly (Linux and Windows follow)
907 tests: Released: functions as values and sized integers (v0.13.11); richer enums, patterns and generic structs (v0.13.10); @derive(Eq, Show) (v0.13.9)
Trait objects: Next (dyn Trait), then Set, slicing and comprehensions

Where each version stands

Every release from v0.6 to v0.12 is complete, v0.13 is shipping in small releases, and v1.0 has not started.

v0.6

100%

v0.7

100%

v0.8

100%

v0.9

100%

v0.10

100%

v0.11

100%

v0.12

100%

v0.13

100%

v1.0

Release	Scope	Status
v0.6 alpha	Native core, JSON diagnostics, verify mode	done
v0.7	Source spans, semantic core native, REPL, closures, `dyn`, ARC scaffolding, rich diagnostics, Mifa registry protocol + publish	released 2026-07-06
v0.8	True LLVM-IR default backend, async/await (sync lowering), end-to-end regression suite, ignored-test burn-down 10 → 0	released 2026-07-07
v0.9	Soundness & hardening: nominal structs, enums with payload variants, `?` operator + try/catch, tuples, impl blocks, bitwise ops, callable closures, ARC scope-based reclamation, compiler-never-panics on malformed input, CI gates (fmt / clippy / audit / llc corpus), cross-platform release binaries (Linux, macOS ×2, Windows)	v0.9.1-alpha released 2026-07-15
v0.10 – v0.11	Tree-walking interpreter behind `astra run` with parity tests and differential fuzzing against native; modules (`import`, `pub`, `util::f()`, E0013); `mifa build`/`run` with path dependencies as modules; runtime traps for overflow, division by zero, bad shifts, out-of-bounds and runaway recursion on both engines; `def` alias (A4); type inference for omitted parameter/return types (A3); Python-style indentation is the canonical syntax (braces still accepted) and `astra fmt` converts to it; functions may be called before they are defined; a `match` that misses an enum variant is a compile error (E0021); `s.split()`; Cargo-style `astra.toml` and `mifa test`; structs/lists are values, `mut` parameters + E0022, read-only bindings (A8); `a[i] = v`; headered string literals (E0); nominal traits (`trait Shape:` + `impl Shape for Circle:`, E0020) and trait bounds `fn f<T: Shape>` with static dispatch; v0.11.1: released binaries compile natively (C runtime embedded)	v0.11.1-alpha released 2026-11-02
v0.11.2	Trait bounds checked at the call site and impl signatures checked against the trait (E0020); `while`-loop locals, list copies and struct list fields freed (loops stay ~1.3 MB); tuples holding structs compile; 712 tests	v0.11.2-alpha released 2026-11-02
v0.12	Every type error in the main file carries the line and column of its statement, a function reports all its independent errors in one run, and E0014 points at the offending built-in call; machine-applicable `fix` edits on E0002/E0003 (misspelt names) and E0022 (missing or extra `mut`) plus `astra fix <file>`; single-owner locals freed on every exit, strings returned from functions, lists of fresh strings and template-literal intermediates freed (the measured cases drop from 20–231 MB to 1.3 MB peak); bools print `true`/`false` on both engines; `==`/`!=` only on int/float/bool/str; native crash on `let b = a` for strings fixed; `mifa --version`; `mifa search` says the registry is not deployed; a 55-check black-box release suite; 754 tests	v0.12.0-alpha released 2026-11-04
v0.13	`astra mcp` for AI agents, runtime error codes, Astra as WebAssembly and the browser playground; string methods; `Map<K, V>` and list sorting; any value in `Result` / `Option`; calling C and a static Mifa registry; eight correctness fixes from probe programs; `elif`, default arguments, `sqrt`; the Python habits models write first and trait default methods; `@derive(Eq, Show)`; multi-field enum variants, struct / tuple / range / `\|` patterns, tail-expression returns, generic structs; functions as values (`map`, `filter`, `fold`, `fn(..)` parameters) and sized integers with `as`; 907 tests	v0.13.11-alpha released 2026-11-12
Next	Trait objects (`dyn Trait`); storing and returning functions; `Set`, slicing, comprehensions and a `math` module; `@derive` on enums and the other standard traits; fixes for E0021 and E0020; the remaining memory leaks; LSP alpha, stdlib core; then `tool` / `agent` / `prompt` / `memory` keywords, agent SDK, sandbox	planned
v1.0	GPU target (NVPTX), production tooling, hosted Mifa registry	planned

Language feature matrix

The globe shows every feature by status; the table gives each one's evidence.

Feature	Status	Notes
Lexer / parser / AST	working	Full token + column tracking; returns diagnostics instead of panicking on malformed input (v0.9)
Type checking + inference	working	Ad-hoc inference + checking for the core language; omitted parameter/return types are inferred (call sites + body operators). Since v0.13.11 the checker records every expression's type, and a pass after checking uses it (the range checks of sized integers); a full Hindley-Milner solver is still unwired
Native compilation (LLVM IR → binary)	working	Default path since v0.8: IR → `opt` → `llc` → link; release binaries built for Linux x64, macOS x64/ARM64, Windows x64 (v0.9.1)
`--emit-ir` / `--target` cross-compile	v0.8	Prints LLVM IR; `--target` emits target object files (`llc -mtriple`); `astra build -O` and `mifa build --release` optimise at -O3
Functions, recursion, control flow	working	if/else, while, do/while, for-range, switch, ternary
Arrays + `.push()`	working	Bounds-checked; iteration, membership (`in`), honest `.length()`; push-then-read in statement position fixed v0.9
Structs (nominal, typed field access)	working	Named literals typed nominally, same-shape structs are distinct types; mutable fields; native GEP loads, nested access
Enums + match	v0.13.10	Unit variants and variants with one or several values (`Rect(float, float)`, v0.13.10), `match` in expression and statement position, exhaustive (E0021); patterns: literals, variants, guards, and since v0.13.10 structs (`Point { x: 0, y, .. }`), tuples, ranges (`0..10`, `0..=9`) and `\|`. Not yet: a variant pattern nested inside a struct or tuple pattern, struct-style variants
`Result<T,E>` + match + `?`	working	Ok/Err paths, match binding; `?` unwraps Ok/Some or early-returns Err/None (v0.9); since v0.13.2 any payload (structs, floats, lists); `unwrap` / `unwrap_or` / `is_some` / `is_ok` since v0.13.8
try / catch	v0.9 (local)	Lowered as function-local control flow, no unwinder, so a `throw` in a called function still aborts; use `Result` + `?` across functions
Closures (defined and called)	v0.13.11	Lambda-lifted before type checking, for both engines; captures copied at definition; `\|x\| x * 2` needs no braces. Since v0.13.11 lists take closures and function names (`map`, `filter`, `any`, `all`, `count`, `find`, `fold`, `sum`, `enumerate`, `zip`) and functions take `fn(int) -> int` parameters. Not yet: storing or returning functions, closures inside closures
Interpreter (`astra run`)	v0.10	Tree-walking, no LLVM needed; parity-tested and fuzzed against native, same stdout and exit code
Modules (`import`, `pub`, `util::f()`)	v0.10	v0: enum variant names are global; programs from stdin/REPL cannot import
Runtime safety traps	v0.10	Overflow, division by zero, shifts outside 0..63, out-of-bounds and runaway recursion stop with `Runtime error`, exit 1, on both engines; since v0.13.11 also a sized integer leaving its range (`integer overflow: 300 does not fit in u8`)
Tuples + destructuring	v0.9	`(a, b)`, `t.0`, `let (a, b) = e`, tuple types; arity mismatches rejected (E0017)
impl blocks	v0.9	Instance methods and associated functions (`Type::new()`)
Generics (monomorphized fns)	v0.13.10	Generic functions specialize per concrete type; generic structs (`struct Stack<T>` with `impl<T>` methods) since v0.13.10, one concrete struct per type in native builds. Not yet: methods with their own type parameters on a generic struct (native)
`Vec<int>` (minimal)	v0.9 slice	`Vec::new()` + push/read over the array runtime; typed `Vec<T>` annotations don't parse yet
String interpolation `${}`	working	Runtime-value interpolation, `.length()`, `.to_string()`, concat, string-method suite
String methods and characters	v0.13.1	`split`, `trim`, `substring`, `contains`, `index_of`, and since v0.13.1 `starts_with`/`ends_with`, `replace`, `char_at(i)` (byte-indexed; out of range is R0004), `chars()` and `for c in s` (one `str` per UTF-8 character), `<` `<=` `>` `>=` on strings (byte order). Both engines, same output
Bitwise + compound operators	v0.9	`& \| ^ ~ << >>` with Python-parity precedence; `+=` family, `**`, radix literals
Float arithmetic / compare	v0.7	Native `fadd`/`fcmp`; an `int` becomes a `float` with `.to_float()` (no automatic promotion yet: `int * float` is a type error); `sqrt` since v0.13.6
Sized integers + `as`	v0.13.11	`u8`, `u16`, `u32`, `i8`, `i16`, `i32` beside 64-bit `int`; every result range-checked on both engines, as in Rust; a literal takes the other side's type and must fit; mixing types needs `as` (`x as u8` wraps, `f as int` truncates). Not yet: `u64`/`usize`
`elif`, default arguments, `sqrt`	v0.13.6	`elif` in both syntaxes; literal default values for trailing parameters, filled in at the call on both engines (no keyword arguments yet); `sqrt` of an `int` or `float`. Linux binaries of v0.13.6-alpha fail to link a `sqrt` of a run-time value; fixed in v0.13.7
JSON diagnostics with line + column	working	Since v0.12: every type error in the main file carries the line and column of the statement that raised it (human output `(line N, column M)`), a function reports all its independent errors in one run, and E0014 points at the offending built-in call; errors in imported modules and function signatures still have no line
Machine-applicable fixes + `astra fix`	v0.12	Diagnostics carry `"fix": {"edits": [...]}` when the repair is unambiguous: misspelt variable/function names (E0002/E0003, `did you mean 'total'?`) and a missing or extra `mut` at a call (E0022). `astra fix <file>` applies them, re-verifies, repeats and writes the file. Fixes for E0021 and E0020 are next
Rich diagnostics: `error_code`, `suggestion`, `astra explain`	v0.7	Stable E0001–E0022 codes
`astra repl`	alpha	Whole-program re-compile model
`dyn` gradual typing	v0.7	First milestone: boundary typecheck + boxed lowering
ARC memory reclamation	working, partial	Single-owner structs, strings, tuples, arrays freed at loop-body + function scope with retain-on-alias; 2M-iteration loops ~1.3 MB (were 98–194 MB), in `for` and `while` loops, including list copies and struct list fields. String-aliased values, lists of heap values and some non-loop scopes still leak, bounded and safe, never a double-free. Since v0.12, single-owner locals are freed on every exit (fall-through, `return`, `break`, `continue`), strings returned from functions, lists of fresh strings and template-literal intermediates are freed; peak RSS 231 MB → 1.3 MB for a helper building a struct/list/tuple called 1M times, 47 MB → 1.3 MB for a returned `str` bound in a loop ×1M, 20 MB → 1.3 MB for a list of fresh strings or a template literal ×200k, with identical output on both engines. Still leaking: locals inside `if`/`match` branches, locals passed to calls, stored or reassigned, exits via `?`/`throw`, `str` fields of structs
async / await	v0.8	Parses + compiles natively; synchronous lowering, real task runtime still ahead
Printing and equality	v0.13.9	Bools print `true`/`false` on both engines; `==`/`!=`, `print` and `${}` work on int/float/bool/str, and on structs with `@derive(Eq, Show)` (v0.13.9); on enums, tuples, lists, `Option` and `Result` they are a type error (native compared pointers), and `xs.pop()` is refused
Traits + generic structs	v0.13.10	Nominal traits (`trait Shape:` + `impl Shape for Circle:`) with E0020 conformance; trait bounds `fn f<T: Shape>` checked at the call site, static dispatch; trait default methods (v0.13.8); `@derive(Eq, Show)` on structs (v0.13.9); generic structs (v0.13.10). Next: trait objects (`dyn Trait`), derive on enums, the other standard traits
Not implemented yet	planned	Trait objects (`dyn Trait`), storing or returning functions, `Set`, comprehensions, list `pop`/slicing, math beyond `sqrt` (`pow`, `floor`, trig), `int * float` without `.to_float()`, `u64`/`usize`, indented `try:`/`catch e:`, `@derive` on enums, `await` in the interpreter, `spawn`, `tool`/`agent` keywords
WASM target	planned	`--target=wasm32-wasi` emits a wasm object today; a WASI runtime build (for runnable `.wasm`) is next. The compiler itself already runs as WebAssembly: the browser playground and a Node runner (v0.13.0)
Python interop	planned	Embedded CPython, ratified decision
`tool`/`agent`/`prompt`/`memory`	planned	Agent-native keywords
GPU kernels (NVPTX)	v1.0

Ignored-test burn-down

A release KPI: tests stay ignored until the feature truly works end-to-end, and the count must shrink every release. It is complete: 10 → 0 and has stayed at 0 since 2026-07-07. The end-to-end regression suite (tests/regression_tests.rs) has grown from 14 to 108 tests, each locking a shipped feature through compile → IR → native run → stdout/exit-code assertions. CI also gates every commit on cargo fmt, clippy -D warnings, cargo audit, and an llc IR-validity corpus.

Release testing v0.12

A black-box release suite tests the downloaded binaries, not the source tree: 69 checks covering programs on the interpreter and native, modules, calling C, error codes and lines, astra fmt, astra fix and the Mifa flow, workspaces included. It runs on every platform before a release publishes, and a failure on any platform stops the release. v0.13.11-alpha scores 69/69 on macOS (Apple Silicon); v0.13.5-alpha scored 63/63; v0.13.2-alpha scored 60/60. v0.12.0-alpha's Windows run found that programs compiled but did not link there; v0.12.1 fixed it. v0.11.2-alpha scored 52/55 (mifa search failed).

The work queue, in priority order

v0.8 and v0.9 are closed, and the narrow & harden phase (rows 1–8) is done. The current phase is parity: Rust's language features first, then Python's, each on both engines with parity tests. The order of attack:

#	Astra	Status / why it's next
1	Robustness: compiler never panics	done 2026-07-13, lexer/parser return diagnostics instead of crashing on malformed input; CI gates every commit on fmt, clippy `-D warnings`, cargo-audit, and an llc IR-validity corpus
2	Callable closures	done 2026-07-13, root cause was pipeline order (closure-lift now runs before typecheck); v0 is int-typed closures on the default path
3	ARC scope-based reclamation	done 2026-07-15, single-owner structs, strings, tuples, arrays freed at loop-body and function scope; retain-on-alias; 2M-iteration loops now run in ~1.3 MB (were 98–194 MB). String-aliased values still leak (bounded, safe)
4	Interpreter with native parity	done 2026-10-27, `astra run` interprets (no LLVM needed; the slot-resolving redesign landed 2026-10-30, so it now beats CPython on loops, floats and arrays and is close on branches); every feature is tested for identical stdout and exit code against the native binary, and a fuzzer generates programs that must agree on both. Overflow, division by zero, bad shifts, out-of-bounds and runaway recursion now stop with a runtime error on both engines
5	Modules v0	done 2026-10-28, `import util;`, `pub` items, `util::f()` names; resolved before type checking so both engines get them; cycles, missing modules and private items are E0013 at the import line
6	Program input and output	v0.10 Command-line arguments, stdin, files and environment variables, with capabilities
7	Consolidate the two codegen paths	Done 2026-11-01: the legacy backends (`--llvm-native`, `--legacy-c`) were removed; `ir.rs` is the only code generator
8	Machine-applicable fixes	v0.12 Diagnostics carry `fix` edits for misspelt names (E0002/E0003) and a missing or extra `mut` (E0022), and `astra fix` applies them; fixes for a missing match arm (E0021) and a missing trait method (E0020) are next
9	Rust parity: traits, generics, functions, integers	Trait bounds (v0.11), trait default methods (v0.13.8), `@derive(Eq, Show)` (v0.13.9), multi-field variants, richer patterns and generic structs (v0.13.10), functions as values and sized integers (v0.13.11) are done; next is trait objects (`dyn Trait`), then Python parity: `Set`, slicing, comprehensions, `math`
10	Remaining memory leaks	Locals inside `if`/`match` branches, locals passed to calls, stored or reassigned, exits via `?`/`throw`, and `str` fields of structs still leak (bounded, safe)
11	LSP alpha + stdlib core (`astra fmt` shipped)	Diagnostics-on-save first (reuses the JSON pipeline); collections/string/fs surface

#	Mifa	Why it's next
Done	`mifa build` / `run` with path dependencies	done 2026-10-28, builds `target/<name>`, dependency `src/` folders are module folders, `build --json` reports the binary path; `add --path` validates the package
1	Real `mifa test` discovery + project-wide `mifa verify`	The last gaps in the agent-native local story: `verify` checks only the manifest and layout today
Done	Static package registry + real `mifa publish`	v0.13.3, a registry is a folder or any static web host: `mifa publish` writes a version into a folder, `mifa add <name>`, `mifa yank`, `mifa search`; web registries are read-only
2	Central hosted registry	Accounts and uploads over HTTP, so publishing no longer means uploading a folder yourself; `--dry-run` stays as the local pre-flight

Guiding rule: no hosted registry before the local --json story is complete. Stretch items, WASM target, Python-interop alpha, real async runtime, follow the big rocks.

From the first lexer to v0.13

Each release on one line, oldest first. Test counts are the suite at the time of the release.

Oct 2025 v0.1
The idea becomes code: a language as easy as Python, as safe and fast as Rust, built for agentic coding. Lexer, parser and the first AST.
Oct 2025 v0.4
The package manager gets its name: Mifa.
Nov 2025 v0.5
Native compilation, Docker CI, first pre-built binaries.
Jun 2026 v0.6 alpha
Honest alpha reset: JSON diagnostics, verify mode, the AI-first verify-repair-compile loop.
Jul 6, 2026 v0.7
Source spans, structs / Result / closures native, REPL, dyn, ARC scaffolding, rich diagnostics with astra explain; Mifa lockfile and registry protocol.
Jul 7, 2026 v0.8.0-alpha
The true LLVM-IR backend becomes the default; async/await (synchronous lowering); ignored tests 10 → 0. 285 tests
Jul 7, 2026 v0.8.0.1-alpha
Rust and Go join the cross-language benchmark suite, with every program's output checked.
Jul 9, 2026 v0.9.0-alpha
Soundness: nominal structs, enums with payloads, ? and try/catch, tuples, impl blocks, bitwise operators.
Jul 15, 2026 v0.9.1-alpha
First cross-platform binary release (Linux, macOS ×2, Windows); callable closures; ARC memory reclamation; the compiler never panics on malformed input. 449 tests
Oct 30, 2026 v0.10.0-alpha
Interpreter behind astra run with native parity and differential fuzzing; modules; program I/O with capabilities; runtime traps on both engines; mifa build / run. 609 tests
Nov 2, 2026 v0.11.0-alpha
Value semantics (structs and lists are values, mut parameters, E0022, a[i] = v), Python-style indentation and astra fmt, type inference, nominal traits and trait bounds with static dispatch. 695 tests
Nov 2, 2026 v0.11.1-alpha
Released binaries compile natively: the C runtime is embedded in the compiler, and macOS links for the compiler's own architecture. 699 tests
Nov 2, 2026 v0.11.2-alpha
Trait bounds checked at the call site and impl signatures checked against the trait (E0020); loops no longer leak memory (while bodies, list copies, struct list fields); every release binary is smoke-tested before publishing. 712 tests
Nov 4, 2026 v0.12.0-alpha
Every type error in the main file carries its line and column; machine-applicable fixes and astra fix; single-owner locals freed on every exit (a helper building a struct/list/tuple, called 1M times: 231 MB → 1.3 MB peak); bools print true/false; == only where it compares by value; mifa --version and an honest mifa search; a 55-check black-box release suite on every platform. 754 tests
Nov 5, 2026 v0.12.1-alpha
Native builds on Windows; print and ${} refuse values that native code printed as heap addresses; xs.pop() refused until it returns an Option; the release check now blocks a release on any platform. 756 tests
Nov 5, 2026 v0.12.2-alpha
Three native wrong answers fixed, all found by writing real programs: nested structs that share a field name, a f(mut x)? statement, a bool inside a Result. 20 showcase and 8 real-world examples, each checked against a Python version on both engines. 760 tests
Nov 5, 2026 v0.13.0-alpha
astra mcp: a Model Context Protocol server, so any AI agent can verify, fix, run, build and test Astra, whatever the model. Runtime errors carry stable codes (R0001–R0007). Astra as WebAssembly, with a Node runner, and the browser playground. 777 tests
Nov 6, 2026 v0.13.1-alpha
The string methods of a first hour with Astra: char_at, chars(), for c in s, starts_with, ends_with, replace, and < / > on strings, on both engines. Mifa version requirements follow Cargo's rules and pick the newest version by semver. 796 tests
Nov 6, 2026 v0.13.2-alpha
Everyday programs without workarounds: Map<K, V>, list sort and sort_by_key, and any value in Result / Option. All eight real-world programs were rewritten to use them. Mifa fetches git dependencies, solves versions across the whole graph and builds workspaces. 831 tests
Nov 6, 2026 v0.13.3-alpha
Calling C: extern "c" fn with int, float, bool and str, and @link for libraries. Mifa reads a static, self-hosted package registry (a folder or any static web host): mifa publish, mifa add <name>, mifa yank, mifa search, SHA-256 checksums pinned in the lockfile. 847 tests
Nov 10, 2026 v0.13.5-alpha
No new language features: about 74 probe programs, run on both engines, found eight bugs, now fixed. Struct literals are typed by their name, a range loop's end is evaluated once, xs.push(v) is type-checked, and assignment evaluates the value first. astra --version reads Cargo.toml, and the release build checks that tag, Cargo.toml and binaries agree. 856 tests
Nov 11, 2026 v0.13.6-alpha
elif in both syntaxes, default arguments (literal, trailing; a call may leave them off) and sqrt, on both engines. A compound assignment's index runs once. The agent benchmark runs against any model provider, hosted or local, with keys kept out of files and logs. Known issue: on Linux, a sqrt of a value computed at run time fails to link; v0.13.7-alpha fixes it. 868 tests
Nov 11, 2026 v0.13.7-alpha
Linux fixes: native builds link the C math library, so a sqrt of a run-time value links, and every NaN prints as nan. Windows stays on v0.13.6-alpha (same language). 868 tests
Nov 11, 2026 v0.13.8-alpha
The Python habits a model writes first: and / or / not / not in, single-quoted strings, trailing commas, if as a value (a if c else b), statements continued on the next line, unwrap / unwrap_or / is_some / is_ok, clearer errors for import std, and trait default methods. 877 tests
Nov 11, 2026 v0.13.9-alpha
@derive(Eq, Show) on structs: == compares field by field and print shows Point { x: 1, y: 2 }. A struct field whose type ends with > no longer breaks parsing. Linux and Windows builds follow. 880 tests
Nov 11, 2026 v0.13.10-alpha
Enum variants with several values (Rect(float, float)); struct, tuple, range (0..10, 0..=9) and | patterns in match; a function's last expression is its return value; generic structs (struct Stack<T>) with impl<T> methods. A native fn main() without a return type exits 0. Linux and Windows builds follow. 893 tests
Nov 12, 2026 v0.13.11-alpha current
Functions as values: lists take functions (map, filter, fold, sum, ...), enumerate / zip, and functions take fn(int) -> int parameters. Sized integers (u8 to i32) with every result range-checked, as in Rust, and as conversions. Linux and Windows builds follow. 907 tests
Next Trait objects and collections planned
Trait objects (dyn Trait); storing and returning functions; Set, slicing, comprehensions and a math module; @derive(Hash, Ord) and derive on enums; fixes for E0021 and E0020; the remaining memory leaks.
v1.0 v1.0 planned
GPU target, production tooling, hosted Mifa registry; the source opens at v1.0-beta.

Release scope table ↓ · Project story

Every release, in three dimensions

Each column is a release, as tall as its test suite; the latest is darkest. Drag to turn it, or use the arrow keys to step through the releases.

Version	Date	Tests	What changed
v0.13.11-alpha	2026-11-12	907	Functions as values: list map, filter, any, all, count, find, fold and sum with closures or function names, enumerate and zip, for (i, x) in, and fn(..) parameters; sized integers (u8, u16, u32, i8, i16, i32) with every result range-checked, as in Rust, and `as` conversions. Linux and Windows builds follow.
v0.13.10-alpha	2026-11-11	893	Enum variants with several values (Rect(float, float)); struct, tuple, range (0..10, 0..=9) and \| patterns in match; a function's last expression is its return value; generic structs (struct Stack<T>) with impl<T> methods; a native fn main() without a return type exits 0. Linux and Windows builds follow.
v0.13.9-alpha	2026-11-11	880	@derive(Eq, Show) on structs: == compares field by field and print shows Point { x: 1, y: 2 }; a struct field whose type ends with > no longer breaks parsing. Linux and Windows builds follow.
v0.13.8-alpha	2026-11-11	877	The Python habits a model writes first: and/or/not and not in, single-quoted strings, trailing commas, if as a value (a if c else b), statements continued on the next line, unwrap / unwrap_or / is_some / is_ok; trait default methods; clearer errors for import std. Linux and Windows builds follow.
v0.13.7-alpha	2026-11-11	868	Linux fixes: native builds link the C math library (sqrt of a run-time value failed to link with v0.13.6-alpha) and every NaN prints as nan. Windows stays on v0.13.6-alpha.
v0.13.6-alpha	2026-11-11	868	elif in both syntaxes, default arguments (literal, trailing) and sqrt, on both engines; a compound assignment such as shelf[find(k)].qty -= n runs its index once; the agent benchmark runs against any model provider with keys kept out of files and logs.
v0.13.5-alpha	2026-11-10	856	Eight correctness fixes found by about 74 probe programs on both engines: struct literals typed by name, range end evaluated once, xs.push(v) type-checked, assignment evaluates the value first. No new language features; astra --version reads Cargo.toml and the release build checks tag = Cargo.toml = binary.
v0.13.3-alpha	2026-11-06	847	C FFI + static package registry: Calling C with int/float/bool/str; @link for custom libraries; Static registry with mifa publish/add and SHA-256 checksums.
v0.13.2-alpha	2026-11-06	831	Map<K, V>, list sort and sort_by_key, any value in Result and Option: the 8 real-world programs need no workarounds. Mifa: git dependencies, whole-graph version solving, workspaces.
v0.13.1-alpha	2026-11-06	796	String methods: char_at, chars, for c in s, starts_with/ends_with, replace, < and > on strings; Mifa version requirements with Cargo's rules and semver ordering.
v0.13.0-alpha	2026-11-05	777	astra mcp: a Model Context Protocol server any AI agent can use; runtime error codes; Astra as WebAssembly with a Node runner, and the browser playground.
v0.12.2-alpha	2026-11-05	760	Three native wrong answers fixed, found by writing real programs; 20 showcase and 8 real-world examples checked against Python.
v0.12.1-alpha	2026-11-05	756	Native builds on Windows; print and ${} refuse values that native printed as addresses; release check passes on every platform.
v0.12.0-alpha	2026-11-04	754	Every type error has a line; machine fixes and astra fix; memory freed on every exit; bools print true/false; a 55-check release suite.
v0.11.2-alpha	2026-11-02	712	Trait bounds checked at call sites, impl signatures checked (E0020); loops no longer leak.
v0.11.1-alpha	2026-11-02	699	Released binaries compile natively: the C runtime is embedded in the compiler.
v0.11.0-alpha	2026-11-02	695	Value semantics, indentation syntax and astra fmt, type inference, nominal traits and trait bounds.
v0.10.0-alpha	2026-10-30	609	Interpreter with native parity and fuzzing; modules; program I/O with capabilities; runtime traps; mifa build and run.
v0.9.1-alpha	2026-07-15	449	First binaries for four platforms; callable closures; ARC memory reclamation; the compiler never panics on bad input.
v0.9.0-alpha	2026-07-09	—	Nominal structs, enums with payloads, ? and try/catch, tuples, impl blocks, bitwise operators.
v0.8.0.1-alpha	2026-07-07	—	Rust and Go join the cross-language benchmark suite, with every program output checked.
v0.8.0-alpha	2026-07-07	285	The LLVM-IR backend becomes the default; async/await; ignored tests 10 to 0.
v0.7	2026-07-06	—	Source spans, structs, Result and closures native, REPL, dyn, astra explain; Mifa lockfile and registry protocol.
v0.6	2026-06	—	Honest alpha reset: JSON diagnostics, verify mode, the verify-repair-compile loop.
v0.5	2025-11	—	Native compilation, Docker CI, first pre-built binaries.
v0.4	2025-10	—	The package manager gets its name: Mifa.
v0.1	2025-10	—	The idea becomes code: easy like Python, safe and fast like Rust, built for agents. Lexer, parser, first AST.

Memory, before and after

Peak memory of four programs that used to leak, built natively. The tall columns are before; the short ones are after memory was freed on every exit (v0.12).

Case	Before	After
Helper called 1M times building a struct, list and tuple	231 MB peak	1.3 MB peak
A function returning a new string, 1M calls	47 MB peak	1.3 MB peak
A list of fresh strings per iteration, 200k	20 MB peak	1.3 MB peak
A template literal per iteration, 200k	20 MB peak	1.3 MB peak

Package manager progress

Mifa's five local milestones are complete, and a static, self-hosted registry works; only a central hosted registry is still to come.

M1 local

100%

M2 lock

100%

M5 json

100%

M3 registry

100%

M4 publish

100%

Capability	Status	Evidence
`mifa init`: project scaffolding	shipped	Integration-tested manifest + src layout
`mifa add`: dependency management	shipped	Manifest round-trip tests; validates the package; `--path` (v0.10), `--git` (v0.13.2) or a registry package by name (v0.13.3)
`mifa verify`: manifest + layout validation	shipped	7 failure modes + success path tested; type-checking the project is planned
`mifa build` / `run` with importable path dependencies	v0.10	End-to-end test drives the real binary: init → add --path → build → run
`mifa lock`: reproducible lockfile	shipped	sha256-stable across runs (validated)
Path dependencies	shipped	Resolve from local `astra.toml`
Cache (`~/.mifa/cache`)	shipped	`MIFA_CACHE_DIR` override supported
`mifa clean [--cache]`	shipped
`mifa --version`	v0.12	Prints the Mifa version
`mifa search`	v0.13.3	Searches a registry folder (a static web host cannot list); v0.12 said no registry was deployed, and v0.11.2-alpha and earlier listed packages that do not exist
M5-basics: `--json` on local commands	shipped	Stable JSON envelope (`command`, `success`, `diagnostics[]`) on `init`/`add`/`verify`/`test`/`lock`/`login`/`publish`; JSON error envelope on failure
M3: Registry protocol	shipped	`/v1/packages` v1 API (`RegistryApi` trait), SHA-256 checksums with verification, yanked-version handling, stable `REG4xx` error codes; 34 tests
M4: Publish + auth	shipped	`mifa login` (per-registry tokens, 0600 credentials file), `publish --dry-run` (semver/license validation, deterministic archive, 10 MiB limit, checksum report)
Static registry (folder or static web host)	v0.13.3	`mifa publish` into a folder (versions never change), `mifa add <name>`, `mifa yank`; SHA-256 checked on download and pinned in `astra.lock`; `--offline` from the cache
mifa.dev hosted registry	v1.0	A central public registry with accounts and uploads is pending; static self-hosted registries work today. Checksummed packages; lockfile contract goes global

90+ tests cover the package manager: manifest parsing, version requirements, resolution (direct + transitive), lockfile stability, JSON envelopes, the registry protocol, and publish/auth flows.

Design investment, tracked like a feature

Astra's thesis is that when code generation is free, the strategic layer, the design investment Ousterhout says tactical programming skips, must live in the language and be enforced by the compiler. That claim is only honest if each piece of the strategic layer is tracked and tested like any other feature. This table is that commitment:

Strategic guarantee	Mechanism	Status
Interfaces can't drift silently	Static types + inference	shipped v0.6
Errors are values, not surprises	`Result<T,E>` + exhaustive `match` + `?` operator	shipped v0.6 · `?` v0.9
Feedback is a machine contract	JSON diagnostics, stable E-codes, `suggestion`, `astra explain`; machine-applicable `fix` edits and `astra fix` (v0.12)	shipped v0.7
Flexibility is explicit, never accidental	`dyn` gradual-typing boundary	shipped v0.7
Builds are reproducible	Mifa sha256-stable `astra.lock`	shipped M2
Memory correctness without generator burden	ARC + escape analysis (no GC, no lifetimes)	reclaiming since v0.9; every exit and owned strings since v0.12
Generated code runs in a cage	WASM sandbox target	planned
Tool schemas can't lie	`tool` keyword, signature is the schema	planned
Agent state is typed, prompts are checked	`agent` / `memory` / `prompt` keywords	planned
Delegation graphs typecheck end-to-end	Agent-to-agent contracts, verified at compile time	planned
One strategic layer, every target	Single compiler → native / WASM / GPU	v1.0

Scorecard: 5 of 11 strategic guarantees shipped, 1 in progress, 5 planned. The paradigm behind this table is on the home page; the release plan that delivers the rest is on the vision page.

Validated performance claims

Numbers on this site come from a scripted validation harness in the repo (scripts/validate_metrics.sh, 12/12 checks passing), not from marketing copy:

115 ms: Astra compile and run of a 5M-iteration loop (Python: 959 ms run-only)
113 ms: astra verify full typecheck of a program, no codegen
4/4: classes of agent mistakes (undefined vars, type errors, arity, bad returns) rejected before execution
sha256-stable: astra.lock byte-identical across repeated resolutions

Ratified architecture decisions

Five foundational bets were debated and locked on 2026-07-02. They set the direction through v1.0 and can only change through a documented amendment process.

Bet	Decision
1, Memory model	ARC + escape analysis + `region` (no GC, no borrow checker)
2, Typing discipline	Static by default; gradual via explicit `dyn` boundaries
3, Backend	One LLVM compiler, three targets: native, WASM, GPU
4, AI primitives	`tool`/`agent`/`prompt`/`memory` as language keywords
5, Python interop	Embedded CPython in the standard library