Mica Backlog

Actionable continuation of the Mica Roadmap. Read the roadmap for direction and release framing. Read this file for the detailed execution queue.

Current version: 4.5.0 · Linux x86_64 · System V AMD64 ABI · DWARF v5 Canonical date: 2026-03-22 Build evidence: scripts/build-compiler.sh passes · go run ./tests/cmd/mica-test run passes · -stress passes Stress timings: StressLOC100k: 6.687 s · StressLOC10k: 718 ms · StressLOC1k: 142 ms Planning state: .backlog/current/ is intentionally empty today. The active planning surface is this backlog plus the roadmap; closed detailed plans live in .backlog/archive/ in the compiler repository.

Recent closures already folded into this baseline:

Pascal-compatible static array index types and cross-compilation-unit index-type identity are closed; see archived plan-pascal-compatible-array-index-types.md.
Compiler-wide ordinal storage/arithmetic/indexing/interop/debug coherence is closed; see archived plan-ordinal-integration-coherence.md.
Non-string aggregate/library interop topology closure is closed on the validated Linux x86_64 platform; see archived plan-library-foundation-and-string-separation.md.

For strategy, release framing, and the interoperability vision, read the Mica Roadmap. For the full language and compiler description, see the Technical Portrait.

Release 4.6 — Language Ergonomics & Library (Active, Q2 2026)

Language ergonomics

Item	Status	Window	Why
variable initialization expressions	planned	Q2–Q3 2026	reduce boilerplate; make numerical and worker-style code read naturally
extended `case`: label lists and label ranges	planned	Q2–Q3 2026	finish the classic `case` surface; the `4.5` form only has single constant labels
richer `for` surface: step expressions and deferred forms	planned	Q2–Q3 2026	revisit loop surface explicitly left out of `4.5`
`panic` and `assert`	planned	Q2–Q3 2026	one simple non-returning mechanism for impossible states; no exception system
`checked_bounds`	planned	Q2 2026	explicit runtime bounds safety for subranges and array/string indices

panic design direction:

for impossible states, not expected failures
no recover, no stack unwinding, no general exception system
optional string-literal payload (stays in read-only data; no dynamic allocation)
assert lowers to panic
expected failures move toward typed outcome/result values

Illustrative future syntax (not current compiler syntax):

panic;
panic "invalid parser state";
assert x > 0;
assert x > 0, "x must be positive";

Standard library surface

Complete the library surface a developer expects when writing medium-sized programs. Library namespaces lowercase. Callable API PascalCase. Same rule as std.

Strings (str) — planned, Q2–Q3 2026

Function	Description
`Length(s)`	character count
`Copy(s, from, count)`	substring extraction
`Pos(needle, haystack)`	find substring; 0 if not found
`Insert(src, var dst, pos)`	insert at position
`Delete(var s, from, count)`	remove characters in range
`Str(value, var s)`	numeric value to string
`Val(s, var result, var errorPos)`	parse numeric value from string

Ordinals and characters — planned, Q2–Q3 2026

Function	Description
`Ord(x)`	ordinal domain value to integer
`Chr(n)`	integer to character
`Succ(x)`, `Pred(x)`	next and previous in ordinal domain
`Inc(var x)`, `Dec(var x)`	in-place increment/decrement
`High(T)`, `Low(T)`	bounds of ordinal type or array index type

Numeric (std/math) — planned, Q2–Q3 2026

Function	Description
`Abs(x)`	absolute value — integer or float
`Sqr(x)`	square — integer or float
`Round(x)`	float → nearest int64
`Trunc(x)`	float → truncated int64
`Int(x)`	float → integer part as float64
`Frac(x)`	float → fractional part as float64
`Odd(x)`	true if x is odd
`Max(a, b)`, `Min(a, b)`	maximum and minimum

Program control (std) — planned, Q2 2026

Function	Description
`Halt`	terminate with exit code 0
`Halt(exitCode)`	terminate with explicit exit code

File I/O (std) — planned, Q2–Q3 2026

Function	Description
`Open(var f, path)`	associate file variable with a path
`Reset(var f)`	open for reading
`Rewrite(var f)`	open for writing (truncate)
`Append(var f)`	open for appending
`Close(var f)`	close file
`Eof(f)`	true at end of file
`EoLn(f)`	true at end of line

Standard library modernization

Item	Status	Window	Why
classic-style standard library modernization	planned	Q2–Q3 2026	turns `interop/standard/mica-stdlib.c` into a stronger language-facing surface

Direction: stay UTF-32 first at the language level; keep string zero-terminated and interop-ready; use classic structured naming (stringpart, stringbuffer, stringpool, cstring) rather than copying slice-heavy or UTF-8-first designs. Make concatenation and formatting destination-driven so the compiler/runtime can reserve once and fill once.

String runtime

Item	Status	Window	Why
UTF-32-first terminated string model (`string`)	planned	Q2–Q3 2026	keeps Mica classically structured; keeps wide-C interop direct
borrowed text ranges (`stringpart`)	planned	Q2–Q3 2026	substring/tokenization without allocating a new terminated string
mutable text construction (`stringbuffer`)	planned	Q2–Q4 2026	destination-driven append/format/replace without temporary-object storms
explicit narrow C boundary (`cstring`)	planned	Q2–Q4 2026	UTF-32-first Mica with clean access to narrow `char*` APIs
temporary text regions (`stringpool`)	research	Q3–Q4 2026	arena-style temporary text; heap/lifetime model must exist first

Interop and contracts

Item	Status	Window	Why
compiler-emitted JSON contracts for Mica libraries	planned	Q2–Q3 2026	library publish and library import use the same contract artifact
header-assisted C contract bootstrap from well-formed headers	planned	Q3–Q4 2026	lowers the cost of reusing established C libraries
ABI-scoped contract interfaces with dot-call surface	planned	Q3–Q4 2026	namespace-like grouping without OO class machinery
curated C library contract packs	planned	Q2–Q3 2026	makes interop reusable across projects instead of ad-hoc per project
embedded core contracts plus example packs for broader libraries	planned	Q2–Q3 2026	keeps the built-in surface small with solid external patterns
library-first deployment model without package manager	planned	Q3–Q4 2026	OS/toolchain locates binaries; contracts provide the typed metadata layer
POSIX and Linux API access (without threading)	planned	4.6 → 4.7+	practical systems access; first wave: `posix` and `linux` contract packs

SSA foundation

Item	Status	Window	Why
SSA transformation for Mica IL	planned	Q3 2026	optimizer base for global analysis and later AI work
dominator tree, frontiers, and phi-node placement	planned	Q3 2026	prerequisites for all SSA-based optimization

Classic language completion (deferred from 4.5)

Item	Status	Window	Why
variant records	deferred	Q2–Q3 2026	major classic aggregate feature on top of the trusted record baseline
conformant arrays	deferred	Q2–Q3 2026	classic procedure-interface and array abstraction compatibility
`with` statement	deferred	after 4.6	touches aliasing and selector semantics; not safe to rush
typed `outcome`/`result` return values	research	after variant records / 4.7+	explicit success/failure returns without exceptions or multi-value signatures

outcome direction: prefer one typed return object over multi-return slots as the primary error model. Build on Mica’s existing automatic return-variable model. Keep success and failure paths word-oriented and visible in source. Avoid punctuation-dense syntax.

Illustrative future syntax (not current compiler syntax):

function ParseInt(s : string) : outcome int64, ParseError;
begin
    if IsValidInt(s) then
        success ParseInt := ToInt(s)
    else
        failure ParseInt := InvalidDigit;
end;

This direction only becomes credible once tagged result representation, pattern inspection, and variant-style data modeling are in place.

Tooling

Item	Status	Window	Why
LSP and editor tooling	research	Q3–Q4 2026	improves usability, teaching workflow, and adoption
contract schema and compatibility policy	planned	Q3–Q4 2026	stable toolchains, library publication, long-lived academic examples
benchmarking and profiling evidence	planned	Q3–Q4 2026	keeps performance claims grounded in repeatable measurements
platform/support-matrix hardening	planned	Q3–Q4 2026	clarifies what Mica truly supports beyond Linux `x86_64`

Release 4.7 — Language Completion & Heap (Planned, Q3 2026)

Heap and lifetime

Item	Status	Window	Why
heap memory (`new`, `dispose`)	planned	Q3 2026	explicit heap instead of pointer-only stack-oriented programming
owned dynamic arrays (heap-backed, not slices/views)	planned	Q3 2026	variable-size aggregates without importing slice aliasing semantics
`defer dispose` and `defer until`	planned	Q3 2026	deterministic cleanup without GC; `defer until` fits nested procedures well
ownership diagnostics and escape analysis	planned	Q3 2026	connects source-level lifetime policy to stack-vs-heap storage decisions

SSA optimizer (completion)

Item	Status	Window	Why
liveness and alias analysis	planned	Q3 2026	SSA optimization prerequisites
loop analysis	planned	Q3 2026	loop-aware code improvement passes
register allocation and spill reduction	planned	Q3 2026	raises Mica from correct to efficient code generation
range analysis and bounds-check elimination	planned	Q3 2026	connects `checked_bounds` policy to the optimizer
broader global optimization passes	planned	Q3 2026	industry-grade code quality beyond initial SSA passes

Concurrency substrate

Item	Status	Window	Why
atomics and concurrency memory model	research	Q3 2026	prerequisites for safe worker/threading support
structured lexical workers with synchronized captures	research	Q3 2026	concurrency model that fits nested procedures; not mainstream task APIs
coroutines and generators	research	Q3 2026	first suspension model before a larger async I/O runtime

Record interfaces

Item	Status	Window	Why
record-bound static interfaces with explicit `this` receiver	research	Q3 2026	data-plus-behavior abstraction without virtual dispatch or OO class machinery; `this` receiver stays explicit in the signature

4.8 — Optimizer, Concurrency & Hardening (Q4 2026)

Item	Status	Window	Why
full SSA optimizer: broader global passes	planned	Q4 2026	industry-grade code quality beyond the initial 4.7 SSA foundation
structured worker concurrency model (synchronized captures)	planned	Q4 2026	workers that cooperate through nested-procedure scope, not free-floating threads
async I/O runtime model	planned	Q4 2026	on top of coroutines and POSIX; not a second unrelated execution model
deeper POSIX and Linux API coverage	planned	Q4 2026	second wave of platform access where the 4.7 contracts prove useful
`bit-core`: `bitset[N]`, `int[N]`, `uint[N]`	planned	Q4 2026	unifies set semantics with lower-level bit and wide-integer programming
benchmarking and profiling evidence	planned	Q4 2026	keeps performance claims grounded in repeatable measurements
platform/support-matrix hardening on x86_64	planned	Q4 2026	clarifies what Mica truly supports before expanding to a second architecture

5.0 — Mica Complete on x86_64 (Q2 2027)

5.0 is where the 4.x incremental work crystallizes into a complete, coherent product. All items below are prerequisites already landed in 4.6–4.8.

Item	Status	Window	Why
complete language surface	planned	Q2 2027	heap, variant records, conformant arrays, dynamic arrays, `with`, typed error returns, concurrency — all working
x86_64 fully hardened and production-tested	planned	Q2 2027	DWARF v5, benchmarks, profiling evidence, support matrix clear
SSA optimizer with register allocation and range analysis	planned	Q2 2027	full optimizing compiler, not just a code generator
LSP and editor integration	planned	Q2 2027	developer tooling mature enough for real use

5.5 — ARM64 & Multi-Platform (Q4 2027)

5.5 brings the complete 5.0 language and optimizer to a second production architecture. The language does not change. The optimizer does not change. A new architecture lands.

Item	Status	Window	Why
Linux `AArch64` emitter	planned	Q4 2027	next realistic architecture; AAPCS64 already in platform layer; ELF/Linux fits current infrastructure
x86_64 + ARM64 both production-tested with DWARF v5	planned	Q4 2027	Mica runs on the two dominant Linux architectures
macOS target support	deferred	after Linux AArch64	requires a separate Mach-O and Apple-toolchain story

6.0 — AI-Native Mica (2028)

6.0 is where the “Born for AI” tagline becomes a language reality. The complete language and optimizer foundation of 5.0 make these items achievable without shortcuts.

Item	Status	Window	Why
native vector and matrix built-in types	planned	2028	first-class substrate for AI and numerical programming
compile-time dimension and shape checking	planned	2028	turns many AI-programming mistakes into compiler errors
mathematical notation with ASCII equivalents	planned	2028	formulas that read like mathematics, not like pointer arithmetic
CPU SIMD lowering for vector and matrix operations	planned	2028	numerical built-ins map to real hardware before GPU work begins
mixed-precision and AI-oriented numeric types	planned	2028	targets efficient training and inference workflows
compiler-native autodiff	planned	2028	gradients inside the compiler, not outsourced to a runtime framework
GPU offload and accelerator lowering	planned	2028	only after CPU vector semantics are solid
AI library contracts (BLAS, cuBLAS, oneDNN) and REPL	planned	2028	the AI direction becomes a usable programming environment

Completed: 4.5 Release Record

Release theme: get as close as practical to a complete classic statement baseline, then reset the public source surface before the first public release.

Workstream	Status	Result
`for` statement (`to`/`downto`)	done	ordinal `for` with ISO-like syntax, end-to-end through harness
`repeat…until`	done	classic post-test loop, parser through harness
ordinal `case`	done	selector, constant labels, optional `else`; label lists/ranges deferred to 4.6
public library API naming reset	done	library namespaces lowercase, callable API `PascalCase`, no legacy spellings in shipped source
`process` library	done	`ProgramName()`, `ArgCount()`, `Arg(index)` — parameterless `program` entry point
concurrent assembly persist and export	done	driver-side per-CU parallelism using `parallel()` pattern; deterministic diagnostics
backlog simplification	done	active planning surface reduced to roadmap + backlog
`with` statement	deferred	keyword at token level only; aliasing semantics unresolved

4.5 compatibility rules (baked in)

No semicolon immediately before any else — consistent for both if…else and case…else
begin…end is the required escape hatch for multiple statements before else
program is always parameterless; process arguments arrive through the process library
Keywords lowercase · library namespaces lowercase · callable API PascalCase
No legacy lowercase public spellings in shipped Mica source artifacts
case v1: ordinal selector, single constant labels, optional else — label lists and ranges are a 4.6 item
for v1: ordinal, to/downto, no arbitrary step expressions

Release 4.6 — Language Ergonomics & Library (Active, Q2 2026)#

Language ergonomics#

Standard library surface#

Standard library modernization#

String runtime#

Interop and contracts#

SSA foundation#

Classic language completion (deferred from 4.5)#

Tooling#

Release 4.7 — Language Completion & Heap (Planned, Q3 2026)#

Heap and lifetime#

SSA optimizer (completion)#

Concurrency substrate#

Record interfaces#

4.8 — Optimizer, Concurrency & Hardening (Q4 2026)#

5.0 — Mica Complete on x86_64 (Q2 2027)#

5.5 — ARM64 & Multi-Platform (Q4 2027)#

6.0 — AI-Native Mica (2028)#

Completed: 4.5 Release Record#

4.5 compatibility rules (baked in)#