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.
201,087 lines of pure Go across 746 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-23, compiler 7.2.0.
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.
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.
A same-day pair after the Dragon SDK launch: two compiler fixes the new debugging tutorial found, and a packaging fix the SDK's first day earned — the Mica-side surface now ships as a file you can read, and the SDK's dependency on the compiler finally says why.
The engine that compiles Mica — control-flow analysis, SSA middle-end, storage placement, register allocation, native emission — is now something you can build a compiler against. Here is what it is, why we published it, and where it goes.
After three years as one program, the Mica compiler now has the architecture it always claimed to have: a foundation, an intermediate language, a backend engine, and a frontend — with walls between them a build system enforces. The proof is a second language: Wirth's PL/0, compiled to native code by Mica's own backend, checked against Wirth's own machine.
6.12.5 gives Mica a project model and a scripting mode, splits the compiler into four modules around its own backend SDK a foreign frontend can drive — and ships only after weeks of adversarial review that ruled four language changes, closed silent-corruption roads, and taught every failure to name itself.