Staging-ready, not production-ready

A permissioned consortium settlement chain, in Rust.

Settles on Syntarie. Trades on Base.

Not a permissionless L1. No on-Syntarie DEX (trading lives on Base Uniswap v3). 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
unreachable
—
chain head, 0/3 validators reachable
7,393
tests green at 322184c5
~92%
across 12 audited goals (LORE-3)

What you’re actually looking at.

Syntarie has two sides. Businesses use it to move value between each other directly. Anyone with a Base wallet can buy or sell the same token (SCC) on a public Uniswap pool.

Settlement

Between businesses, on Syntarie

Companies hold and move SCC between each other directly, no card processor, no bank rail in the middle. The chain itself is the receipt, and a known group of operators keeps it honest.

Permissioned validators (intended 4–20 operators)

Trading

Anyone with a wallet, on Base

SCC bridges to Base as wSCC, where it trades on a public Uniswap pool against USDC. Open to anyone with a Base wallet, same as buying any token on Ethereum.

Pair: wSCC/USDC on Uniswap v3

Things people ask.

?

Can I buy SCC right now?

Not yet. We're on a public testnet, the SCC you can claim from the faucet is free and worth nothing real. Mainnet is planned (~1 focused week from "go"), gated on capital readiness and operational drills, not engineering work.

?

Who runs the validators?

A known consortium, intended 4 to 20 operators. New validators only join via on-chain change approved by ≥ ⅔ of the existing set. Pragmatic, not ideological, the codebase already supports more open modes if a future governance decision wants to ease that.

?

Is this a stablecoin or pegged to anything?

No. SCC has no peg, no backing collateral, no algorithmic stability. Total supply is genesis-capped (no post-launch minting), and there's a small fee burn on bridge withdrawals.

?

Is it like Bitcoin or Ethereum?

Different shape. Bitcoin and Ethereum are permissionless, anyone can run a validator. Syntarie's settlement layer is permissioned, only the consortium operators do. The trading side (wSCC on Base) is fully open, just like any token on Ethereum.

Where we are right now

Public testnet today. Mainnet planned, gated on capital, not code.

The technical work is largely done, chain advances on the public testnet, bridge code is launch-ready, security gates are closed. What’s left is operational drills and the funding to seed the Uniswap pool.

ETA from “go”: ~1 focused week, capital permitting. Read the honest status →

Want the technical version? Read the scope boundaries doc; it covers permissioning, consensus, contracts, and the things we explicitly chose not to build.

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.
  • •Bridged to Base mainnet as wSCC (ERC-20), trades against USDC on Uniswap v3.
  • •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 today (testnet only). SCC exists on Syntarie + bridges to Base as wSCC. No airdrop. No CEX listings in v1. No public validator sign-up.
What is actually shipped
  • •7,393 tests green at 322184c5: interface 6,482, scc-tui 895, 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.