A systems language focused on fast iteration, explicit low-level control, and a language spec small enough to keep in context.
Developed by Aerun.ai.
use "io" fn main() -> result<i64, io_error> { println("Hello, world!")? result.ok(0) }
seed explores a compact systems-language design with explicit tradeoffs.
| Language | Tradeoff | seed |
|---|---|---|
| C/C++ | Fast but unsafe — segfaults, buffer overflows, use-after-free | Ownership, linear resources, lexical views and explicit unsafe |
| Rust | Safe and fast, but brutal complexity — borrow checker, lifetimes, async tax | No lifetime syntax; moves, views and cleanup remain explicit |
| Go | Simple, but GC pauses, no memory control, not systems-grade | No GC; deterministic cleanup and explicit allocation effects |
| Python / JS | Productive, but slow runtime, heavy, not for systems work | Native LLVM pipeline with measured, workload-specific baselines |
| Java / C# | Robust, but verbose, heavy VM, slow warm-up | No VM or warm-up; runtime profile is selected per target |
| All above | LLM-hostile — huge specs, context full of edge cases | Compact grammar plus a versioned agent skill |
Existing languages were designed before the LLM era. seed is designed for it — simple enough for an LLM to reason about as a whole, while retaining explicit systems control. The checked-in skill keeps agents on the same syntax and ownership contract as the operational compiler.
Built from zero. No external limitations.
LLVM IR is the canonical backend. The target is tight edit/check loops with fast incremental builds. Object-level compilation for rapid iteration.
Copy scalars, move-only resources, explicit clone, lexical views, linear t, exact cleanup and no GC.
Hosted, freestanding, kernel and runtime-none profiles make platform services and unsafe boundaries visible.
Linux is primary; Windows x86-64 passes under Wine, macOS x86-64 runs on Intel, and other targets publish their exact object/link/run level.
Every construct returns a value. ADTs, match, ?T optionals, result propagation with ?. Structured concurrency with spawn.
Compact grammar. Fits in a single context window. Both humans and AI agents can hold the entire language in mind.
252 Grove library directories, 11 apps and 20 compiler-stage packages in the current tree. Directory count is inventory, not readiness.
What is operational, what is a tested foundation, and what comes next.
Foundation. G08 closed portable parsing, help, completion, surfaces, layout and snapshots. Interactive terminal/process ownership remains next.
Foundation / prototype. Network and HTTP policy layers exist; the integrated web runtime and a real window/renderer lifecycle are still open.
Android operational slice. JNI host, Canvas frames, input and AVD execution work for arm64/x86-64. Full widgets, accessibility, signing and iOS remain open.
Active v0.3. V3-G0-G13 foundation is complete; V3-G14-G25 owns the local-production expansion. v0.2 P13 was waived, not reported as passing.
Prototype. Math, time, layout, input and UI packages exist. Renderer, audio, assets, packaging and an executable game baseline are next.
Metadata foundation. Owned tensors, datasets, model configuration and experiment contracts exist; numeric kernels, training and inference execution remain open.
No node_modules bloat. No per-project duplicates.
Every version of every lib lives once under ~/.local/lib/seed. Ten projects using the same library version share one copy.
Default builds link against .so files in the cache. seed build --static for self-contained binaries.
flock mutex + atomic rename(2). Two projects running seed install simultaneously never corrupt each other's download.
seed uninstall removes packages cleanly. seed prune cleans source cache. No gigabytes of dead deps.
Once downloaded, the cache serves every build without network access. Lock files pin exact versions so builds are reproducible offline.
Every cached version records a checksum in seed.lock. Tampering or corruption is detected on every build.
Familiar concepts, zero ceremony.
struct point { x: i32 y: i32 } fn point.distance_squared(other: point) -> i32 { let dx = self.x - other.x let dy = self.y - other.y dx * dx + dy * dy } fn main() -> i32 { let origin = point.{ x: 0, y: 0 } let target = point.{ x: 3, y: 4 } origin.distance_squared(target) }
use "task" fn main() -> i64 { let pair = channel_new<i32>(1).or_abort() let sender = pair.sender let receiver = pair.receiver spawn { let _done = sender.send(42) } let received = receiver.recv() match received.value { some(value) => if value == 42 { 0 } else { 1 } none => 2 } }
Omission is design. What we leave out defines the language.
seed is currently proprietary and pre-release. Final plans, pricing and support terms have not shipped.
The compiler, specification, book, agent skill and gate evidence evolve together around one operational implementation.
Pre-1.0 work is reported through named gates, target levels and reproducible baselines. Product readiness is not inferred from source presence.
Language, CLI, TUI, web, mobile, Ridge, game, ML and systems tracks publish their current stage and next evidence boundary.
The code you write is yours. Full ownership. No restrictions. No royalties. You ship it, you own it — forever.
Commercial licensing is the current direction. Concrete availability, pricing, compatibility and support commitments will be published with the release that provides them.
seed is launching soon. Drop your email and we'll notify you the moment it's available.