A language made for AI agents and humans.
The whole language fits in about 3,000 tokens of context. Errors say the fix, and passing tests print one line, so your agent reads less, guesses less and retries less. Your servers compile through C into one small native binary.
tokens slang vs Go vs TypeScript, same tasks, same agent: benchmark in progress vs Go and TypeScript: benchmark in progressLight tier of the cross-language suite, 4-vCPU VM. Every run, including the ones we lose →
Try it
Six small programs and what they print. Short enough to fit in a prompt, strict enough that a mistake shows up on the first run.
fn fib(n: int) -> int { if n < 2 { return n; } return fib(n - 1) + fib(n - 2);} for k in 1..=3 { println("tick ${k}");}println("fib(20) = ${fib(20)}");~/hello $ slangc hello.sl --run tick 1tick 2tick 3fib(20) = 6765[exit 0]
Functions, ranges and string interpolation.
import "time"; fn hop(id: int, done: chan[int]) { time.sleep(100_000_000); // 100 ms: parks the task, not the thread chan_send(done, id);} let t0 = time.mono();let done: chan[int] = make_chan(10_000);for i in 0..10_000 { spawn hop(i, done);}for i in 0..10_000 { chan_recv(done);}let ms = (time.mono() - t0) / 1_000_000;println("10000 tasks, 100 ms of sleep each: ${ms} ms");~/tasks $ slangc tasks.sl --run 10000 tasks, 100 ms of sleep each: 490 ms[exit 0]
Ten thousand green tasks. Sleeping parks the task, so they all sleep at once.
// C's atoi says 8080, 80 and 0. slang says:for s in ["8080", "80x80", ""] { let r = to_int(s); guard let n = r else let e = err_of(r) { println(inspect(s) + " -> err: " + e); continue; } println(inspect(s) + " -> " + to_str(n));}~/errors $ slangc errors.sl --run "8080" -> 8080"80x80" -> err: not a base-10 integer"" -> err: cannot parse an empty string as int[exit 0]
A bad number is an error you have to look at, not a zero.
import "json"; gc struct Address { city: str, zip: str }gc struct Person { name: str, addr: Address } let body = "{\"name\":\"Ada\",\"addr\":{\"city\":5,\"zip\":\"SW1\"}}";let r: result[Person, str] = json.decode(body);guard let p = r else let e = err_of(r) { println("rejected: " + e); exit(1);}println("hello, " + p.name);~/json $ slangc json.sl --run rejected: field 'addr': field 'city': expected a string, got a number[exit 1]
Typed decoding. The error names the exact field path.
struct Box[T] { v: T,} impl Box[T] { fn get(self: Box[T]) -> T { return self.v; } fn doubled(self: Box[T]) -> int { return self.v * 2; }} println(Box { v: 21 }.doubled()); // checked for Box[int]println(Box { v: "hi" }.get()); // doubled never checked here~/generics $ slangc generics.sl --run 42hi[exit 0]
A method is checked for the types it is called with, and only those.
import "regex";import "log"; let cr = regex.compile("(\\d{4})-(\\d{2})-(\\d{2})");guard let re = cr else let e = err_of(cr) { log.error("bad pattern: " + e); exit(1);}let m = regex.find(re, "due 2026-09-09");println(to_str(m[0]) + ".." + to_str(m[1])); // whole matchprintln(to_str(m[2]) + ".." + to_str(m[3])); // yearregex.free(re);~/regex $ slangc regex.sl --run 4..144..8[exit 0]
Linear-time matching. No pattern can make it backtrack.
Performance
Measured against eight languages on the same contract, with a conformance check before anything is timed. Memory is where slang pulls away. Throughput sits in the pack.
| language | ms | RSS |
|---|---|---|
| Rust | 1,498 | 10.1 MB |
| slang | 1,757 | 13.3 MB |
| Bun | 1,785 | 88.4 MB |
| Node.js | 1,801 | 81.1 MB |
| Java | 1,990 | 72.5 MB |
| C# | 2,072 | 41.7 MB |
| Go | 2,637 | 8.3 MB |
39,857 req/s
At 50 connections: Go 38,439, Rust 38,021. At 200, Go edges ahead, 36,492 to 35,553. Close enough that a laptop's noise would swap them.
Light tier of bench/suite: raw-socket responders and a compute job on a shared 4-vCPU VM, median of 3 rounds. The Postgres and JSON heavy tier has not run yet. Full record and method →
Concurrency
spawn puts a green task on a pool with one worker per core. Sockets, sleeps, channels and locks park the task and hand the thread back. There is no async, no await and no second colour of function: code that looks blocking stays simple.
Built for agents
An agent spends its tokens reading docs, choosing between options and retrying after errors. slang is designed to cut all three, for the agent and for whoever reviews its work.
llms-small.txt is the language and its packages on one page, about 3k tokens. Every example in it compiles in CI. For a single API, ask the compiler.
~/api$ slangc doc regex
package regex (native)
fn compile(str) -> result[rawptr,str]
fn is_match(rawptr, str) -> bool
fn find(rawptr, str) -> [int]
fn find_at(rawptr, str, int) -> [int]A compile error names the construct, the line and what to write instead. A runtime error names the function and the values, so the next attempt is the right one.
~/orders$ slangc main.sl
main.sl:1: error: cannot infer the element type of an empty list; annotate it, e.g. let xs: [int] = []
~/orders$ ./orders
slang runtime error: list index out of bounds at orders.line_total:2 (index 7, length 3)Tool output an agent can afford: one line when the tests pass, and only the failures when they do not.
~/math$ slangc test .
ok: 2 passed (155us)
~/math$ slangc test .
FAIL test_add_neg (44us)
assertion failed at math.test_add_neg:2
FAIL: 1 of 2 failed (96us)Five backend tasks go to the same agent three times over: in slang with zokor, in Go with Fiber, and in TypeScript with NestJS. Hidden black-box tests decide what passes. We count input tokens, output tokens and turns until they do, and publish the runs where slang still wastes them.
The harness, specs and tests →Retry-Afterzokor
zokor is the backend framework for slang. It makes the decisions every service otherwise makes differently, so neither an agent nor a new hire has to.
r.get("/health", health); // public
let api = r.group("/api/v1");
api.before(require_token); // everything below is guarded
api.get("/orgs/:id", show_org);
api.post("/orgs", create_org);
fn show_org(c: zokor.Ctx[App]) -> http.Response {
guard let org = find_org(c.state.db, c.param("id")) else {
return zokor.respond(c.state.errors, "org.not_found", c.request_id);
}
return zokor.ok_json(encode(org));
}Every choice an agent faces costs reasoning tokens. zokor answers them once.
Router[S], generic over your state.env, then the environment. Every problem at onceThe language
fn, guard let, switch, chan: shapes from Go and Swift, because people and models already know them. Every novelty costs someone a retry.
fn abs(n: int) -> int {
guard n >= 0 else {
return -n;
}
n
}
let code = 404;
switch code {
case 200, 201 { println("ok"); }
case 404 { println("missing"); }
default { println("other"); }
}Each missing feature is one less way for a program to surprise you.
opt[T], unwrapped with guard let or ??result[T, E] for bad data, fault for a bad worldspawn, and blocking calls that parkslang emits C and hands it to your cc. Calling a C library is extern fn and a linker flag: no bindings generator, no marshalling layer, no second build system.
link "sqlite3";
extern fn sqlite3_libversion() -> str;
println(sqlite3_libversion());Standard library
27 packages ship with slangc. Native ones are linked only when a program imports them, so a plain TCP server stays free of OpenSSL, SQLite and zlib.
pkg line awayextern fn and a linker flagGet started
Build the compiler from source, then start a project. make install puts slangc and its runtime under /usr/local; PREFIX=~/.local works too.
| Anything | A C compiler |
|---|---|
net TLS, crypto, https | OpenSSL and pkg-config |
sql | SQLite |
compress, httpc | zlib |
CI builds and tests every merge on Linux x86_64 and arm64 (GCC) and macOS on Apple Silicon (clang).
~$ git clone https://github.com/dolphlabs/slang && cd slang
~/slang$ sudo make install
~/slang$ slangc new hello && cd hello
~/hello$ slangc main.sl --run
hello from helloFAQ
It is young: v0.2, and the language can still change. The runtime is tested on three platforms on every merge, including a collector verifier and stress runs under forced preemption. Read Known limitations before you bet a service on it, and pin a commit when you do.
On what has been measured so far: it uses less memory than Go, finishes the CPU and allocation job in two thirds of Go's time, and trails Rust. Raw HTTP throughput is within a few percent of both. The heavier database-and-JSON tier has not run yet. The benchmarks page shows every number, including the ones slang loses.
C runs everywhere a server does, its compilers have decades of optimisation in them, and every C library is one extern fn away. slangc emits one C file with the runtime spliced in and builds it with cc -O3 -flto.
Each is a place where control flow or ownership hides. Without closures a function value is exactly a C function pointer and the collector can ignore it. Without exceptions every failure is a value you can see in the signature. Without null, absence is opt[T] and the compiler makes you handle it.
It means fewer tokens to learn the language, fewer choices to reason about, and errors that lead to the fix in one turn. It is a design goal, not a result yet: the agent benchmark above is built and published, and its first run is pending.
Yes: extern fn plus link "name". Numbers, bool, str, bytes and opaque pointers cross the boundary; GC-managed values are rejected at compile time, so C never sees their layout.
Dolphlabs (Dolph Tech Limited), in the open, under the MIT license.
Say it in slang. Ship it as C.