I build programming languages and systems software in Rust. My work explores how expressive abstractions, explicit ownership, and native execution can fit together — from a language and its compiler to decentralized storage and developer tools.

Rock · Language book · Contact

My main focus: building a language and the ecosystem around it.

Rock is an experimental, natively compiled language with a functional style and explicit ownership. Written in Rust and targeting LLVM, it brings together type inference, pattern matching, higher-kinded types, and deterministic resource cleanup. Its syntax draws from LiveScript, Haskell, and Rust: concise functions, readable pipelines, and abstractions that compose.

The ambition is to make functional programming feel natural in systems code: work with functions and containers at a high level while keeping borrowing, mutation, and resource lifetimes explicit. Traits such as Functor, Monad, and Traversable let different containers share operations; do notation makes dependent, fallible steps read as a flat sequence.

double = value -> value * 2

main = !->
    mut values = Vec::new!
    for value in [1, 2, 3]
        values.push value

    Option::Some 21
        <&> double
        |> (.println!)  // Some(42)

    values
        <&> double
        |> (.println!)  // [2, 4, 6]

    Option::None
        <&> double
        |> (.println!)  // None

Connecting higher-kinded abstractions, ownership-aware closures, and trait inference so ordinary programs need fewer annotations; exploring scoped dynamic dispatch and existential packages on a dedicated development branch.

Moving operator meaning and primitive arithmetic policy into the standard library, backed by explicit compiler intrinsics; extending UTF-8 text handling and generic, short-circuiting traversal.

Developing rockup, the project CLI, language server, editor integrations, and the language book alongside the compiler, with reusable compiled dependency artifacts.

The challenge is making these features work together:

• Ownership across abstractions — preserving borrowing and cleanup through closures and erased types.
• Predictable inference — keeping generic trait calls understandable without excessive annotations.
• Consistent semantics — carrying the same guarantees across separately compiled dependencies.

That makes compiler correctness, useful diagnostics, and realistic library programs central to the work.

Rock is still experimental. The published release and active development branches move at different speeds; the goal is a coherent, usable language, and the current work is about earning that reliability.

Explore the compiler → · Read the book · Try a release · Join the discussion

I'm building the surrounding tools and libraries that let Rock be used for real programs. rock_http is a blocking HTTP/1.1 server library written in Rock, with bounded request parsing, response framing, and a thread-per-connection model built on safe standard-library APIs. It gives the language a concrete systems workload.

rock.nvim, vscode-rock, and tree-sitter-rock bring the editing experience along with it.

A Rust storage system that turns the Autonomi network into a mutable key–value interface. Mutant combines encrypted private storage and public sharing with chunked, resumable uploads, storage-pad reuse, and synchronization.

A persistent daemon manages network operations and background tasks, exposed through an async Rust API, a CLI, and a web workspace with file viewing, editing, and media streaming. The underlying problem: making distributed storage practical when transfers are interrupted, data changes, and network operations take time.

My kernel work includes contributing load-average accounting and the corresponding /proc/loadavg interface to Asterinas, a Rust operating-system kernel with a Linux-compatible ABI. The implementation connects scheduler statistics to the proc filesystem, using fixed-point arithmetic and lazy calculation of load averages.

It's systems work at a different layer: turning internal scheduling state into useful information for userspace while respecting kernel constraints. View the contribution →

Earlier explorations include Comet, a reactive, isomorphic full-stack framework for Rust, and reactive-postgres-rs, a reactive layer over PostgreSQL.

Interested in language design, compilers, or decentralized systems? Let's talk.