This page is written for someone deciding whether Mica is worth an evaluation. It is not a scoreboard: C, C++, Rust and Go are all mature, well-engineered languages with ecosystems Mica does not have. What follows is where the design positions differ, including where the others are ahead.
Memory safety
| Mechanism | Annotations | Runtime cost | Rejects correct programs? | |
|---|---|---|---|---|
| Mica | flow analysis, proven per allocation | none | none when proven | no — ambiguity narrates instead |
| C / C++ | programmer discipline | none | none | no |
| Rust | ownership and lifetimes in the type system | lifetimes where inference fails | none | sometimes — the checker is conservative |
| Go | garbage collection | none | GC pauses, throughput | no |
The distinguishing property is the failure mode. A borrow checker must be conservative inside the type system, so it will occasionally reject a program that is in fact correct, and the programmer’s job is to restructure until it is accepted. Mica’s analysis degrades instead: where flow escapes it, the site is reported rather than rejected, and the checked runtime floor catches anything that slips through. You are never arguing with the compiler about a program you know to be right.
The cost is a weaker guarantee. Rust proves more, statically, than Mica does. → Heap lifetime proof
Concurrency and data races
| Data races | When you find out | |
|---|---|---|
| Mica | rejected at compile time | at build |
| C / C++ | undefined behaviour | in production, or never |
| Rust | prevented by Send/Sync in the type system | at build |
| Go | detected dynamically, if exercised | in CI, for interleavings a test happened to hit |
Mica and Rust both give a build-time answer; they get there differently. Rust encodes it in the type system, which is powerful and general but shapes every API you write. Mica derives it from a marking discipline over the activation tree — one keyword at the point of shared access, and no ownership types in your signatures.
Go’s race detector is excellent at what it does, but it can only report races that actually occurred during a run. → Data-race freedom
Determinism
| Same result across thread counts? | Across architectures? | |
|---|---|---|
| Mica | yes — bit-identical, by construction | yes, at a fixed optimization set |
| C / C++ with OpenMP | no — reduction order varies | not guaranteed |
| Rust with Rayon | no — reduction order varies | not guaranteed |
| Go | no | not guaranteed |
This is the axis where Mica’s position is least common. Parallel numeric results are bit-identical to serial at every carrier count, because accumulations are never split — and the compiler’s own reductions stay on a single carrier rather than being offered fast with a caveat. If you have to certify a number, this is the difference between a regression test and a tolerance band. → Determinism
Calling C
| Mechanism | Error conventions | |
|---|---|---|
| Mica | direct, no wrapper | lifted into the failure channel from a contract |
| C++ | direct | manual |
| Rust | unsafe plus a generated binding layer | manual |
| Go | cgo, with a call boundary cost | manual |
Everyone can call C; the difference is what arrives on your side of the call. In
Mica, an imported C function is a failing function — the -1/NULL/errno
convention is declared once in the contract and never appears in your code.
Adoption is incremental: link one Mica module into an existing C program and
debug both halves in one session.
→ The C boundary
Toolchain footprint
| Backend | External dependencies | |
|---|---|---|
| Mica | own, end to end | none, plus GNU as/ld |
| C / C++ | GCC or LLVM | large |
| Rust | LLVM | large |
| Go | own | none |
Go and Mica are the two with their own backends. For a procurement or supply-chain review, “the whole toolchain is ours, with no third-party code” is a materially different answer from an LLVM-based one.
Where the others are clearly ahead
Stated plainly, because you will find this out anyway:
- Ecosystem. Rust’s crates, Go’s modules, and C’s decades of libraries are not comparable to what Mica has. The C boundary mitigates this considerably — you can use C libraries directly — but it is a real gap.
- Optimizer maturity.
gcc -O2leads Mica on general code. Specific kernels reach or pass parity; broadly it does not. - Platform reach. Mica is Linux on two architectures. The others run essentially everywhere.
- Tooling. Editor support is a VS Code extension; there is no language server yet. Debugging is good — real DWARF, real gdb — but the surrounding tooling is young.
- Hiring and training. More people know the others.