Coming Soon

Build fast.
Ship faster.

A systems language that compiles in milliseconds, runs at C speed, and fits the entire language spec in your context window.

hello.sd

fn main() {
    let names = ["world", "from seed"]
    for name in names {
        print("Hello, {name}!")
    }
}

benchLANG Results

5 workloads — prime sieve, fibonacci, string lookup, mandelbrot, binary trees — Ryzen 9 5900X @ 3.5GHz

#	Language	Compile	Runtime	vs seed	Binary
1	seed	0.05s	0.84s	1.00x	23KB
2	Nim	0.98s	5.82s	6.93x	52KB
3	C (GCC -O3)	0.27s	7.84s	9.33x	28KB
4	Zig	0.73s	8.49s	10.11x	204KB
5	Rust	2.04s	9.02s	10.74x	2.0MB
6	Go	0.10s	11.99s	14.27x	1.5MB
7	Java	—	10.08s	12.00x	—
8	Python	—	241.59s	287.61x	—

Why seed?

Born from frustration with Rust's compilation times.

⚡

Millisecond Compiles

QBE backend, single-pass, no AST. 16ms average for small programs. 10k LOC in ~200ms. Your iteration loop is instant.

🔒

Safe by Construction

Ownership + linear types. Use-after-free impossible. Double-free impossible. No GC pauses, no data races, no segfaults.

🚀

No libc, No Runtime

Direct syscalls via assembly stubs. No glibc init, no dynamic linker. 4.5x less memory than C. 23KB binaries.

🌐

Multi-Target

Linux x86-64, Linux ARM64, macOS ARM64, WebAssembly. One language, every platform.

🔧

Expression-Oriented

Every construct returns a value. ADTs, match, optional chaining with ?T. Ergonomic error handling.

💡

LLM-Native

~130 BNF rules. Fits in a single context window. Both humans and AI agents can hold the entire language in mind.

Simple, Powerful Syntax

Familiar concepts, zero ceremony.

structs.sd

struct Point {
    x: i32
    y: i32
}

fn Point.distance(other: Point) -> f64 {
    let dx = (self.x - other.x) as f64
    let dy = (self.y - other.y) as f64
    (dx * dx + dy * dy) // simplified
}

fn main() {
    let p1 = Point.{ x: 0, y: 0 }
    let p2 = Point.{ x: 3, y: 4 }
    print("distance: {p1.distance(p2)}")
}

concurrency.sd

fn main() {
    let ch = chan<i32>(10)

    spawn {
        for i in range(0, 5) {
            send(ch, i * 2)
        }
    }

    for _ in range(0, 5) {
        let val = recv(ch)
        print("received: {val}")
    }
}

What seed Removes

Omission is design. What we leave out defines the language.

borrow checker

replaced by ownership + linear types

async/await

structured concurrency with spawn

generics

monomorphized inline fns

null

optional type ?T

exceptions

ADTs + try operator

classes

structs + methods

operator overloading

explicit methods

macros

inline fns + generics

Build fast.Ship faster.