KYRx is a next-generation systems language with opt-in ownership (own T / shared T), colorless async concurrency, and a time-travel debugger built into the runtime. 5× more productive than Rust.
// opt-in ownership — no borrow anxiety
fn transfer(src: own Buffer, dst: shared Pool) {
let view = &src[0..64]; // safe ref, default
dst.write(view); // compiler validates regions
} // src dropped here — deterministic, no GC
// colorless async — no keywords, just fast
fn fetch_all(urls: Vec<Url>) -> Vec<Body> {
urls.map(|u| http::get(u)).collect()
// ^ concurrent automatically, work-stealing
}
fn main() {
let pool: shared Pool = Pool::new(1024);
let buf: own Buffer = Buffer::load("data.bin");
transfer(buf, pool); // zero-copy, zero-fear
}// mandatory explicit lifetime annotations
fn transfer<'a>(src: Vec<u8>, dst: &'a mut Pool) {
let view = &src[0..64]; // borrow — src now frozen
dst.write(view); // lifetime 'a must outlive view
} // explicit drop, lifetime juggling required
// async colours every caller — must use .await
async fn fetch_all(urls: Vec<Url>) -> Vec<Bytes> {
let futs: Vec<_> = urls.iter()
.map(|u| async { reqwest::get(u).await })
.collect();
futures::future::join_all(futs).await
}
#[tokio::main] // runtime annotation required
async fn main() {
// verbose setup, lifetime annotations throughout
}Core Innovations
KYRx retains zero-cost memory safety while eliminating the three biggest sources of developer friction in systems programming.
own T · shared T · default &T
Choose your ownership model per value. Exclusive stack-allocated ownership with own T, reference counting with shared T, or the default safe reference. The borrow checker still enforces safety — but you set the rules, not the compiler.
let x: own Vec<u8> = ... let y: shared Config = ... let z: &[u8] = &x[..]
concurrent code looks like sync code
No async keyword. No await keyword. No function coloring — a sync function can call a concurrent one without modification. The work-stealing scheduler and io_uring / kqueue / IOCP integration are entirely invisible to user code.
fn load_all(ids: Vec<Id>) -> Vec<Row> {
ids.map(|id| db::get(id)).collect()
// ↑ concurrent, zero keywords
}step backwards through execution history
The KYRx runtime records execution history at near-zero overhead. Attach the debugger to any running process and step backwards through every function call, memory write, and state transition. No replay required.
kyrx debug --attach <pid> > step-back 50 > inspect frame -3 > watch x.field == 42
Compiler Architecture
Every crate has a single responsibility. The pipeline is deterministic and auditable — each stage passes a well-typed artifact to the next. Cranelift handles fast dev builds; LLVM maximises release performance.
Runtime Architecture
Language Tour
Same safety guarantees. Radically less friction. Three scenarios that show where KYRx wins every day.
// KYRx — opt-in ownership, zero borrow-checker anxiety
fn process(data: own Vec<u8>) -> Result<Summary> {
// 'own' = exclusive, stack-allocated — no GC, no fear
let header = data[0..8]; // safe reference, default
let shared_ctx: shared Config = load_config(); // ref-counted
analyse(header, shared_ctx) // compiler validates regions
}
fn analyse(buf: &[u8], cfg: shared Config) -> Result<Summary> {
// mix ownership modes freely — compiler tracks it all
Summary::from(buf, cfg.schema)
}// Rust — borrow checker friction in practice
fn process(data: Vec<u8>) -> Result<Summary, Error> {
let header = &data[0..8]; // borrow — now data is "frozen"
let ctx = load_config(); // returns owned value
let ctx_ref = &ctx; // must take reference explicitly
// if you need to move data AND borrow header, it's a fight
analyse(header, ctx_ref)
}
fn analyse<'a>(buf: &'a [u8], cfg: &Config) -> Result<Summary, Error> {
// lifetime annotations required — 'a ties buf to Summary
Summary::from(buf, &cfg.schema)
}How KYRx Compares
Across the dimensions that matter most in production systems.
| Feature | ⬡ KYRx | Rust | Go | C++ |
|---|---|---|---|---|
| Memory safety | ✅ Regions + opt-in ownership | ✅ Lifetimes | ✅ GC | ❌ Manual |
| Garbage collector | ✅ None | ✅ None | ⚠ Yes | ✅ None |
| Async model | ✅ Colorless | ⚠ Coloured | ✅ Goroutines | ⚠ Coloured |
| Error handling | ✅ Effects | ✅ Result | ⚠ Multi-return | ⚠ Exceptions |
| FFI overhead | ✅ Zero-copy | ✅ Zero-copy | ⚠ CGO cost | ✅ Zero-copy |
| Build time | ✅ Fast (Cranelift) | ⚠ Slow | ✅ Fast | ❌ Slow |
| Syntax complexity | ✅ Low | ❌ High | ✅ Low | ❌ Very high |
| Polyglot bindings | ✅ 10 langs | ⚠ Manual | ⚠ Manual | ⚠ Manual |
| WASM target | ✅ First-class | ✅ Good | ⚠ Limited | ⚠ Limited |
| Effect system | ✅ Algebraic | ❌ None | ❌ None | ❌ None |
✅ Full support · ⚠ Partial / workaround · ❌ Not supported
Bridges & FFI
First-class FFI bridges let KYRx call and be called by every major language and runtime. Adopt incrementally — no rewrite required.
Render KYRx components in React apps via JSX bridge
Native Node.js addon via N-API — zero-copy buffers
Direct C ABI interop — share types across language boundary
PyO3-style bindings — call KYRx from Python, no overhead
cgo-compatible shared library — link KYRx into Go services
WASM32 target — run in browser, Cloudflare Workers, Deno
Toolchain
No plugins, no configuration, no separate installs.
kyrx buildCompile to native binary, WASM, or librarykyrx checkType-check and lint without producing outputkyrx runBuild and immediately execute the programkyrx testRun unit, integration and property-based testskyrx benchStatistical benchmark harness (HTML reports)kyrx fmtOpinionated auto-formatter — zero configkyrx bindgenGenerate TypeScript / Python / Go / Rust / Java bindingskyrx publishPublish packages to hub.kyrx.devkyrx addInstall packages from the registrykyrx lspStart the language server (VSCode / Neovim)Package Registry
hub.kyrx.dev is the official package registry for the KYRx ecosystem. Every package is stored in a BLAKE3 content-addressed store at ~/.kyrx/store/<hash>/ — ensuring immutability, deduplication, and cryptographic integrity on every install.
kyrx-runtimecoreAsync scheduler + nurserieskyrx add kyrx-runtimekyrx-reactorcoreio_uring + kqueue + IOCPkyrx add kyrx-reactorkyrx-netcoreAsync TCP / UDP / WebSocketkyrx add kyrx-netkyrx-httpcoreHTTP/1.1 + HTTP/2 serverkyrx add kyrx-httpkyrx-wasmcoreWASM bridge + wasm-bindgenkyrx add kyrx-wasmkyrx-stdcoreCollections, strings, IOkyrx add kyrx-stdhbforge-wasmbridgeIsomorphic WASM loaderkyrx add hbforge-wasmclearscript-nodebridgeClearScript in Node.jskyrx add clearscript-nodePerformance
Colorless concurrency compiles down to the same machine code you would write by hand. The scheduler is a Rust library — no interpreter, no bytecode.
The kyrxc_backend_llvm crate emits LLVM IR directly. All LLVM optimisation passes apply — vectorisation, inlining, LTO, PGO. Binary parity with Rust release builds.
Fewer lifetime annotations. No async/await syntax. Opt-in ownership means you write correct code fast. Real teams ship features in days, not weeks fighting the borrow checker.
Benchmarks
Benchmarks run on Linux x86-64 with io_uring. KYRx uses the reactor-driven AsyncTcpListener for all networking tests.
| Benchmark | ⬡ KYRx | Rust / tokio | Go | Node.js |
|---|---|---|---|---|
| HTTP throughput (req/s) | 148,200 | 152,000 | 89,400 | 42,100 |
| TCP accept latency (µs) | 12 | 11 | 18 | 44 |
| JSON parse (MB/s) | 1,840 | 1,920 | 1,210 | 680 |
| Binary size (hello) | 210 KB | 390 KB | 1.8 MB | — |
| Cold start (ms) | 1.2 | 1.1 | 3.4 | 48 |
| Peak RSS (echo server) | 2.4 MB | 2.1 MB | 8.8 MB | 52 MB |
Numbers are estimates — full benchmarks publish with the 0.1.0 release.
What's New
New AsyncTcpListener / AsyncTcpStream — first real consumer of submit_poll. End-to-end tests prove real sockets wake the reactor on both Linux and macOS.
Replaced T037 stub with live IoUring::new(256) backend. PollAdd ops keyed by Token.0, completions fire wakers, graceful busy-poll fallback.
Full EVFILT_READ/WRITE + EV_ONESHOT integration with 1 ms kevent timeout. 41/41 runtime tests pass.
New public API for registering fd-readiness interest with a waker. Foundation for all future async IO primitives in the runtime.
KYRx gives you Rust-level memory safety, Python-level ergonomics, and a debugger that lets you step through time. Visit kyrx.dev to follow the build.