Hibana

What if your compiler could prove your protocol is deadlock-free?

Hibana is a #![no_std] multiparty session types engine that brings established type-theoretic guarantees into everyday systems. Write your global choreography once, project it at compile time, and get affine cursors that make protocol violations impossible.

                // 1. Global Choreography
const PING_PONG: g::Program<_> = g::seq(
    g::send::<Client, Server, Ping>(),
    g::send::<Server, Client, Pong>(),
);

// 2. Compile-Time Projection
const CLIENT: g::RoleProgram<0, _> = g::project(&PING_PONG);

// 3. Affine Execution
// Compiler enforces protocol compliance.
let (client, _) = client.flow::<Ping>()?.send(&42u32).await?;
let (client, pong) = client.recv::<Pong>().await?;
            

Const Projection

g::Program builds protocols with g::send / seq / par / route. Pure const fn composition, macro-free.

Affine Cursors

Every step is a linear resource. You cannot skip a step, reuse a step, or drop a session mid-flight without explicit handling.

Transport Agnostic

BindingSlot trait infers transport actions from choreography metadata. Zero boilerplate.

Embedded First

Rust 2024 · #![no_std] · no_alloc — runs on bare metal with deterministic resource usage.

Deterministic Observability

Dual-ring tap architecture prevents Observer Effect. Deterministic replay and debugging.

Effect Policy Filter

eBPF-inspired bytecode VM. Hot-reloadable dynamic policies.

Crates

hibana-quic Beta

IETF QUIC. Interops with Quinn, s2n-quic, quiche.

hibana-h3 Beta

HTTP/3 + QPACK + route handlers.

HibanaOS (Coming Soon)

A #![no_std] unikernel with type-safe async executor and WASI host, driven entirely by Hibana session protocols.

Get Started

[dependencies]
hibana = { git = "https://github.com/hibanaworks/hibana" }

GitHub · Discussions · Issues

HIBANA