Programmable assets, settled on Bitcoin.

Seventeen years of proof, now open for building. Assets issued through Orobit settle on Bitcoin and move at the speed of Lightning, so what you create inherits the trust Bitcoin already earned.

Read the docs Open the explorer

Compatible with

Federated sidechains

A committee holds it.

On a pegged sidechain, your bitcoin is locked in a multisig run by a fixed set of functionaries. Getting it back means that group agreeing to sign.

Bitcoin rollups

A bridge holds it.

The asset moves into a bridge contract and stays there. Its safety rests on covenant changes Bitcoin has not adopted, or on assumptions still being proven.

Issuing elsewhere

Another chain holds it.

Issue on Ethereum or Tron and you leave Bitcoin altogether, for a chain with its own validators and its own fee token, and whatever guarantees come with them.

Orobit doesn't move your bitcoin. It never needs to.

Architecture02/ 04

Three layers, one chain underneath.

Orobit divides the work the way the internet does. Each layer does one job well, and none of them asks you to trust something new.

Every deployment, mint, and transfer is carried by a Bitcoin transaction, and is final when Bitcoin is final.

Bitcoin settles.

Assets ride ordinary BOLT11 payments through existing channels and existing routing, settling atomically with the payment.

Lightning carries.

A deterministic language and virtual machine. The same chain in produces the same state out, on every node.

Built from the ground up, in Rust.

A contract language written from scratch, compiled to deterministic bytecode. The same source produces byte-identical output on every machine.

A stack-based virtual machine for consensus work. The base tier is bounded at 100k instructions per call, 1024 stack depth and 64 KB of storage per contract; staked tiers raise the ceiling to 1M instructions and 4 MiB.

A peer-to-peer node in Rust that reads Bitcoin through Esplora and syncs state between peers in seconds. No local Bitcoin node required.

An asset-aware fork of rust-lightning, built on LDK, carrying SCL context through channel funding and standard BOLT11 payment paths.

The source is public on GitHub

token.sclSCL

contract Token {
    @writeable_by(init, transfer_ownership)
    owner: Str;
    @writeable_by(init, mint, burn)
    total_supply: Int;
    @writeable_by(init, pause, unpause)
    paused: Int;
    @writeable_by(init)
    max_supply: Int;
    @writeable_by(init)
    initialised: Int;
 
    fn init(owner_addr: Str) {
        if (initialised == 1) {
            return 0;
        }
        owner = owner_addr;
        total_supply = 0;
        paused = 0;
        max_supply = 50000000000000000;
        initialised = 1;
        MAP_SET("balances", owner_addr, 0);
        return 1;
    }

deterministic buildsclc compile

What it costs to run04/ 04

Moving money costs nothing.

XRB meters computation, not payments. A plain transfer fits inside the free instruction envelope every call gets, so moving money never touches the meter. What pays is heavier compute: contracts stake and burn XRB for the instructions and storage they consume, and validators earn it for verifying every execution against Bitcoin. It is not the asset you issue, and not something your users ever have to hold.

Network fuel

XRB–

Burned for compute, earned by validators. Never held by the people using what you build.

A transfer costs your users

0XRB, permanently

Supply can never fall below

300MXRB

Emission pool

40Mleft in 2026

152 XRB per Bitcoin block until the pool empties in 2031. Then issuance ends for good.

Settles on Bitcoin L1

A call is committed by writing its bytecode hash into a Bitcoin transaction, so the chain itself carries the record. Nodes read that commitment back out and replay the call against it, which means finality is not something Orobit grants. It is inherited from the block the transaction landed in.

How SCL works

Every deployment, mint and transfer is carried by a Bitcoin transaction, and is final when Bitcoin is final.

Settlement and validation

The same chain in produces the same state out on every node, with each call metered against a fixed instruction budget.

Inside the VM

Assets ride ordinary BOLT11 payments through existing channels, settling atomically with the payment itself.

SCL on Lightning

Our developer suite.

Issue an asset, move it over Lightning, settle it on the base chain, with a compiler, an explorer and a wallet that already exist. Nothing in this section is a roadmap item.

Look up any address, asset or contract.

Search the network and read back blocks, transfers, holders and contract state, decoded from the Bitcoin transactions that carry them.

Open the explorer

Ship a token in an afternoon.

Write the contract in SCL, compile it in the browser, and deploy to testnet in one sitting. The same source compiles to the same bytes on every machine, so anyone can verify what you shipped.

Open the IDE

Send value in seconds, not blocks.

Assets ride ordinary Lightning payments, so transfers clear instantly and cost nothing to move. Keys never leave the device, and balances restore from a seed phrase alone.

Open the wallet

Settlement rails that answer to Bitcoin.

Custody, treasury and settlement for funds, exchanges and corporates, with governance and compliance controls set in the contract rather than promised in a policy document.

Talk to the team

Read the whole protocol.

The contract language, the built-ins, the interface standards, and everything needed to run a validating node of your own. No part of it is a black box.

Read the docs

What teams are building on it.

One contract layer, and every transaction settling on Bitcoin.

Banks and institutions

Custody, treasury and settlement, with the compliance controls written into the contract and enforced on every transfer.

Stablecoins and payments

Issue a fully backed token and move it at merchant speed, with every transfer verifiable by anyone with a copy of the chain.

Lightning wallets

Assets ride ordinary Lightning payments, so transfers clear in seconds and cost nothing to move between users.

Game studios

Currency and items for Unity and Unreal, issued as real assets the player holds outright and settled on the Bitcoin base chain.

Our latest news.

Releases, research and ecosystem news, straight from the team.

Orobit editorial illustration showing a signed manifest, a hardware signing device, a sealed software package and a payment node connected by a blue-to-orange verification line.

Research1 Sept 2026

The Verification Path Behind XRB

We built SCL so independent nodes can replay the same committed contract against Bitcoin-derived context. XRB adds contract resource capacity and validator incentives, making exact inputs and software part of the evidence.

Read the article →