Mica Roadmap

Tagline: Structured clarity. C control. Born for AI. Canonical date: 2026-03-22 Version context: the compiler currently reports 4.5.0

For a comprehensive technical description of the language and compiler internals, read the Technical Portrait. For the detailed execution queue, read the Backlog.

A note on accuracy
Mica is developed by a single engineer working with AI assistance. This roadmap and the accompanying backlog represent the best current thinking about direction, sequencing, and scope — but they are living documents, not contracts. Specific names, API spellings, library namespaces, and feature boundaries will change as implementation reveals what actually works. Inaccuracies and inconsistencies between documents can and do occur.
What will not change is the direction and the vision. The platform philosophy, the commitment to explicit semantics, the structured-language foundation, and the AI trajectory are stable. Everything else is subject to revision as the compiler grows.
Mica 4.5 is the first public release. The compiler is verified by a test harness spanning 576 Mica programs, but as with any first release, unexpected limitations may still be encountered. The compiler, the VS Code extension, and the tutorials are under intensive development throughout 2026 — changes can and will occur. The primary goal for 2026 is a consistent, well-designed Mica core language with a complete standard library. Known gaps — including heap memory allocation, a string library, and further standard library coverage — will be addressed in the course of this work.

The Platform Vision

Mica does not build a private ecosystem. It opens the one that already exists.

The world already has decades of proven C libraries, POSIX interfaces, Linux kernel APIs, and battle-tested system runtimes. They are not going anywhere. Every HTTP client, every database driver, every numerical toolkit, every operating system interface — already written, already tested, already running on billions of machines. Mica’s goal is not to replace any of that. It is to make all of it immediately and safely accessible from structured, readable source code.

Most new languages ask developers to wait while an ecosystem is built from scratch. Mica takes the opposite position: the ecosystem already exists. It is the entire C ABI world — and Mica is designed to reach every part of it directly.

The JSON contract system is the mechanism. Every C library surface, every POSIX API, every Linux syscall that follows a stable ABI can be described in a contract file and reached from Mica source with full type checking, format-string validation, and compile-time safety. A Mica binary and a C library binary are the same kind of object. They link together directly under the System V AMD64 ABI. No adapter layer. No runtime bridge. No reimplementation required.

This principle shapes every architectural decision in Mica:

The standard library grows by surfacing what already exists, not by reimplementing it.
The planned posix and linux contract packs give Mica programs access to the full Linux OS API without leaving the language.
C interop is first-class, not an escape hatch. A contract file is how you reach any C library — whether it ships with Mica or was written a decade before Mica existed.
Mica programs and C programs share one binary world. They call each other, link together, and cooperate under the same ABI with no performance tax at the boundary.

The measure of success is not how many libraries Mica ships. It is how quickly a developer can reach any library that already exists — including libraries written years from now.

Mica augments the platform. It does not compete with it.

Where We Are

4.5 is closed. As of 2026-03-22 the verified baseline is:

Target: Linux x86_64, System V AMD64 ABI, DWARF v5, GNU binutils ELF flow
Type system: integers, floats, booleans, characters, enumerations, subranges, sets, records (packed/ordinary), arrays (packed/ordinary, with lower bounds and Pascal-compatible ordinal index types), pointers, files
Statements: assignment, call, begin…end, if, while, repeat…until, for…to/downto, case, leave
Library surface: std, process, limits, cstd, math
Ordinal coherence: supported ordinal surfaces are now coherent across storage, stepping, indexing, interop, aggregate ABI classification, and DWARF handling
Interop: JSON-based C contracts with format-string analysis, cross-compilation-unit imports/exports, and validated non-string aggregate transport across the supported library topologies
Evidence: scripts/build-compiler.sh passes · full harness passes · stress passes
Planning surface: .backlog/current/ is intentionally empty today; active planning lives in the backlog and roadmap, with closed detailed plans archived under .backlog/archive/ in the compiler repository

Recent Closures Already In The 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 integration and coherence are closed; see archived plan-ordinal-integration-coherence.md.
Non-string aggregate/library interop topology closure is closed on the supported Linux x86_64 platform; see archived plan-library-foundation-and-string-separation.md.

Release Overview

Release	Theme	Status	Target
`4.5`	First public baseline — control flow, API naming, process library	Closed	March 2026
`4.6`	Language ergonomics · stdlib surface · contracts · SSA foundation	Active	Q2 2026
`4.7`	Language completion · heap model · SSA optimizer · concurrency substrate	Planned	Q3 2026
`4.8`	Full optimizer · concurrency model · POSIX/Linux · hardening	Planned	Q4 2026
`5.0`	Complete language · optimizing compiler · x86_64 production	Planned	Q2 2027
`5.5`	ARM64 backend · multi-platform	Planned	Q4 2027
`6.0`	AI-native language and compiler	Planned	2028

4.5 — First Public Baseline (Closed)

Release theme: finish the release-facing compiler story without rewriting the compiler.

Done:

for statement (ordinal, to/downto, ISO-like syntax, end-to-end through harness)
repeat…until — classic post-test loop
ordinal case — selector, constant labels, optional else
public library API naming reset — library namespaces lowercase, callable API PascalCase
process library — ProgramName(), ArgCount(), Arg(index), parameterless program
concurrent assembly persist and export in the compiler driver
backlog simplification — active planning surface reduced to roadmap + backlog

Design rules baked in:

No semicolon before any else — applies equally to if…else and case…else
begin…end is the escape hatch for multiple statements before else
program is always parameterless; process arguments come through the process library
Keywords lowercase · library namespaces lowercase · callable API PascalCase

Closure evidence: StressLOC100k: 6.687 s · StressLOC10k: 718 ms · StressLOC1k: 142 ms

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

Theme: grow Mica to the point where a developer can write medium-sized programs and libraries without running into systematic gaps.

Language ergonomics

variable initialization expressions (declaration + value in one step)
extended case: label lists and label ranges beyond the minimal 4.5 form
richer for forms: step expressions and other deferred surface questions
panic and assert — one simple non-returning failure mechanism; no exception system
checked_bounds — explicit runtime bounds safety for subranges and array/string indices

Standard library surface

A structured-language standard library for medium-sized programs needs more than WriteLn. The following names are the target for 4.6. Library namespace: str, std, math. Callable API follows the same PascalCase rule.

Strings (str):

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:

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):

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):

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

File I/O (std):

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

POSIX and Linux:

posix contract pack: file I/O, process, signals — no threading in the first wave
linux contract pack: syscall-level access via curated contracts and examples

String runtime

stringpart — borrowed derived-text range for substring/tokenization without allocation
stringbuffer — owned growable UTF-32 text for append, format, replace
cstring — explicit narrow C boundary for char* API reachability
stringpool — arena-style temporary text (depends on heap/lifetime track; research)

Direction: stay UTF-32 first, keep string zero-terminated and interop-ready, use classic structured naming rather than copying slice-heavy or UTF-8-first designs.

Interop and contracts

compiler-emitted JSON contracts for Mica libraries (same format as consumed for imports)
header-assisted bootstrap from well-formed C headers to starter contracts
ABI-scoped contract interfaces with dot-call surface for namespace-like grouping
curated contract packs for commonly used C libraries
library-first deployment: OS/toolchain locates binaries, contracts provide typed metadata

SSA foundation

SSA transformation for Mica IL
dominator tree, frontiers, and phi-node placement

Classic language completion (deferred from 4.5)

variant records
conformant arrays
with statement (aliasing and selector semantics must be clear first)
typed outcome/result return values (after variant records; likely 4.7+)

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

Theme: close the classic language surface and introduce the heap model.

Heap and lifetime

new(var p) and dispose(var p) — explicit heap allocation and deallocation
owned dynamic arrays (heap-backed, not slices/views)
defer dispose — deterministic cleanup at scope exit
defer until — nested-procedure-aware cleanup
ownership diagnostics and escape analysis

SSA optimizer (completion)

liveness, alias, and loop analysis
register allocation and spill reduction
range analysis and bounds-check elimination

Concurrency substrate

atomics and a documented concurrency memory model
structured lexical workers built around nested procedures and functions
coroutines and generators as a first suspension model

Record interfaces

record-bound static interfaces with explicit this receiver — data-plus-behavior abstraction without virtual dispatch or OO class machinery

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

Theme: production-grade code quality, concurrent programming, and platform hardening.

full SSA optimizer: broader global passes beyond the initial 4.7 foundation
structured worker concurrency model (synchronized parent-scope captures)
async I/O runtime model (on top of coroutines and POSIX; not a second unrelated model)
deeper POSIX and Linux API coverage where the first wave proves useful
bit-core: bitset[N], int[N], uint[N] — unifies set semantics with bit programming
benchmarking and profiling evidence
platform/support-matrix hardening on x86_64

5.0 — Mica Complete (Planned, Q2 2027)

Theme: the 4.x incremental work crystallizes into a complete, coherent product on x86_64.

5.0 is the release where Mica can say plainly and truthfully:

Language complete: all classic structured-language constructs work — heap, variant records, conformant arrays, dynamic arrays, with, typed error returns, concurrency model
Optimizing compiler: SSA-based with register allocation, range analysis, loop-aware passes
Production quality on x86_64: fully hardened, benchmarked, and profiled
Mature tooling: LSP and editor integration, contract schema versioning, profiling infrastructure

The ARM64 backend follows in 5.5. macOS is deferred until after Linux AArch64 is solid.

5.5 — ARM64 & Multi-Platform (Planned, Q4 2027)

Theme: bring the complete 5.0 language and optimizer to a second production architecture.

Linux AArch64 emitter — AAPCS64, ELF, GNU binutils
the platform layer already models AAPCS64; the infrastructure investment is already made
both x86_64 and ARM64 production-tested with DWARF v5 debug information
macOS support evaluated here — requires a separate Mach-O and Apple-toolchain story

5.5 is a focused release: the language does not change. The optimizer does not change. A second architecture lands on the same solid foundation that 5.0 proves.

6.0 — AI-Native Mica (Planned, 2028)

Theme: the “Born for AI” tagline becomes a language reality.

Language: native vector and matrix built-in types, compile-time dimension and shape checking, mathematical notation with ASCII equivalents
Compiler: CPU SIMD lowering, tensor-aware optimization passes, mixed-precision numeric types, compiler-native automatic differentiation
Platform: GPU offload and accelerator lowering — only after CPU vector semantics are solid
Ecosystem: AI library contracts (BLAS, cuBLAS, oneDNN), contract bundles, interactive REPL for numerical workflows

6.0 follows directly on the complete multi-platform foundation that 5.0 establishes. The AI language features become practical precisely because 5.0 proves the language is complete, the optimizer is production-grade, and the platform story is solid on both architectures.

Strategic Direction

Lens	What Mica takes from it	Why it matters
Structured clarity	readable block structure, nested procedures, records, arrays, sets, ordinal types, structured control flow	keeps the language teachable, analyzable, and suitable for compiler construction audiences
C control	explicit pointers, explicit address/dereference, direct ABI compatibility, contract-based interop	keeps systems behavior predictable and FFI cost visible instead of hidden
AI trajectory	compiler-driven optimization, mathematical notation, future tensor-native semantics	gives Mica a direction stronger than “a classic structured language with extras”

Mica’s near-term value is not that it already is an AI language. Its value is that it is building an AI-ready compiler on a disciplined structured-language/C foundation.

Mica is not pursuing classes, inheritance, or a conventional OO framework model. Abstraction comes from records, procedures, nested functions, and contract-defined interfaces.

Release positioning

Mica is a structured systems language with explicit C-grade control and a roadmap toward AI-native compiler semantics.

That statement is accurate for three audiences:

Compiler construction and university: clean front-end/back-end story with ABI and DWARF discipline
Systems programmers: explicit pointer semantics, no hidden FFI tax, predictable binary behavior
AI and numerical computing: a compiler shaped toward tensor-native optimization rather than retrofitted

Strategic non-goals

Mica is not trying to become an object-oriented class/inheritance language.
Mica is not trying to build a second package ecosystem on top of native libraries.

The Platform Vision#

Where We Are#

Recent Closures Already In The Baseline#

Release Overview#

4.5 — First Public Baseline (Closed)#

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

Language ergonomics#

Standard library surface#

String runtime#

Interop and contracts#

SSA foundation#

Classic language completion (deferred from 4.5)#

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

Heap and lifetime#

SSA optimizer (completion)#

Concurrency substrate#

Record interfaces#

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

5.0 — Mica Complete (Planned, Q2 2027)#

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

6.0 — AI-Native Mica (Planned, 2028)#

Strategic Direction#

Release positioning#

Strategic non-goals#