Mica in one page — the facts

Mica is a statically typed systems language with its own optimizing native backend — no LLVM, no GCC backend, no third-party dependency anywhere in the implementation. It is influenced by Pascal, Ada, and C. Three commitments shape everything on this page: the compiler proves at compile time what most toolchains leave to the debugger; a program’s output is deterministic to the digit — on both architectures, at every optimization tier, and even across serial and parallel execution; and the numeric stack up to a training loop on a GPU is part of the language, not a package ecosystem bolted on.

Everything below can be checked in an afternoon: the compiler is free for any use including commercial, and docker run -it micalang/mica is a complete environment — compiler, debugger, examples, benchmarks.

What the compiler proves at compile time

Each row is a hard guarantee with its own documented mechanism, not a lint:

The rule behind the table is deliberate. Mica proves at compile time what is provable, and for the scenarios today’s analysis cannot prove, a checked build plants a trap: the program stops at a named source line instead of proceeding corrupted. This is the language’s chosen middle way — no ownership model, no borrow checker, no lifetime annotations — because readability and low complexity for the developer are a top priority of the design, not an afterthought. Where a guarantee is usually bought with annotation machinery, Mica researches the pragmatic road to the same result: prove what the compiler can see, trap loudly on what it cannot yet, and move scenarios from the second list to the first with each release. The same discipline governs efficiency and footprint — small binaries, small images, and no runtime cost for features a program does not use.

What stays exact at run time

Determinism in Mica is a language property, not a library option:

• The same digits on every machine. The whole test corpus is gated on both architectures per release; the teaching examples print byte-identical output on x86-64 and AArch64 at every optimization tier.
• Parallel equals serial. Reductions (Sum, Mean, the extremes) run on one documented pairwise tree — the same tree serially and in parallel, so a float reduction gives bit-identical answers at every carrier count. A multicore run of the SIMD benchmarks is bit-identical to the serial run.
• Checked arithmetic. At the checked tier, integer overflow traps at a named source line — scalar and tensor alike — instead of wrapping silently.
• Reproducible randomness. The random unit is seeded and bit-stable on every machine; a shuffled benchmark shuffles identically everywhere.

The practical consequence: a training run — including the GPU-resident one — prints the same loss column on every machine, every time. That claim is on the AI course, where every chapter keeps it.

Machine learning inside the language

Not a framework: language surface, with the compiler’s checks applied to it.

• Autograd is a language feature. tracked values record onto a tape inside a tape … end window; one Backward walk answers every gradient through Gradient. The recorded vocabulary — the tensor operators plus Sum, Tanh, Softmax, LayerNorm, CrossEntropy and their family — keeps each verb’s plain signature and shape rules.
• The GPU is a residency, not a dialect. A tensor declared on gpu keeps its type and moves its storage; values cross only at visible ToDevice / ToHost. The tensor verbs dispatch to the device by residency, through PTX the compiler ships itself — an NVIDIA card of compute capability 7.0 or newer and a resident driver are the whole requirement; no CUDA toolkit is installed. Host and device training produce digit-identical loss columns.
• A GPT is the worked example. The repository’s samples/gpt trains a 786944-parameter transformer with every mechanism above — walked chapter by chapter in the twelve-part AI course, from the first nudge loop to text in your corpus’s style, reproducible to the digit.

The language, briefly

• Values are values. Assignment and argument passing copy, all the way down; sharing is a visible pointer, an address written at the call, a value at every touch — never a hidden reference.
• Errors are a channel, not a convention. fails in the signature, fail to raise, four visible consumption forms at the call — no error codes, no exceptions, no sum types; C’s errno is lifted into typed codes at the boundary by contract.
• Concurrency is structured. Tasks, generators, streams over bounded rings, select with timeout — with the join guaranteed by scope and the capture discipline checked at compile time.
• Generics with capability constraints. One algorithm over many types, monomorphized; constraints (numeric, ordinal, plain, …) are checked against the body and every call.
• Memory is a deployment class. The same source links against the hosted heap or a fixed arena — --memory-class fixed-arena=<bytes>, no code change. A program can run with no heap at all, and indefinitely: drained regions return their blocks for reuse, so a long-running loop’s live set stays bounded inside the fixed budget. Both classes compose with single and multicore tasking, and the test corpus runs under both. The memory-classes tutorial walks it end to end.
• Two build-time string encodings. UTF-32 as the general default, UTF-8 for the boundary — one letter of difference in format specifiers, checked at compile time.

What ships in the language

The standard library is written in Mica — twelve units, resolved by plain imp, no package manager required:

Beneath them, the C standard library, POSIX, and Linux surfaces ship as 25 curated contracts embedded in the compiler binary — imp Open : posix; works on a fresh install with nothing else on disk, every call type-checked, every errno lifted into the failure channel. The Dragon SDK’s own surface is the 26th, for programs that drive the backend.

The toolchain

Where performance stands

Stated the way we measure it, so you can re-measure it:

• The backend is our own, and its optimizer earns its keep: the benchmark corpus retires 46.9% fewer instructions than unoptimized code, with bounds checks proven away rather than merely hoisted.
• Lane-level SIMD reaches 2.33x over scalar on f64 and 4.03x on f32; data-parallel execution on 8 cores reaches up to 4.0x — bit-identical to the serial result at every carrier count.
• On general-purpose code, gcc -O2 still leads; specific numeric loops reach or pass parity. We publish the gap and work on it each release — performance and method carries the numbers and the measurement discipline.
• The benchmarks live in the container you can pull: benchmarks/ beside examples/, each a make away, oracle-checked so a wrong answer fails loudly before a fast one impresses anyone.

The numbers

Figures generated from the repository at 2026-08-23 — no number on this page is typed by hand.

The five goals ahead

The one forward-looking section on this site. In order:

1. A native N-dimensional numeric library — dynamic shapes, explicit broadcasting, dtypes, decompositions born fails — on the tensor foundation, keeping the bit-exact reduction guarantee.
2. A neural-network training library on the language’s own autograd, completing the story the GPT sample begins.
3. User-defined GPU kernels as first-class language citizens, extending the shipped PTX road beyond the curated verb vocabulary.
4. macOS as a full host — today Darwin/ARM64 compiles both Linux targets but cannot link; native linking brings the whole developer story.
5. The comprehensive language reference with a published grammar — every rule normatively stated, the EBNF verified against the parser so it cannot drift.

Beside the five, footprint is a working lane rather than a goal that waits: the next concrete step is a smaller micalang/mica container image, measured and published like every other number on this page.

Where to go next

Install it · the comparison · what the compiler guarantees · the reference · performance and method