Roadmap

The order is the planned order of work: finished items first, then work under way, then the next items, then the rest. States are the state of each item on the date below, in the development compiler; the Downloads page offers the latest published release. This one data file feeds the page, its Markdown version and llms-full.txt. Updated 2026-10-28.

Markdown version of this page

Done so far

  • Language specification
  • Standard library written in Lane: io, fmt, mem, os, bufio and float
  • A test runner written in Lane, which runs the 1668 programs behind these docs

Planned order

  1. Self-hosting

    Done

    The Lane compiler is written in Lane and compiles itself, on Windows, on Linux and on macOS (arm64).

  2. Floats: f32 and f64

    Done

    Strict IEEE arithmetic at both optimization levels, with a native square root on every target.

  3. Position-independent executables

    Done

    Windows executables are built for address-space randomization and carry a header checksum; --resources adds an icon, a manifest and version information.

  4. Visual scripting

    Done

    Edit a program as a node graph side by side with its text, with the same checks and the same generated code. The program tree commands (tree, print, build --tree, nodes) are released.

  5. Inlining

    Done

    Small functions are inlined into their callers at -O1.

  6. Contracts

    Done

    assume lines and test examples on functions. The examples run during builds for every target, a failing one fails the build, float results can be stated exactly, and exported library functions can carry examples. Using assume facts in the optimizer is planned.

  7. x86-64 Linux

    Done

    Static executables that need no C library, built with --target linux.

  8. The compiler on Linux

    Done

    The compiler itself runs on Linux and builds itself to the same result as on Windows.

  9. Optimization on every processor family

    Done

    x86-64 builds at -O0 and -O1; AArch64 and RISC-V 64 build at -O1. Floats are optimized on x86-64.

  10. defer

    Done

    A statement that runs when its scope ends, for owned resources.

  11. Implicit lossless number conversions

    Done

    A value converts to a wider type without a cast when no information can be lost.

  12. Compile-time errors for impossible constants

    Done

    Integer division by a constant zero is an error, and so is any constant that is infinity or NaN.

  13. A faster compiler

    In progress

    Target: one million lines to a runnable executable in under one second on one core without optimization, and in under three seconds at full optimization. Dated figures are on the measurements page.

  14. Register allocation

    In progress

    Values live in registers instead of memory.

  15. Loops as fast as hand-written code

    Next

    At -O1, values a loop reuses stay in registers, divisions by powers of two become shifts, conditions branch directly, counters step in one instruction and calls to small functions no longer save and reload values around the call, so scalar loops run as fast as the same algorithm written by hand.

  16. Lane Explorer

    In progress

    The compiler in the browser: source on one side, the generated code for each target on the other. In progress: a result for every contract line, so that each example shows as passed or failed.

  17. WebAssembly: wasm32 and wasm64, with SIMD128

    In progress

    wasm32 and wasm64 modules build with the same results as x86-64, and floats are done on both. Native SIMD128 code is still to come.

  18. Library output

    In progress

    Windows x86-64 libraries are done. In progress: a WebAssembly library mode, so that a host such as a game engine can embed Lane code. Linux shared libraries are planned.

  19. SIMD vectors

    In progress

    Fixed-width vector types and operations are done, including vectors in optimized code (-O1) and a native square root. In progress: AVX2 images.

  20. Exact math.fmod and math.wrap

    In progress

    Floating-point remainders with identical bits on every target. The % operator stays an error on floats.

  21. Files and processes in the standard library

    In progress

    Done on Windows. In progress: the file system on Linux. macOS and the browser follow.

  22. AArch64: macOS, iOS, Linux, Android, Windows

    In progress

    Linux and macOS (arm64) are done, with integers and floats; the compiler builds itself on macOS. iOS, Android and Windows on ARM remain.

  23. RISC-V 64 with RVV

    In progress

    Linux programs build with integers and floats, with -O1. The RISC-V vector extension remains.

  24. Faster test runs

    In progress

    A batched test runner and faster continuous integration, so the test programs run in less time.

  25. Threads

    Next

    Threads in the language, running on a thread pool that the host program provides.

  26. Asynchronous I/O

    Next

    await and job handles, so that file and network calls never block the main thread.

  27. File mocks for tests

    Next

    Fixture files and a fake event queue, so that functions that read and write files have examples.

  28. Compile-time evaluation

    Next

    Calls to suitable functions are evaluated while compiling, and recursion is turned into loops by the compiler.

  29. The I/O event queue, sockets and windows

    Next

    One queue for keys, mouse, windows, timers and network events, with sockets and native windows.

  30. The memory API and opt-in safety checks

    Next

    Virtual memory, arenas and pools in the standard library, and safety checks a program asks for. The cost of zero-initialising variables has been measured, to decide when the compiler may skip it.

  31. The loop optimizer and auto-vectorizer

    Next

    Loop optimizations, automatic vectorization and scheduling, with a per-loop report.

  32. Removing the bootstrap compiler

    Next

    The compiler is built only from a pinned earlier build of itself, with no other toolchain in the build.

  33. Windowed programs on Windows

    Planned

    A program can be built as a windowed program, so it starts without a console window and opens faster from Explorer or a shortcut.

  34. Syntax highlighting

    Planned

    A TextMate grammar for editors, and highlighting and language detection for Lane files on code-hosting sites.

  35. Native f16

    Planned

    Half precision with the same results on every processor.

  36. The calculator showcase

    Planned

    A first small program that shows the language end to end.

  37. Coverage and profiling

    Planned

    Line and branch coverage and per-function timing, in builds that ask for them.

  38. Generics

    Planned

    Compile-time type and value parameters.

  39. Data-parallel loops, packed types and text types

    Planned

    vec and par loops, packed types and text types.

  40. ECS storage

    Planned

    SoA and AoS as one keyword for entity-component data.

  41. Incremental builds

    Planned

    Rebuild only what changed.

  42. lane watch

    Planned

    A long-running mode that keeps an executable ready and answers questions about the program.

  43. Hot reload

    Planned

    Change the functions of a running program, for game engines.

  44. The $12 server

    Planned

    A complete HTTP and JSON API server, built for the public "$12 Server Challenge".

  45. SPIR-V shaders

    Planned

  46. One language for every application

    Planned

    Complete applications on every platform written only in Lane: windows, a GPU-drawn UI and layout engine, input, files, network, audio, and desktop and mobile packaging, with no other language or framework in the build.

  47. 32-bit targets

    Planned

    Nice to have.

  48. Normalized types un8, un16, sn8, sn16

    Planned

    Unorm and snorm values in 8 and 16 bits.

  49. Machine-learning number types

    Planned

    bf16, FP8 and quantized integers.