Testnet live · mainnet 2026

The financial chain forNative Bitcoin

DeFi that actually works.

See how it works ↓Read the docs

How is that possible?

Arch lets builders create applications directly around Bitcoin. Computation happens on Arch, while ownership and settlement remain on Bitcoin.

Native tech

What’s built on Arch lives on Bitcoin: same coins, same wallets, same ledger. Making that true took new technology at almost every layer:

Financial primitives

Speed, reliability, and general programmability become financial infrastructure on Bitcoin. Pooling on real UTXOs enables AMMs, oracle feeds enable collateral enforcement, and safe lending carries credit, perps, and structured products.

Finance unlocks

Those primitives compose into real markets. From trading and lending to prime brokerage and more, Arch unlocks a DeFi ecosystem on native Bitcoin. It’s fast, easy to build on, and native all the way down.

Finance, finally native to Bitcoin.

Four rules we couldn't break.

Real finance on Bitcoin needs all four at once. Every prior attempt broke at least one — so markets never formed, and capital sat idle. Arch is the first to hold all four.

Native
Real Bitcoin, or nothing.

Your actual BTC, settled on Bitcoin. Never an IOU. Never a bridge claim.

Fast & Deterministic
Recovery is certain, not best-effort.

When a position breaches, liquidation fires mechanically and clears in the next block.

Decentralized
No single party can move your coin.

No single key exists — a threshold of validators must sign together. Custody without a custodian.

Programmable
Real financial logic, native to Bitcoin.

Lending, margining, liquidation, and structured products run directly against Bitcoin UTXOs.

How it works.

NativeFastDecentralizedProgrammable

The advances that make all four true at the same time — native, fast, decentralized, and programmable, on one chain.

1UTXO
your coin is one real output
0IOUs
no wrapper, no synthetic
100%
real, native Bitcoin
The foundation

It never stops being Bitcoin.

What you hold is the coin itself — a real UTXO on Bitcoin's own ledger, not a receipt token for coins held elsewhere. Every move settles straight into a Bitcoin block.

180ms
one block, every
1,500TPS
throughput
eBPFVM
Solana-like VM, on UTXOs
The execution layer

Fast and programmable.

Apps fire transactions; Arch sequences them into blocks every 180 ms and executes them against real Bitcoin UTXOs — reorg-safe, so its record stays consistent with Bitcoin itself.

1signature
on-chain: an ordinary Bitcoin spend
0single keys
no party can sign alone
FROST·ROAST
threshold signing
The cryptography

There's no single key to hold.

The authority to move a coin lives only as shares split across the validators. No single party, Arch included, can move anything alone.

180ms
Arch executes (fast)
~10min
Bitcoin settles (final)
1block
one settlement = one block
Settlement

Fast where it needs to be.
Final where it counts.

Move faster than Bitcoin alone ever could, then settle with Bitcoin's own finality.

The financial primitives Arch unlocks.

Pools, enforceable collateral, and real liquidations — the building blocks of markets, finally possible on native Bitcoin.

Bitcoin could send value. It just couldn't pool it.

A pool is shared capital that many people can trade against at once. It's a fundamental primitive for any non P2P market. Bitcoin can't do it alone. Arch can, while keeping every coin native.

Peer-to-peer is one coin to one coin; a pool is many coins sharing one reserve — only possible on Arch.

Collateral you can actually enforce.

A loan market only works if the lender can seize collateral without the borrower's consent. Arch enforces it mechanically and settles to Bitcoin — the borrower can't yank it back.

A price line crosses the liquidation threshold; the VM assembles a Bitcoin transaction that moves the collateral.

A liquidation that's on time and final.

A late liquidation isn't slow — it's a loss. Arch detects a breach, locks the price at signing, and broadcasts the closeout in under three seconds, then settles on Bitcoin.

Under three seconds from breach to broadcast on Arch, then about ten minutes for Bitcoin settlement — two timescales.

Lending on Bitcoin — natively, for the first time.

Native settlement made the collateral enforceable; speed made the liquidations real. Together they make pooled lending possible on Bitcoin itself.

A ladder: pools plus enforceable collateral plus fast liquidation combine into pool-based lending on native Bitcoin.

These primitives are yours to build on.

Borrow, earn, and swap against native Bitcoin. It stays yours the whole way through.

Borrow without selling.

Draw a loan against native BTC — without a wrapped IOU.

// borrow against pooled BTC collateral
pub fn borrow(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    amount: u64,
) -> Result<(), ProgramError> {
    let iter = &mut accounts.iter();
    let pa = next_account_info(iter)?;
    let pos = next_account_info(iter)?;
    let mut pool = LendingPool::load(pa)?;
    // stay over-collateralized, or reject
    pool.check_health(pos, amount)?;
    pool.total_borrows += amount;
    pool.save(pa)
}
// more in the docs

Put idle Bitcoin to work.

Earn yield that accrues to real Bitcoin — not a receipt.

// supply native BTC, earn supply APY
pub fn deposit(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    amount: u64,
) -> Result<(), ProgramError> {
    let iter = &mut accounts.iter();
    let pa = next_account_info(iter)?;
    let mut pool = LendingPool::load(pa)?;
    // credit supply, re-price utilization
    pool.total_deposits += amount;
    pool.utilization_rate =
        pool.total_borrows * 10_000
            / pool.total_deposits;
    pool.save(pa)
}
// more in the docs

Swap against real liquidity.

Pooled, always-on liquidity at a tight, predictable spread.

// settle a runes swap on native Bitcoin
pub fn process_accept_offer(
    accounts: &[AccountInfo],
    ix: SwapInstruction,
) -> Result<(), ProgramError> {
    let iter = &mut accounts.iter();
    let taker = next_account_info(iter)?;
    let oa = next_account_info(iter)?;
    let maker = next_account_info(iter)?;
    let mut offer = SwapOffer::load(oa)?;
    // both legs settle, or neither does
    transfer_runes(maker, taker, give)?;
    transfer_runes(taker, maker, want)?;
    offer.status = OfferStatus::Filled;
    offer.save(oa)
}
// more in the docs
For builders

Build your first Arch program in under 15 minutes.

Start Building Read the docs