UTXO_Compiler turns Python-like .ct sources into BVM bytecode you can drop straight into a Bitcoin locking script, with strong typing and compile-time ownership checks.
Contract P2PKH:
def verify(sig: hex, pubKey: hex):
pubKey_copy = pubKey.Clone()
pubKeyHash = Hash160(pubKey_copy)
EqualVerify(pubKeyHash, self.pubKeyHash)
result = CheckSig(sig, pubKey)Hash160 consumes pubKey; Clone it first so the compile-time ownership check stays satisfied.
Powered by TBC · BVM · UTXO · PoW SHA-256 · Fair launch
Writing BVM opcodes by hand is error-prone and out of step with how product engineers ship. UTXO_Compiler lets you describe contract logic in a Python-like high-level grammar; the compiler turns it into BVM bytecode for you.
A contract's member fields land directly inside its bytecode, so different data produces different locking scripts. Mandatory type declarations plus compile-time ownership checks mean what you read in the source is what runs on the stack — failures get caught at build time, not at chain-tip rollback.
An interactive debugger ships in the box; you can drive both the passing and failing branches deliberately. Compiled output is JSON-shaped bytecode, ready to embed in a locking script or hand to a wallet / indexer.
Indent-delimited blocks, def for functions, strong typing, no var / auto.
def verify(sig: hex, pubKey: hex):
pubKey_copy = pubKey.Clone()Variables can't be reused after consumption — mirrors BVM's stack-pop semantics.
h = Hash160(pubKey) # pubKey now consumed — using it again is a compile error
Lexer → Parser → Semantic → Codegen, output as JSON-shaped bytecode.
$ utxoc compile p2pkh.ct → p2pkh.bvm.json
--debug drops into a REPL; step the passing and failing paths separately.
$ utxoc --debug p2pkh.ct (dbg) step pass / step fail
Linux, Windows 64 / 32-bit binaries; macOS planned.
$ tar xzf utxoc-linux-x64.tgz $ ./utxoc --version
Standard library keeps expanding (Hash160 / CheckSig / EqualVerify / PartialHash …).
Hash160(x); CheckSig(sig, pk) EqualVerify(a, b); PartialHash(...)
macOS binaries; more involved contract patterns (multi-function, advanced ownership).
# macOS · arm64 · planned # multi-function contracts · advanced ownership
Contract P2PKH:
def verify(sig: hex, pubKey: hex):
pubKey_copy = pubKey.Clone()
pubKeyHash = Hash160(pubKey_copy)
EqualVerify(pubKeyHash, self.pubKeyHash)
result = CheckSig(sig, pubKey)Contract Counter:
Struct Script:
SuffixData: string
PartialHash: string
Size: number
Struct Output:
Value: number
LockingScript: Script
def verifyCurrentTX(ctx: CurrentTX):
# ...iterate ctx.Outputs, assert ctx_count == pre_count + 1...
EqualVerify(pre_count_copy + 1, ctx_count)curl -LO https://docs.utxocompiler.com/releases/utxo_compiler-v1.0.0-linux.tar.gz
tar -xzf utxo_compiler-v1.0.0-linux.tar.gz
cd utxo_compiler-v1.0.0-linux
./utxo_compiler --version
./utxo_compiler p2pkh.ct
./utxo_compiler p2pkh.ct --debugNo mental switch, no extra bridge layer. Download the release, ship your first piece of BVM bytecode in minutes.
Release notes, tutorials and ecosystem updates land here first. Tap any card for the full story.