Progress tracker

ReleasesWhere each version stands

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
Next	Traits, generic structs, typed collections, LSP alpha, astra fmt, stdlib core; then tool / agent / prompt / memory keywords, agent SDK, sandbox	planned
v1.0	GPU target (NVPTX), production tooling, hosted Mifa registry	planned

What's nextThe work queue, in priority order

v0.8 and v0.9 are closed. The current phase is narrow & harden: make what exists sound and honest before widening the surface. The committed 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	Consolidate the two codegen paths	The legacy string-emission backend (--llvm-native) duplicates the default ir.rs path — a maintenance risk to retire
5	Traits, generic structs, typed collections	Currently gated with clear errors, not faked; Vec<int> is the minimal first slice
6	LSP alpha + astra fmt + stdlib core	Diagnostics-on-save first (reuses the JSON pipeline); formatter makes agent diffs reviewable; collections/string/fs surface

#	Mifa	Why it's next
1	mifa build --json + real mifa test discovery	The last gaps in the agent-native local story; JSON snapshot tests lock the envelope contract
2	HTTP registry client	Implements RegistryApi over HTTP — the trait means resolver code doesn't change
3	Staging registry + real mifa publish	Smallest deployable /v1/packages service; --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.

The strategic layerDesign 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	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 — loop + function scope; string aliasing pending
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.

AstraLanguage feature matrix

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 (a full Hindley-Milner solver exists but is not wired into the pipeline)
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); --legacy-c fallback
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.9	Unit variants + single-payload data variants (int, string, struct payloads via boxed repr), match in expression and statement position; multi-field variants gated with a clear error
Result<T,E> + match + ?	working	Ok/Err paths, match binding; ? unwraps Ok/Some or early-returns Err/None (v0.9); built-in Result payloads currently int-like — user enums for richer payloads
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.9	Lambda-lifting before typecheck (the v0.7 pipeline-order bug is fixed); v0 is int-typed closures on the default path
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)	working	Generic functions specialize per concrete type; generic structs and traits are gated, not implemented
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
Bitwise + compound operators	v0.9	& | ^ ~ << >> with Python-parity precedence; += family, **, radix literals
Float arithmetic / compare	v0.7	Native fadd/fcmp with int→double promotion
JSON diagnostics with line + column	working	Parse + named-symbol typecheck spans
Rich diagnostics: error_code, suggestion, astra explain	v0.7	Stable E0001–E0012 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). String-aliased values and some non-loop scopes still leak — bounded and safe, never a double-free
async / await	v0.8	Parses + compiles natively; synchronous lowering — real task runtime still ahead
Traits + generic structs	next	Gated with clear errors today, not silently faked
WASM target	planned	Also unlocks a browser playground
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.

MifaPackage manager progress

Capability	Status	Evidence
mifa init — project scaffolding	shipped	Integration-tested manifest + src layout
mifa add — dependency management	shipped	Manifest round-trip tests
mifa verify — workspace typecheck	shipped	7 failure modes + success path tested
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
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)
mifa.dev hosted registry	v1.0	Protocol done; HTTP client + hosted deployment pending. 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.

DirectionRatified 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

MeasuredValidated 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