Staging-ready, not production-ready

A permissioned consortium settlement chain, in Rust.

Not a public L1. Not a DeFi chain. A bounded, known-operator ledger with private-first transaction submission, bounded native contracts, and a transparent engineering process.

Try it in 30 seconds →Read the honest status
7,299
tests green at 80e5a51
60 min
live soak — 6,999 blocks across 3 EU validators
~92%
across 12 audited goals (LORE-3)
Quick install

Try it in 30 seconds.

One command on Linux or macOS. Auto-detects your platform, drops scc-tui into ~/.local/bin, and points at the public testnet.

one-liner
curl -sSL https://github.com/syntarie/scc-releases/releases/download/testnet-2026-04-26/install.sh | sh

Or grab a binary directly:

⬇ Download scc-tui-linux-x86_64

glibc 2.31+ (Debian 13 / Ubuntu 22.04+) · Static-linked, no librocksdb dependency.SHA256

Nuremberg (faucet)http://91.99.102.167:19100
Helsinki (read)http://62.238.14.215:19100
Falkenstein (read)http://178.104.121.69:19100

What Syntarie is, what it isn't, what is actually shipped.

What it IS
  • •A Rust blockchain node with Proof-of-Authority consensus and checkpointed finality.
  • •A permissioned consortium chain — genesis-capped, non-redeemable, operated by a known validator set.
  • •A private-first transaction submission system with explicit public opt-in.
  • •A bounded native contract runtime — capability-gated Rust contracts plus a governed PolicyEngine DSL.
  • •A terminal-UI wallet (scc-tui) with real transfer-safety workspace.
What it is NOT
  • •Not an EVM or WASM platform. Bounded native contracts are a settled design decision.
  • •Not a generalized intent router. Bounded composition is also settled.
  • •Not production-ready. Ready for a bounded, known-operator staging — the audit says so.
  • •Not a finished wallet product. The runtime substrate is ahead of the wallet UX.
  • •Not a public mainnet. No token. No airdrop. No public validator sign-up.
What is actually shipped
  • •7,299 tests green at 80e5a51 — interface 6,482, scc-tui 801, foundry 16.
  • •3 validators live on Hetzner Cloud across Nuremberg + Helsinki, round-robin block production.
  • •SECURITY-1 sibling closed — payload-context spoofing rejected fail-loud across 8 axes.
  • •Bridge code launch-ready — Python prover signs with real keys, rotation digest aligned to Solidity.
  • •Public testnet up — anyone can install + transact with one curl line.
Why believe any of this

Most chains ship a whitepaper. Syntarie ships bugs it found this week.

The first 3-validator cloud deploy broke at block 2. The postmortem surfaced five distinct bugs, each hidden behind the others — every one of which passed 6,500+ unit tests:

  1. 1
    Peer accounting

    /status peer_count returned the --peers CLI arg length, not real connections.

  2. 2
    Inbound-only count

    Peer manager registered inbound only; dialer-only nodes reported zero peers.

  3. 3
    Partition sticky-halt

    Correct halt logic on wrong input — once halted, gap-only-grows made recovery impossible.

  4. 4
    Outbound TTL decay

    Observer decayed at 60-second TTL under steady state, so the system forgot peers every minute.

  5. 5
    Block-broadcast TCP starvation

    Locally-produced blocks dialed fresh TCP; under load hit EAGAIN and silently dropped.

Same-process test harnesses connect instantly, so they cannot distinguish inbound from outbound. Localhost harnesses do not hit EAGAIN. Cloud deployment found all five.

After fixes: ~6,999 blocks across 60 minutes at 2 blocks/sec, round-robin authorship working correctly, across two EU cities, zero peer drops.

Then the 2026-04-25 audit cycle ran 7 parallel agents and closed ~58 findings — including SECURITY-1 sibling (payload-context spoofing), now rejected fail-loud with regression tests pinning it.

Settled, not aspirational

Bounded by design.

Syntarie's contract runtime is not an unfinished step toward a general-purpose VM. It is a bounded, governed, native contract system — capability-gated Rust classes plus a small typed policy DSL, installed through a governance path, with monetary effects routed through a single constitutional module. There is no deploy-anything VM. There will not be one.

Blast radius

In a consortium setting, the cost of a misbehaving contract falls on named operators, not anonymous users. Bounded classes make review tractable.

Determinism

A small typed AST with bounded evaluation is dramatically easier to prove deterministic across a validator set than an opcode VM with gas-metering corner cases.

Honesty

Writing down "we do not ship a general VM, here is the scope we do ship" turns a vague aspiration into a settled decision.

If your protocol needs a deploy-anything VM, Syntarie is the wrong tool. If your protocol needs a governed ledger with known operators and a predictable contract surface, it might be the right one. Full boundary write-up: Scope Boundaries.

Hands-on

First 30 seconds on testnet.

You already have a bash shell. Here's how to generate a wallet, top it up with test SCC, and send a transfer.

# 1. One-line install (Linux / macOS)
curl -sSL https://github.com/syntarie/scc-releases/releases/download/testnet-2026-04-26/install.sh | sh

# 2. Generate a wallet
scc-tui keygen ~/my.key

# 3. Launch the TUI against the public testnet
scc-tui --testnet ~/my.key
# (yellow [TESTNET] badge appears; press [$] on Wallet for faucet → 100 SCC)

Then read, in this order: v1 readiness, scope boundaries, and the testnet welcome.