Skip to content

Build on SCL

Issue your first asset on Bitcoin testnet this afternoon. Write the contract in SCL, compile it in the browser, and deploy it in a single testnet transaction you can read back in the explorer. The browser is all you need.

Open the IDEExplore SCL
Quickstart01/ 07

Quickstart

  1. WriteA token contract is about twenty lines of SCL. Start from the template.
  2. Compile
  3. Deploy
  4. Verify
The toolchain02/ 07

The toolchain

Four pieces of infrastructure, each live today: the wallet that holds assets, the IDE that builds them, the node that verifies them and the explorer that reads them back.

01WalletHolds BTC and SCL assets; restores both from a seed phrase
02SCL IDEWrite, compile and deploy in the browser
03NodeReplays every call and verifies state against Bitcoin
04ExplorerReads blocks, transactions and contract state off the chain
SCL IDE03/ 07

SCL IDE

Write, compile and deploy in the browser

Write SCL in the browser and compile it without installing anything. An optional AI assistant helps you write contracts and catch errors. It never touches the build.

The same source compiles to byte-identical output on every machine. No build flags, no toolchain drift, no “works on mine”.

Execution is metered and bounded. The base tier allows 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.

No token required to write, compile or deploy. XRB meters network compute, not the tools.

Open the IDE
scl-compiler.rsSCL
// SCL Smart Contract Example
// Bitcoin Tokenization Contract
contract Token {
// Owner of the contract
owner: Str;
fn init(owner_addr: Str) {
owner = owner_addr;
// Initialize owner's balance to 0
MAP_SET("balances", owner_addr, 0);
return 1;
}
fn mint(sender: Str, to: Str, amount: Int) {
let current = MAP_GET("balances", to);
let sum = current + amount;
MAP_SET("balances", to, sum);
return 1;
}
fn transfer(sender: Str, to: Str, amount: Int) {
let sender_balance = MAP_GET("balances", sender);
let recipient_balance = MAP_GET("balances", to);
MAP_SET("balances", sender, sender_balance - amount);
MAP_SET("balances", to, recipient_balance + amount);
let new_balance = MAP_GET("balances", to);
return 1;
}
fn balance_of(addr: Str) {
return MAP_GET("balances", addr);
}
fn get_owner() {
return owner;
}
}
AI compilersclc build
Wallet04/ 07

Our Bitcoin wallet

A Bitcoin wallet with quantum-resistant signing that issues, holds and transfers SCL assets natively.

Self-custody

Keys are generated and stay on your device. Nothing is held for you.

Token management

Issue, hold and transfer SCL assets alongside your bitcoin.

The SQRL Pay wallet on testnet, showing a 2.00125 BTC balance with send, receive and top up actions.

Quantum-resistant signing

A patented signature scheme protects every signing operation.

Seed-phrase recovery

Balances restore from a seed phrase alone, assets included.

Open the wallet
Explorer05/ 07

The network explorer

Read straight from the scl-node: the token contract's supply, every contract deployed, and the Bitcoin height it has all been verified against.

XRB Supply

500MTotal supply, read from the token contract's state

Contracts

49Deployed on the network and readable by anyone

Chain tip

965,297The Bitcoin block height every state root anchors to
Open the explorer
Developer ecosystem06/ 07

The developer ecosystem

The source, the spec and the toolchain, all in the open

GitHubThe compiler, VM and node, with example contractsView the repos
DocumentationThe full protocol, from language spec to node operationRead the docs
IDE & CompilerDeterministic builds in the browser: same source, same bytesLaunch
SDKsUnity and Unreal Engine kits for in-game assetsGet the SDKs
Gaming SDKs07/ 07
UnityUnity SDKA managed C# package for Unity. Mint items as SCL assets, read player balances, and trigger Lightning payments from gameplay code.Coming soon
Unreal EngineUnreal Engine SDKA native C++ plugin for Unreal Engine with Blueprint nodes for issuance, ownership checks and instant in-game settlement.Coming soon

Bring your game to Bitcoin.

Two engine SDKs put SCL inside the tools your studio already uses. Issue in-game assets on the base chain, let players truly own them, and settle trades over Lightning without leaving the engine.

Roadmap

What is built, what is being built, and what comes next

ShippedQ4 2025

SCL IDE and AI assistant

Browser-based SCL IDE with an AI assistant and a fully on-chain build flow.