We build industry compilers.
We are a German engineering company building compiler technology for industrial systems software. Our work is native code generation, static program analysis, and the kind of correctness guarantee you can put in front of an auditor: not a linter, not a runtime detector, but a proof the compiler performs before it emits a single instruction.
Mica proves at compile time what other systems languages leave to the debugger: heap lifetimes, data-race freedom, and array bounds — with no garbage collector, no borrow checker, and no lifetime annotations.
A statically typed systems language with an optimizing native backend, compiled to Linux x86_64 and AArch64 ELF with DWARF v5 debug information. No LLVM, no GCC backend — every phase from lexical analysis through SSA optimization and register allocation is ours, with zero external dependencies.
Every touch of shared state must be spelled synchronized.
Touch a global or an ancestor activation's cell without the mark —
directly, or through a call several frames down — and it is a
compile error, not a lint. Unmarked code is not shared code, so a
reviewer's search space collapses. The same source runs on one carrier or
many, with no source change and byte-identical output at one.
Every allocation creates an obligation. Wherever the compiler can follow the pointer, it must see that obligation discharged on every path, and an undischarged cell is a build error. Where a pointer escapes what the analysis can follow, Mica does not guess and does not pretend — it narrates exactly what it could not prove, and a checked build traps rather than corrupts. No annotations to write, and no correct program rejected.
Hosted, or freestanding fixed-arena with no OS heap at all —
selected when you link, with byte-identical code generation across both,
verified down to matching object-file hashes. Compiler-scheduled regions
run inside either. The intermediate language never names
malloc, so one source tree serves a Linux server and a
statically budgeted embedded target.
Parallel linear algebra is bit-identical to serial at every carrier count, because partitioning never splits an accumulation. Floating-point contraction decides identically on both backends. Parallel reductions are refused rather than silently approximated. Carrier count is fixed at compile time: one binary, one known degree of parallelism.
A tensor declared on gpu keeps its type and moves its
storage; values cross only at visible ToDevice /
ToHost, and a hidden transfer is a compile error. The
tensor verbs — the same vocabulary the language's autograd tape
records — dispatch to the device through PTX the compiler ships
itself: an NVIDIA card and its resident driver are the whole
requirement, and device results are digit-identical to host results.
A complete GPU program with no kernel in
it →
An imported C function is a failing function. The
-1/NULL/errno conventions are
declared once in a contract and lifted at the call site into the
language's failure channel. Curated contract packs cover the C standard
library, POSIX and Linux. Mica links into an existing C program one
module at a time, and both halves step in a single debugger session.
206,757 lines of pure Go across 750 files, an empty dependency set, and the GNU assembler and linker as the only external tools. Adopting Mica means trusting one vendor, not a vendor plus everyone who ever contributed to a dependency it pulls in.
Figures as of 2026-08-28, compiler 7.4.0.
The numeric foundation and the training library ship together: tensors whose shapes arrive with the data, any rank, a linear-algebra library on the failure channel, explicit expansion instead of silent broadcasting, a complete training toolkit with visible optimizer state — and the whole vocabulary running resident on an NVIDIA GPU, printing loss columns digit-identical to the host run.
Remarks arrive: hints from the compiler's own knowledge about your code, spoken only when asked and never gating a build — six of them at first light, each explaining a place where Mica is different by design. Beside them, the callback kind meets the C world's callback-shaped APIs, libraries learn to export generators and borrowed handles across their contracts, and VS Code extension 4.1.0 puts all of it in the editor: remarks in the Problems panel with a status-bar counter, and the snippet family returns.
The libraries shelf opens with sqlite: prepared queries with binds, a generator-driven pull road, text columns, failure on the language's own channel — shipped as source you copy into your project, built by one Makefile that bakes C and Mica together.
A short notice and an apology: the starter repository briefly carried examples predating Mica 7.2.0's stricter compile-time checks. One git pull — or a fresh clone — puts it right, and the repository's own gate now makes this class of slip impossible to ship quietly.
One directory in the starter repository sets a machine up, creates one in the cloud when the desk is not big enough, and measures what the compiler does against gcc. Three commands, both major clouds, Linux and macOS, and one command between a fresh checkout and an editor open on a machine that did not exist a few minutes ago.
Training a network becomes ordinary Mica: values that record onto the language's own autograd tape, one Backward walk answering every gradient, GPU residency checked at compile time, and formulas written with their own glyphs. Shipped together with VS Code extension 4.0 — Mica Notebooks whose outputs are verified facts, one-click run and debug, and a stopped program that narrates its own task tree. A complete GPT trains in pure Mica, and a twelve-chapter course teaches the road to it.
With 7.1 the SDK becomes a complete product of its own: the runtime floor ships as its own package under a licence written for toolchains, your emitted programs link no Mica standard library, and a compiler you build on Dragon installs and works without the Mica compiler anywhere on the machine.
One day after 7.0.0: a case must now say what happens to every value of its selector, and the three comparison spellings Mica does not have each answer with the two it does.
The largest release Mica has shipped, and the only breaking one it will ever ask for: one naming pass and then a frozen surface, generics over shapes, slicing without roulette, a borrowed span under a visible lending law, bit-exact reductions, a stream that may fail, and a network line from worker pool to a typed value stream over the wire.
6.12.6 ships the Dragon SDK — the engine that compiles Mica, as a static archive and a C header a compiler in any language can drive. Wirth's PL/0 is the worked example, written twice against the shipped artifacts alone, and building it found ten defects in 6.12.5 that are fixed at the root.