SYSTEMS LANGUAGE · BUILT BY HYPERBRIDGE DIGITAL

Memory Safety
Without the Tradeoffs.

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.

◈ Visit kyrx.dev Browse hub.kyrx.dev →GitHub ★

main.kyrx

KYRx

// 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
}

main.rs

Rust

// 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
}

5×

Productivity vs Rust

Compiler Crates

Function Coloring

∞

Debug History

Core Innovations

Three ideas Rust
never got right.

KYRx retains zero-cost memory safety while eliminating the three biggest sources of developer friction in systems programming.

◈

No Borrow-Checker Anxiety

Opt-in Ownership

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[..]

⬡

Zero Overhead Concurrency

Colorless Async

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
}

⏮

Built Into the Runtime

Time-Travel Debugger

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

14 crates. One pipeline.
Source → Binary in strict order.

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.

Frontend

Middle

Backend

Infrastructure

FRONTEND

kyrxc_lexer

Source text → token stream

→

kyrxc_parser

Tokens → Concrete Syntax Tree

→

kyrxc_ast

AST node defs & visitors

→

kyrxc_resolve

Name resolution & scoping

→

kyrxc_types

Type inference & constraint solving

→

kyrxc_effects

Effect typing & tracking

passes artifact to Middle

MIDDLE

kyrxc_regions

Region inference for memory

→

kyrxc_ownership

Ownership & borrow validation

→

kyrxc_mir

Mid-level IR — typed SSA form

→

kyrxc_opt

Optimisation passes on MIR

passes artifact to Backend

BACKEND

kyrxc_backend_cranelift

Fast codegen — dev builds

→

kyrxc_backend_llvm

Max-perf codegen — release

passes artifact to Infrastructure

INFRASTRUCTURE

kyrxc_diagnostics

Structured error emission

→

kyrxc_driver

Compiler entry-point & orchestration

PIPELINE SUMMARY

Source→

Tokens→

CST→

AST→

Resolved→

Typed→

Effects→

Regions→

Owned→

MIR→

Optimised MIR→

Object Code→

Diagnostics→

Binary

Runtime Architecture

Platform-native I/O.
Zero runtime tax.

⚙

Work-Stealing Scheduler

M:N green threads

✓M green threads multiplexed over N OS threads
✓Idle threads steal work from busy queues
✓Tasks pinned to NUMA nodes when beneficial
✓Fully cooperative — no OS context-switch cost
✓Backpressure signalling built into the scheduler

Colorless async maps directly to scheduler tasks — zero user-visible ceremony.

◉

Platform I/O

io_uring · kqueue · IOCP

✓Linux: io_uring (submission queue, completion ring)
✓macOS: kqueue (kevent-based async I/O)
✓Windows: IOCP (I/O completion ports)
✓Zero-copy buffer passing where platform allows
✓Single unified I/O API regardless of platform

KYRx picks the optimal syscall interface at compile time — no shims.

◈

Content-Addressed Store

BLAKE3 · ~/.kyrx/store/<hash>/

✓Every package version stored by BLAKE3 hash
✓Identical content deduplicated across projects
✓Immutable store — no silent overwrites possible
✓Global cache: cold install = one network fetch
✓Supply-chain security: hash = integrity proof

hub.kyrx.dev mirrors the same content-addressed model server-side.

Language Tour

KYRx vs Rust —
side by side.

Same safety guarantees. Radically less friction. Three scenarios that show where KYRx wins every day.

KYRx

5× more productive

// 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

equivalent code

// 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)
}

Bridges & FFI

KYRx lives in your
existing ecosystem.

First-class FFI bridges let KYRx call and be called by every major language and runtime. Adopt incrementally — no rewrite required.

⚛

React

Render KYRx components in React apps via JSX bridge

⬡

Node.js

Native Node.js addon via N-API — zero-copy buffers

⚙

Rust

Direct C ABI interop — share types across language boundary

🐍

Python

PyO3-style bindings — call KYRx from Python, no overhead

◈

cgo-compatible shared library — link KYRx into Go services

◉

WebAssembly

WASM32 target — run in browser, Cloudflare Workers, Deno

Package Registry

The KYRx
Package Hub.

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.

◈BLAKE3 hash = content identity — no silent mutations
◈Identical content shared across all projects on the machine
◈Deterministic builds: lockfile stores hashes, not version ranges
◈Supply-chain audit: every package traceable to source
◈Offline-capable: cached packages work without a network

Browse hub.kyrx.dev →

kyrx.toml

[package]
name    = "my-service"
version = "0.4.2"
edition = "2026"

[dependencies]
# BLAKE3-pinned — immutable installs
kyrx-http    = { version = "2.1.0", hash = "blake3:a1b2c3..." }
kyrx-json    = { version = "1.8.3", hash = "blake3:d4e5f6..." }
kyrx-db      = { version = "3.0.1", hash = "blake3:g7h8i9..." }

[dev-dependencies]
kyrx-test    = { version = "1.2.0" }

# Content store: ~/.kyrx/store/<blake3-hash>/
# kyrx add kyrx-http     → resolves, pins, caches
# kyrx audit             → full supply-chain report
# kyrx install --offline → works from local cache

Performance

No GC. No overhead.
No compromises.

Zero-cost async

Native LLVM codegen

Colorless concurrency compiles down to the same machine code you would write by hand. The scheduler is a Rust library — no interpreter, no bytecode.

No runtime overhead

Native LLVM codegen

Release builds

The kyrxc_backend_llvm crate emits LLVM IR directly. All LLVM optimisation passes apply — vectorisation, inlining, LTO, PGO. Binary parity with Rust release builds.

LLVM IR output

5× productivity

vs Rust

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.