LEGACY DOCS · 12.4Stable is 13.2. This page stays because it still owns historical or unchanged contracts.CURRENT 13.2 →
RELEASE LINE13.2 HISTORICAL13.1 PREDECESSOR13.0 PREVIOUS12.4 NATIVE MIRARCHIVE

LEGACY DOCS · 12.4

PAGE ROLE · NATIVE MACHINE CODE FOUNDATION

DBYTE 12.4 · NATIVE MACHINE CODE

This release stops treating native code generation like a bag of target-specific tricks. Concrete HIR is lowered into one Native MIR, legalized for the target, optimized at O0 or O1, allocated deterministically, selected into machine instructions, then written by DByte's own object and executable writers.

READ THIS FIRST. v12.4 does not replace the language manual, allocator contract, VM, collections, ABI, ELF or PE documentation. Those contracts already have owners. This release owns the native machine-code path between Concrete HIR and the existing target writers.

00 the shape of the compiler

PARSE + TYPE + OWNERSHIP
        |
        v
   CANONICAL HIR
        |
        v
   CONCRETE HIR
        |
        v
     NATIVE MIR
        |
        +--> TARGET LEGALIZATION
        +--> O0 OR O1
        +--> LINEAR-SCAN ALLOCATION
        +--> INSTRUCTION SELECTION
        +--> PEEPHOLE
        `--> DBYTE OBJECT / EXECUTABLE WRITER

There is one semantic input to production native lowering: Concrete HIR. The old direct-HIR DBYTE64 path and the old i686 evaluation-stack path remain useful as differential oracles, but they are not allowed to become alternate language interpreters.

A backend gets to choose registers and encodings. It does not get a vote on what the program means.

10 why Native MIR exists

Native MIR gives the compiler a place where machine constraints can be explicit without corrupting language semantics. Basic blocks are deterministic. Virtual registers have target-sized types. Stack objects are named. Memory effects are visible. Calls and intrinsics are resolved. Relocations exist as relocations instead of accidental strings. Source spans survive long enough to explain a bad lowering.

That matters because optimization and allocation only become trustworthy when the thing being optimized can be inspected. If the compiler hides everything inside one recursive lowering function, every performance fix becomes archaeology.

20 contracts that did not move

ContractOwner12.4 rule
Language semantics12.0Concrete HIR remains authority.
Owned runtime / Drop12.1Optimization may not move or erase ownership effects.
Native ABI / object formats12.2Calling convention and writer contracts remain stable.
VM / collections12.3VM remains a separate execution backend and oracle.
Machine-code pipeline12.4Native MIR through final machine encoding.

30 what v12.4 proved

VM corpus15 / 15; geometric mean 1.409877x; minimum 0.995889x.
NMOS 6502151 / 151 / 151 legal-opcode authority; 4.481502x speedup.
Linux native14 workloads; geometric mean 1.635904x; minimum 0.987252x.
Windows native14 workloads; geometric mean 1.639412x; minimum 1.019105x.
StabilityMaximum relative MAD: Linux 4.08%, Windows 4.16%.
Hardware countersUNAVAILABLE — PERF_NOT_FOUND. Wall-time, object, relocation, ABI and disassembly gates remained mandatory.

The point is not that every workload got faster. It did not. The floor matters because a geometric mean can hide a disaster. The release contract therefore carries both an aggregate gate and per-case floors.

40 less machine junk

I686 AGGREGATE
text bytes      3033 -> 2482
instructions    1201 -> 769
frame bytes      168 -> 112

X86_64-NONE AGGREGATE
text bytes    175203 -> 118338
instructions   35590 -> 28764
frame bytes   308832 -> 7304

Frame reduction on the freestanding x86_64 corpus is not decorative. It is what happens when scalar locals stop being pessimistically treated like permanent memory and the allocator is allowed to keep values in registers until reality says otherwise.

If every local becomes a stack slot because the compiler is scared, the compiler is not conservative. It is lazy.

50 current package

PACKAGE      dbyte-v12.4.0-windows-x64.zip
BYTES        3855311
ENTRIES      450
RUNTIME      25
SHA256       433b18bbfd5c36304558a71fe169e631757dbd5285ad16c9097b36e64ee1e55f
TAG OBJECT   28c074777f46bd9e8885f42c49f903ba34e19254
COMMIT       a1a5c2458065f6f295d1c3e77df62a34846226e3

DOWNLOAD WINDOWS X64 · PACKAGE MANIFEST · RAW V12.4 CONTRACT

60 follow the wire

Read Native MIR when you want the representation. Read O0 and O1 when you want the legal transformations. Read register allocation when you want to know where values physically go. Read machine inspection when you distrust the compiler. You should distrust the compiler. Then make it print enough evidence to earn trust.