Roadmap

This page tracks the status of major SUB features. Items are grouped by completion status.

Completed

Classes Done

Class definitions with fields, .new construction, and dot-notation member access. Lowered idiomatically on every backend — structs in Rust, classes in Java/Python, interfaces in TypeScript.

class Point {
    let x = 0
    let y = 0
}

let p = Point.new
p.x = 10
p.y = 20

Pattern Matching / Switch Done

switch/case/default over integers, strings, and floats. Multi-value clauses, no fall-through. Compiles to efficient branch tables on native targets.

switch value {
    case 1, 2:
        println("low")
    case 3:
        println("three")
    default:
        println("other")
}

Try / Catch Done

Structured error handling with try/catch/finally and throw. Works across all backends including native compilation.

try {
    let result = divide(10, 0)
} catch err {
    println("Error: " + err)
} finally {
    println("Cleanup")
}

UI DSL Done

Declarative UI tree with ui.window, ui.label, ui.button, and other primitives. One tree, many renderers.

ui.window {
    title: "My App"
    ui.label { text: "Hello!" }
    ui.button { text: "Click" }
}

13-Target Transpiler Done

Python, JavaScript, TypeScript, C, C++, Rust, Go, Java, Kotlin, Swift, Ruby, x86-64 Assembly, and CSS — all from a single AST, verified in CI.

Native x86-64 Compiler Done

subc emits x86-64 machine code directly and writes the ELF binary itself. No assembler, no linker, no libc.

Standard Library (9 modules) Done

math, arrays, strings, io, testing, format, path, encoding, collections — all written in SUB, verified through every backend.

Planned

Generics Planned

Type-parameterized functions and classes. This would eliminate the need for _int/_float suffixed variants in the stdlib and enable more expressive code.

# Planned syntax
fn first<T>(arr: [T]) -> T {
    return arr[0]
}

Async / Await Planned

First-class async functions for non-blocking I/O. The networking builtins (net_fetch, net_post) are currently synchronous — async support would make them non-blocking.

# Planned syntax
async fn fetch_data(url) {
    let response = await net_fetch(url)
    return response
}

Foreign Function Interface (FFI) Planned

Call C library functions directly from SUB. This would unlock access to system libraries, GPU compute, database drivers, and other native functionality.

# Planned syntax
import ffi
let lib = ffi.load("libm.so")
let cos = lib.bind("cos", fn(float) -> float)
println(cos(0.0))  # 1.0

File I/O Builtins Planned

Native builtins for reading and writing files: file_read, file_write, file_append, file_exists, file_delete, dir_list. Currently possible through transpiled targets but not available in the interpreter or native compiler.

Package Manager Planned

A built-in package manager (subpkg) for discovering, installing, and managing third-party SUB libraries. Inspired by cargo, npm, and pip.

# Planned CLI
$ subpkg init
$ subpkg add json-parser
$ subpkg build

Improved Error Messages In Progress

Better parse errors with caret diagnostics showing exactly where the problem is, suggestions for common mistakes, and type error explanations.

Source Maps for Transpiled Output Planned

Generate source maps alongside transpiled output so debuggers can map back to the original .sb source.

Incremental Compilation Planned

Cache parsed ASTs and only recompile changed modules. Important for larger projects.

How to Help

Interested in working on a planned feature? Check the contributing guide and open an issue to discuss your approach before starting.

• Contributing Guide
• Open Issues
• Changelog — see what shipped recently