GitHub

Roadmap

Calx is pre-release, and this is the board it's built from, as it is now: what's planned, what's being built and what's shipped. Vote for what you'd like sooner, suggest an idea, or report a problem.

Planned
11
In progress
28
Shipped
29
Ideas
0
Suggest an ideaReport an issue

The board

As of Oct 31, 2026

Planned

11

Decided or designed, and not started.

  1. CLX-6Insert tick-budget checks in plugin builds
  2. CLX-7Build plugins for wasm32 from the same source
  3. CLX-58Read a symbolic link's target, in std.fs
    0/3
  4. CLX-8Build the plugin tooling and a language server
    0/3
  5. CLX-69Add Handle<T>, a checked reference into a slot map
  6. CLX-70Add Shared<T> for data a parallel loop reads at once
  7. CLX-71Run parallel for over slot maps and maps, and on a pool the program picks
  8. CLX-72Add dyn interfaces, associated types and operator interfaces
  9. CLX-73Add java.ArrayList, a list that grows as Java's does
  10. CLX-74Stop only the plugin that panics, and free all its memory

In progress

28

Being built, or built and waiting for review.

  1. CLX-2Define the Phase 3 tick-loop benchmark
    In review5/5
  2. CLX-1Write CALX_SPEC.md v0
    In review11/11
  3. CLX-4Add packet codegen
    In review7/7
  4. CLX-37Add std.fs for files and directories
    In review4/4
  5. CLX-38Add the wall clock to std.time
    In review4/4
  6. CLX-39Close sockets gracefully on Windows
    In review
  7. CLX-40Make -o create its folder
    In review
  8. CLX-41Give connections' peer addresses in std.net
    In review3/3
  9. CLX-42Make net.poll wait for an event or its timeout
    In review
  10. CLX-44Report a stack overflow as a panic
    In review5/5

Shipped

29

Done, newest first.

  1. CLX-60Build the Calx website
    Oct 31, 2026
  2. CLX-49Give std.time the local zone's abbreviation
    Oct 29, 2026
  3. CLX-30Write the hashes, random bytes, AES-CFB8 and RSA that login needs
    Oct 28, 2026
  4. CLX-31Write zlib compression
    Oct 28, 2026
  5. CLX-32Add an HTTPS client on the system's TLS
    Oct 28, 2026
  6. CLX-33Write LZ4 as lz4-java's block streams
    Oct 28, 2026
  7. CLX-9Write the Rust reference benchmark
    Oct 28, 2026
  8. CLX-10Build the compiler pipeline
    Oct 28, 2026
  9. CLX-16Build the compiler test suite and doc tests
    Oct 28, 2026
  10. CLX-17Add debugging support
    Oct 28, 2026
Each card is a task on the Calx board. The same board on ActaPowered by Acta

Ideas and issues

An idea is something Calx should do, and anyone can vote for it. An issue is something that's wrong, in the compiler, the standard library or the docs. Issues go to GitHub, where you can follow the replies.

For now, ideas go to the board's page on Acta, where anyone can vote for them too.

Suggest an idea on Acta
What kind of problem?
Bug
Docs
Feature request
You check it and send it on GitHub, which needs an account. Without one, suggest it as an idea.Open issues

Where Calx is

The tasks above, summed up by feature.

Built

Everything in the reference and the standard library is built, and every example on those pages is compiled and run on Windows and Linux on every push:

  • The types: integers and floats with defined results on every platform, structs, enums, tuples, optionals, error values, generics and interfaces.
  • Memory safety without a garbage collector: ownership, views, arenas and Box<T>, with unsafe code and C functions for what the checker can't see.
  • parallel for, whose capture check gives the same result with any number of threads, and messages between actors, delivered in a fixed order.
  • Modules, libraries that a program opens while it runs, and attributes that libraries write in Calx, which generate code while the program compiles.
  • Lists, deques, priority queues, maps and sets, and the Java-compatible hash tables.
  • Standard library modules for input and output, files, the network, threads, time, math, hashing, compression and the terminal.
  • The calx command, with cached builds that redo only what changed, and the VS Code extension.

Designed, not built

The spec has the design of each of these:

  • Handles: Handle<T>, a checked reference to an object in a slot map, which says when the object is gone instead of reading freed memory (spec).
  • Shared data: Shared<T>, for data that many iterations of a parallel for read at once (spec).
  • More parallel loops: a parallel for over the values of a slot map or a map, and on a pool the program picks (spec).
  • Values of different types together: dyn interfaces, associated types, and interfaces for the operators (spec).
  • java.ArrayList, a list that grows as Java's does, for code that must match Java's capacities (spec).
  • Plugins that fail alone: a plugin's panic stops only that plugin, and its memory is all freed when it stops (spec).

Later

  • Plugins as WebAssembly, built from the same source, for hosts that run code they don't trust.
  • A language server, so editors other than VS Code get errors, completion and go-to-definition, and calx commands for building and testing plugins.
  • Limits on plugins' time: checks the compiler puts in plugin builds, so a plugin that runs too long can be stopped.
  • Quarry, a package manager for Calx libraries, which are called stones.