Certain in the host, judged in Kimiya, certified at the boundary one front end · a portable IR · interchangeable runtimes · one certificate

§1 · the shape of it

One front end, one document, many runtimes

Kimiya is not reimplemented per language. There is one front end — lexer, parser, the discipline checker (K1–K15), the type checker — and it is the Python one. It emits a checked program as a portable document, kir/1: a JSON tree with every name already resolved, every judged relation's task key fixed, every prompt template hashed, every irreversible act flagged, and a requires block saying what the program needs from a host. A runtime executes that document; it never parses source and never re-checks discipline — it may refuse a document, never reinterpret it.

python3 -m kimiya ir prog.kim          -- prog.kir.json: checked, resolved, hashed
kimiya-rt validate prog.kir.json      -- a runtime's own consumer validation
kimiya-rt run prog.kir.json name=value   -- the same certificate as `kimiya run`

§2 · the boundary

What a host supplies, what it gets back

Every import is a small set of named operations; a host may omit a whole import (no screen world on a phone) and the runtime refuses, before running, any program whose requires needs it. The imports:

The lifetime of a run

prepare(kir_json)             -- load + validate, once per document; refused with the problems named
execute(prepared, params, limits, host)   -- any number of times; each with its own params,
                                       --  limits, cancel token and host state
close(prepared)                -- releases the document and everything a run owned:
                                       --  prompts, replies, θ, memo keys (freed, not zeroed)

Every execution ends in exactly one outcome, a certificate whose status is one of COMMITTED, ENDED, ABSTAINED or CANCELLED. The fourth is the host's: a cancel token tripped from any thread, or a limit on model calls, tokens or host-clock seconds, stops the run at the next statement boundary or before the next model call, and the certificate's reason names what fired — cancelled by the host, limit: 40 model call(s) reached. A run is never stopped between a model call and the recording of its reply. What the program did (abstain) and what was done to it (cancel) are never confused.

§3 · the runtimes

One runtime, five ways to hold it

kimiya-rt is a Rust crate that performs no I/O outside the traits of the boundary. Everything below is that one crate, compiled or wrapped differently; the conformance suite (§4) runs the same goldens through each.

Rust, in six lines

// a run with no disk: files in, certificate out
let doc = kimiya_rt::ir::load(&kir_json)?;
let (mut host, artifacts) = kimiya_rt::memory::memory_host(oracle, kernel, files, secrets);
host.oracle = Box::new(oracle::Live::new(credentials, LiveOpts { cancel: Some(token.clone()), ..Default::default() }));
let cert = Runtime::new(doc, host, &params)?.with_limits(limits).with_cancel(token).run();
let receipt = kimiya_rt::receipt::from_certificate(&cert);   // keep this; drop the trace

Node, with the WebAssembly module

node host/js/kimiya-rt.mjs run prog.kir.json --oracle live --max-calls 20
-- the asyncified module when present; a live provider awaited behind one import

Kotlin

KimiyaProgram(kir).use { program ->
    val out = program.executeSuspending(files = mapOf("transcript.txt" to text), host = myHost, cancel = token)
}   // out: {"status":"done","certificate":{…},"receipt":{…}} — no trace unless asked

§4 · the proof it is one language

Conformance: the same certificate, to the byte

Two runtimes agreeing is tested without a model. The reference records every model request — hashed exactly as the runtime assembled it: model, system text, prompt, temperature, token cap, image hashes — and every reply; a runtime under test is handed the recording as its oracle. A request the recording lacks is not a cache miss, it is a conformance failure: the runtime under test assembled a prompt the reference never made. Host-function calls are recorded and replayed the same way, so a program whose kernel exists only in Python still runs everywhere.

Conformance is graded in levels — L0 text, L1 images, L2 screen, L3 dom, L4 the batched instruments — so a host can say precisely which part of the language it carries. The WebAssembly build is the text level by design: no worlds beyond files. The Rust runtime is L4, the whole language, with the screen and dom worlds under recording drivers and a live xdotool driver bound only on request.