Natives: the Audit Table of the Manifest#

Status: step 1 of the kernel of natives built (2026-10-23) — every native declaration of std/ and every entry of the manifest has a row below with a verdict, and the kernel is a closed list. Nothing else changed: no native, no syntax, no driver flag and no name the compiler looks up is touched, so the seed is not involved. The measuring and the rewrites are the next steps of the kernel of natives (ROADMAP.md, "The kernel of natives").

Every native of std/ is work for every back end. Before a native is rewritten in TorbScript, this record says what each one is: a kernel operation a back end has to provide, a rewrite that becomes ordinary TorbScript on the kernel, or a keep at the edge of the machine. The later steps work from this one list: COLLECTIONS.md gap 6 (Buffer) rebuilds the collections, native fn bodies as IR (BACKEND.md 3.7) turn the kernel rows into the operations std/ itself names, and each rewrite is decided by a measurement.

What a row is#

The rows are the entries of the manifest, nativeEntries() in compiler/src/backend/c/natives.trb (BACKEND 3.7), one row per NativeEntry, grouped by owner type or std/ module. A native that is generated per width (Int8.add to UInt64.add) has one row per width, because the manifest has one entry per width. The columns:

• Name is NativeEntry.name, exactly.
• Target is the kind of NativeEntry.target (Intrinsic, Runtime, Derived, Container, Lowered, ArrayStorage, Target, ScriptTable, Embedded, Machine, ScriptHost), with (planned) for an entry whose state is .Planned. The verdict of a planned entry is the verdict of what it will be.
• Verdict is kernel, rewrite or keep.
• Group is, for kernel, one of the kernel groups K1 to K8 below; for keep, one of the edges below; - for rewrite.
• Shape is, for rewrite, the TorbScript form the native takes. Needs lists the kernel groups that form stands on. Measure names the measurement that decides the rewrite, M1 to M6 below. All three are - for the other verdicts.

The verdicts#

• kernel — an operation of the closed list below. A back end implements it (an IR intrinsic, an Array or Buffer operation) and everything else in std/ is TorbScript on top of it.
• rewrite — the native can be written in TorbScript on the kernel. The verdict is the target: the measurement of the row decides whether the rewrite is not slower than the bound (10% on the benchmark of its group, the bound of tools/buffer-cost.sh). A rewrite that misses it stays as it is and its row changes to keep or kernel in the same change, with the number in its commit message.
• keep — an edge that cannot be written in TorbScript: the operating system, a clock, a file, a network, the terminal, the process, the scheduler's threads, TLS, the VM, the test harness, the compiler's own reflection. Each keep row names its edge.

The kernel#

The kernel is this list and nothing else. A kernel row belongs to exactly one group, and the drift check fails for a group that is not in this table.

Why K3 holds the math functions: a sine that differs in the last bit between two back ends is a different program, and a bit-exact libm in TorbScript is a project of its own with no gain for a back end. Why K1 holds the wrapping pair: hashing and Decimal limbs need them, so the table proves them necessary.

The edges of keep#

The measurements#

A measurement is a program built natively with --release and timed as the fastest of nine runs, once with the std/ of the merge base and once with the rewrite, in forge CI at the end of tier B like tools/buffer-cost.sh. It is a measurement and not a gate. The bound is the one of that tool: no more than 10% slower. The benchmarks that do not exist yet are written by the step that rewrites the rows.

Counts#

The numbers below are the rows of the tables, counted by the drift check.

The table#

Signed integers#

Module: std/number.

Unsigned integers#

Module: std/number.

Floats#

Module: std/number.

Decimal#

Module: std/number.

Conversions, wrapping arithmetic and hashing helpers#

Module: std/number, std/core.

Core types#

Module: std/core.

Char#

Module: std/text.

String#

Module: std/text.

Console, panic and the test harness#

Module: std/console, std/test, std/prelude.

ArrayList#

Module: std/collections, std/core.

TrieList#

Module: std/collections, std/core.

Buffer#

Module: std/collections, std/core.

HashMap#

Module: std/collections, std/core.

TrieMap#

Module: std/collections, std/core.

HashSet#

Module: std/collections, std/core.

TrieSet#

Module: std/collections, std/core.

Files and standard streams#

Module: std/fs, std/io.

Processes and the environment#

Module: std/process, std/os.

Time#

Module: std/time.

Entropy#

Module: std/os.

Windows#

Module: std/os.

Posix#

Module: std/os.

Linux#

Module: std/os.

Bsd#

Module: std/os.

MacOs#

Module: std/os.

X86#

Module: std/os.

Tasks, channels and regions#

Module: std/task, std/parallel.

Sockets and name servers#

Module: std/network.

IDNA tables#

Module: std/network (dns).

TLS#

Module: std/tls.

The VM kernel#

Module: std/machine.

Expression#

Module: std/expression.

Receiver scripts and the sandbox#

Module: std/sandbox.

Embedded resources#

Module: std/resource.

The drift check#

compiler/tests/natives-audit.test.trb runs in tier A with the rest of the compiler's suite and fails when:

• a manifest entry has no row, a row names no entry, or a name is in the tables twice;
• the target column of a row is not the kind of its entry (or lacks (planned) where the entry is planned);
• a verdict is not kernel, rewrite or keep; a kernel row names a group that is not in the kernel table, or a keep row an edge that is not in the edges table; a rewrite row has no shape, a need outside the kernel groups, or a measure that is not in the measurement table;
• the counts in "Counts" are not the rows of the tables;
• a native declaration of std/ has no manifest entry: the test reads every native fn of std/*/src/, with its owner type, and looks it up in the manifest. A declaration that is generated from a trait of a native type (Int8.add from Numeric) is checked by the checker against the manifest already.

A new native therefore needs its manifest entry and its row in the same change, and a changed verdict is an edit of the row and of the counts.

Not in this record#

• The measuring and the rewrites. They are further steps of the kernel of natives, each decided by the measurement of its row, and each under the two-commit rule where it adds or changes a native (CLAUDE.md).
• native fn bodies as IR and native { ... } blocks, the next step of the same milestone.
• The shape of Buffer as the storage of the collections (COLLECTIONS.md gap 6).