A systems language where the data layout is the program

Lane has explicit SoA/AoS layout, explicit SIMD, multithreading as keywords, and tests, benchmarks and coverage built into the compiler. One source for every ISA.

What is Lane

Lane is a compiled systems programming language for software where data layout and speed decide the result, such as game engines, game servers and databases. Data layout is part of the type, SIMD is explicit and written once for every instruction set, threads are in the language, and tests live in the declaration of the function they check.

A fast-compiling programming language

Lane builds a million lines into a running executable in 225 ms on 16 threads (prototype, 2026-10-14); on one thread the in-memory build phases take 1,105 ms (2026-10-18), and the goal is under one second. Method and dates

A data-oriented programming language

Lane is a data-oriented programming language: SoA and AoS are keywords on array types, so the layout is part of the type, and lean packed types keep data compact. Data layout

A SIMD programming language: one source for every ISA

Lane is a SIMD programming language with one source for every ISA: vec loops must vectorize at the target's native width or the build fails, per-ISA code is chosen with when, and the targets include x86-64, AArch64, WebAssembly, RISC-V and SPIR-V. Targets

A programming language with built-in tests and contracts

Lane is a programming language with built-in tests and contracts: a test is one line in the function's declaration, about 8 tokens, and the compiler runs it during the build; an estimate puts the saving at about 25% fewer tokens for well-tested code (2026-10-14). Contracts

A systems programming language for game engines

Lane is a systems programming language for game engines: data layout is part of the type, threads are in the language with access modes that make conflicts checkable, and struct-of-arrays data fits the entity-component pattern. Layout and threads

Why Lane

Three things that cost game engines, game servers and databases time, and that no library fixes.

Builds that grow with the program

Large native codebases take a long time to build, and the time grows with the code. Teams respond with build caches, split modules, precompiled headers and builds they do not wait for. The compiler is rarely designed around being fast.

The same kernel, written several times

A SIMD kernel that has to run on x86-64, ARM and the web ends up as assembly for each architecture plus a portable fallback. Each copy is maintained by hand, and each can drift from the others. The database engines and game engines that need these kernels carry them several times over.

Languages that hide the data layout

What decides whether a loop is fast is how its data sits in memory, and most languages let you not say. Turning an array of structs into a struct of arrays means rewriting every place that touches it.

What Lane does about it

Each answer is a design decision, written down in the language specification.

Data layout is a keyword

Layout is a property of the array type, not of the record: soa []Body stores one array per field, aos []Body stores records back to back. The same rec works with both, and field access is written the same way. Record layout follows the C rules, and the compiler computes size_of and align_of.

Explicit SIMD, one source for every ISA

A vector register value (f32x4) and an array in memory ([4]f32) are different types. A vec loop must vectorize at the target width or it is a compile error, never silently scalar. Per-ISA code is chosen with when, not with a preprocessor.

Threads are built in

par runs a loop or block across cores and joins at the end. Parameters carry access modes (wr, out) that are repeated at every call, so a conflict between two writers is something the compiler can check.

Tests and contracts live in the compiler

test and bench blocks, and functions that state what they require and what they return, with examples the compiler checks on both sides of every promise. Results go to a binary report file that a viewer prints, not JSON.

Everything is measured

Every change to a hot path adds a row to the performance log. Tests assert exact values, never tolerances, and float code is strict by default so results are bit-identical on every target.

A self-hosted compiler

The compiler is written in Lane. A bootstrap compiler builds the Lane compiler, the Lane compiler builds itself, and the second build is the same bytes as the first. Once that holds, the bootstrap compiler is frozen as the seed and every new feature is written only in Lane. How Lane compiles itself

What it looks like

A record with a chosen layout and a parallel vector loop, and a function that carries its own tests.

rec Body { f32 x; f32 vx; }

nul step(wr soa []Body b, f32 dt) {
    par vec i in 0..b.len {
        b.x[i] += b.vx[i] * dt;
    }
}
  • wr says the function writes b. A call repeats it: step(wr bodies, dt).
  • soa []Body stores one array per field. Replace it with aos and the body of the function does not change.
  • par splits the loop across cores. vec means each piece must vectorize at the target's width, or the build fails.
  • Declarations put the type first: f32 dt, nul step(...). A function that returns nothing returns nul.

Tests and assertions the compiler runs

i32 clamp(i32 v, i32 lo, i32 hi)
    assume lo <= hi, "lo must not exceed hi";
    test (5, 0, 3) == 3, "expected 3 when given 5 for range 0 to 3";
    test (-1, 0, 3) == 0;
    test (7, 3, 3) == 3;
    test (5, 3, 0) fails;
{
    if v < lo { ret lo; }
    if v > hi { ret hi; }
    ret v;
}
    if unlikely(keys[slot] == 0) { ret false; }
    assume(slot < keys.len);
    ret probe_slow(keys, slot, key);
  1. The assume line states what the function requires of its callers, with a message for when a caller breaks it.
  2. The test lines are examples the compiler runs during the build. fails marks an input that must be refused because it breaks an assume.
  3. Together they document the function, serve as the oracle for correctness, and give the optimizer facts it may rely on.

Inside a body, assume(c) is also a statement: it tells the optimizer that c holds at that point.

Measured and prototyped

Every number here says what kind it is, how it was taken and when. They are from one machine (i7-13700KF, 24 threads, Windows 11), shared with other work unless a card says otherwise. See all measurements.

Measured 2026-10-18

One million lines, built in memory on one thread

1,105 ms

The whole build of a generated program: one million one-line functions, 56 MiB of source, a 128 MiB executable, on one thread, without optimization (-O0).

Full method

The whole build of a generated program: one million one-line functions, 56 MiB of source, a 128 MiB executable, on one thread, without optimization (-O0). It is the sum of the in-memory build phases (load and parse, collect, compile, layout) and does not include writing the executable to disk. Best of 5 interleaved rounds.

Goal, not a result: The project goal is under 1,000 ms.

Prototype 2026-10-14

The same program on 16 threads

225 ms

Best of 5 builds of the same one-million-line program (58.8 MB of source, 1,000,010 functions, a 134,892,544-byte executable) with the front end, declaration phases, code generation and image write running on 16 threads with chunks taken from a queue.

Full method

Best of 5 builds of the same one-million-line program (58.8 MB of source, 1,000,010 functions, a 134,892,544-byte executable) with the front end, declaration phases, code generation and image write running on 16 threads with chunks taken from a queue. A scratch prototype, not part of any release. The one-thread build took 1,789 to 1,801 ms in the same session, and the prototype's executable was byte for byte the same at every thread count tried (1 to 32). Taken in a quiet window, with the machine under 20 percent load.

Measured 2026-10-15

The compiler builds itself

18 ms

The compiler written in Lane building its own source (628 functions in 29 modules) in memory, best of 3, one thread.

Full method

The compiler written in Lane building its own source (628 functions in 29 modules) in memory, best of 3, one thread. It does not include writing the executable to disk or starting the process.

Measured 2026-10-15

The compiler reproduces itself byte for byte

617,984 bytes

The bootstrap compiler builds the Lane compiler (A); A builds it again (B); B builds it again (C).

Full method

The bootstrap compiler builds the Lane compiler (A); A builds it again (B); B builds it again (C). A, B and C are the same 617,984 bytes.

Estimate 2026-10-14

About 25% fewer tokens for well-tested code

about 25%

A test is one line in the function's declaration, about 8 tokens, instead of a separate test function.

Full method

The sample is one function with a precondition and four tests. It takes 92 tokens in Lane, against 152 to 168 tokens with conventional test frameworks. Tokens were counted with a proxy tokenizer, where each identifier, number, string or symbol counts as one. It assumes tests make up about half of well-tested code. The count covers test code only. It will be replaced by a measurement with a real model tokenizer.

One source, every target

Every target gets ahead-of-time native code, with no VM and no JIT: x86-64, AArch64, WebAssembly, RISC-V and SPIR-V shaders, each with its own executable format and vector width. Lane code links into an existing app or engine through the C ABI.

The target matrix lists formats, SIMD and how parity is tested. The roadmap has the order and timing.

For people and for agents

Docs for people

A syntax tour of the language: types, functions with access modes and several results, records, enums and match, constants, memory, per-ISA code, and contracts. Every code block is real Lane that the compiler's test suite builds or parses.

Start the tour

Docs for agents

Plain Markdown, no JavaScript: llms.txt, the whole reference in llms-full.txt, a one-page cheat sheet of the rules agents get wrong, verified examples with their expected output, and an error reference.

Open the agent docs