Mica 7.2.0: the AI release

Mica 7.2.0 is the release the 7.x line was aimed at: the one where training a network becomes ordinary Mica. No framework arrives with it, no runtime, no second language for the math — the autograd tape is a language construct, a gradient is something the compiler already knows how to answer, and every digit a training run prints is deterministic. The flagship sample is a complete GPT, trained by the language itself; the teaching road to it is a twelve-chapter course; and for the first time, a release ships paired with its editor: VS Code extension 4.0 “Mica Notebooks” arrives the same day, built on the rule that every fact the editor shows traces to a compiler-emitted artifact.

Everything below is shipped and gated behavior — every claim in this article has a test the release gates run.

The release at a glance

The tape

A value declared tracked is a value with a memory: inside a recording window, the arithmetic it participates in lands on the language’s own tape, and one backward walk answers every derivative at once.

program Slope;

imp
    WriteLn, Backward, Gradient : std;

var
    a : tracked float64;
    m : tracked float64;
    slope : float64;

begin
    a := 3.0;

    tape
        m := a * a;
    end;

    Backward(m);
    slope := Gradient(a);
    WriteLn("slope %lf", slope)
end.

slope 6.000000

That is the whole mechanism, and it scales without changing shape: the same tracked word on a matrix[64, 48] of float64, the same window, the same one-line Backward — and the tensor vocabulary’s verbs record their reverse rules as they run. The rules are not taken on faith: the shipped test corpus holds every derivative against central finite differences of its plain forward twin, so a rule drifting from its calculus fails the gates with the deviating numbers.

Because the tape is a language construct, the compiler polices it like one. The recording window must stand in the program’s own body; a leave cannot cross the tape window; a tracked declaration or an unrecorded call in the wrong place refuses with guidance in the tape’s own vocabulary, not a generic type error.

GPU residency

Tensor data can live on the device, and the curated layer verbs — the softmax-and-friends vocabulary a training loop leans on — run as device kernels behind the same source spelling they have on the host. What makes this Mica rather than a binding is where the checking happens: placement is a compile-time fact. A device tensor cannot be given a name that would let it leak into host arithmetic, a device element type must be float32 or float64, and an operation that would silently shuttle data between host and device does not compile. The refusals name the rule and the offending spelling, the same way every Mica diagnostic does.

The GPT sample trains with the device doing the heavy rows, and prints the same digits as its host-only twin — pinned, both, by the release gates.

The formula tier

Numeric code is written in a notation; 7.2 lets the source wear it.

w₁ := w₁ - α × g₁;

Greek letters and subscript identifiers are ordinary identifiers, × and · are the multiplication spellings mathematics already uses, and none of it is cosmetic escape-hatchery — the scanner’s own admission rules define the set, and the editor completes \alpha to α and w_1 to w₁ as you type. The GPT sample is written in this style throughout; it reads like the paper it implements.

The compiler moves into the editor

The language server grew from four features to a full editor surface this release, and every one of them is the compiler answering, never the editor guessing:

• Semantic highlighting — each identifier colors by what its name resolved to. tracked values render italic; code inside a tape window renders bold. Autograd code looks quietly different, because it is.
• Hover states the whole contract: tracked matrix[64, 48] of float64 with its shape, a fallible function’s signature ending in its fails domain.
• Signature help while typing a call, the active parameter moving with the commas; inlay hints naming literal arguments and wearing a generic call’s instantiation — of float64 — behind the callee; import completion offering exactly the units and names the import diagnostics would accept, from the compiler’s own importable surface.
• The narrator. A stopped program explains itself: one call renders the task tree as the scheduler sees it, each generator’s suspension state, and the tape’s summary as one document — from the runtime’s own state, with no debugger plugin in between.

Extension 4.0: Mica Notebooks

The paired release. The extension stops being a thin language client and becomes the language’s face — and its headline is a notebook only a deterministic language could ship.

A Mica notebook is a plain markdown file: a ```mica fence is a cell holding one complete program, the ```output fence under it is a recorded fact. Verify Notebook re-runs every cell and holds each fresh output against its recording — a success mark for promises kept, a recorded-versus-this-run diff for drift, one summary line for the document:

Verify: all 12 cells hold their promises — every output matches, digit for digit.

Outputs are facts you commit and review, not residue that ages. A training run’s falling loss draws itself as a sparkline under the digits that printed it. The whole story is on the new Mica Notebooks page, and the twelve-chapter AI course ships as verified notebooks in the starter container.

Beside the notebook: one-click Run and Debug on every program declaration with zero configuration, runtime failure lines that click through to the trapping source, and the Mica Runtime view rendering the narrator’s task tree live at every debugger stop. The extension is on the Visual Studio Marketplace and Open VSX; it requires compiler 7.2.

The course, and the GPT

The AI course is twelve chapters from one guessed digit to a trained GPT — each a page in the tutorial series, each a runnable notebook in the container, every printed number a promise the compiler on your machine keeps. It begins at the guessing machine and ends at train your GPT; the tape’s own chapter is the notebook that runs backward.

Inline variables

A declaration no longer has to live at the block’s head:

var scaled : int64 := answer * 2;

is legal wherever a statement is legal. The initializer runs where the line is written — mid-body, after the values it reads exist — and a declaration inside a loop body starts fresh on every round. The full story, including the rule that keeps declaration order honest, is in Initializers, and the leave family.

The smaller movements

• A build without a platform targets the machine it stands on — Linux with the host’s own architecture. The flagless compile, the project road, the run road, and the language server all derive the same default.
• Every end finds its opener in the editor: begin, concurrent, tape, case, select, record, and bitrecord are bracket pairs, straight from the parser’s own list, so matching and colorization follow the whole language.
• The -lsp / --language-server flag takes the short/long pair every other flag has.

Getting 7.2

Install or upgrade from the install page — Debian packages for amd64 and arm64, checksummed and verified before upload. The user container micalang/mica:7.2.0 is on Docker Hub, carrying the course notebooks; the fastest complete start remains get started: clone, reopen in container, install the extension, open a notebook, press Verify — and watch a document prove itself on your machine.