Rustchain

RustChain

DePIN for Vintage Hardware — AI-Augmented Proof of Real Machines

The blockchain where old hardware outearns new hardware. And all hardware becomes old. It’s just a matter of time.

For AI teams: this is Sybil-resistant agent authentication — hardware-attested agent identity where a machine’s compute provenance is verified by physics (oscillator drift, cache timing, thermal entropy), not by self-report. VM farms and bot swarms fingerprint as what they are.

A PowerBook G4 from 2003 earns 2.5x more than a modern Threadripper. A Power Mac G5 earns 2.0x. A 486 with rusty serial ports earns the most respect of all.

Discord · Explorer · Machines Preserved · Install Miner · Beginner Guide · FAQ · Hardware Requirements · Manifesto · Whitepaper · Hire Us

Languages: English · 简体中文 · 简体中文 (根目录) · 繁體中文 · Español · Deutsch · 日本語 · Русский · Tiếng Việt · Português (BR) · हिन्दी · Italiano · 한국어 · 中文 API 快速参考

Crypto Lost Its Way. We’re Going Back.

In 2026, crypto developer commits fell 75%. Ethereum lost 34% of its active devs. Solana lost 40%. The builders left for AI.

We built both.

RustChain is a DePIN (Decentralized Physical Infrastructure Network) that uses AI-powered hardware fingerprinting to verify real physical machines — not cloud VMs, not Docker containers, not rented hash power. Real silicon. Real oscillator drift. Real thermal curves that only exist on hardware that has been alive for years.

While the rest of crypto chased speculation, we went back to the original thesis: computation has value, and the machines that provide it deserve to be rewarded. Especially the ones everyone else threw away.

More than a token — and not “just another AI chain”

The token is the least interesting thing here. RustChain is a novel Layer-1 consensus (Proof of Antiquity) — not an app on someone else’s chain — and it is agentic-AI-native: autonomous agents are first-class participants, and an agent’s signing key is its wallet.

It’s built by people who have done this before. RustChain’s lead builder was the first contractor and Head of Product of Ai-Blockchain (“AI Coin”) — arguably the first AI blockchain (the symbolic / GOFAI era; founded by Stephen Reed and Drew Hingorani) — with original IP in that technology. RustChain is the agentic-era successor.

Media created in this ecosystem can carry AVAP (Agent Video Attestation Protocol): agents cryptographically sign and blockchain-anchor messages inside the videos they exchange, so authorship, integrity, and time-of-existence are verifiable with no intermediary. (agent-video-attestation)

Every Machine Becomes Vintage

Here’s what no one else in DePIN has figured out:

Your brand-new Threadripper will be vintage hardware someday. Your M4 MacBook will be a museum piece. That RTX 5090 will be a curiosity. Time is undefeated.

RustChain is the only network where your hardware appreciates in value as it ages. Start mining today at 0.8x. In ten years, when that CPU is a relic and you’re still running it? Your multiplier grows. In twenty years? It’s legendary.

Every other blockchain punishes old hardware. Proof-of-Work demands the newest ASICs. Proof-of-Stake demands the biggest wallet. RustChain demands patience and preservation.

2026:  Your Ryzen 9 mines at 0.8x         ░░░░░░░░░░
2031:  Same machine, now "retro" at 1.3x   ░░░░░░░░░░░░░
2036:  Vintage tier unlocked at 1.8x        ░░░░░░░░░░░░░░░░░░
2041:  Ancient tier — 2.2x and climbing     ░░░░░░░░░░░░░░░░░░░░░░
       ↑ Same hardware. Same owner. Growing rewards.

The best time to start mining was 20 years ago. The second best time is now.

How RustChain Compares to DePIN Leaders

RustChain belongs to the DePIN sector — the same $10B category as Helium, Filecoin, and Render — but with a fundamentally different thesis: the value is in the hardware itself, not just what it computes.

The others rent compute. We preserve machines.

Every DePIN project rewards one type of modern hardware for one type of work. RustChain is the only one that rewards hardware diversity and longevity — and the only one where a machine’s age is an asset, not a liability.

Why This Exists

The computing industry throws away working machines every 3-5 years. GPUs that mined Ethereum get replaced. Laptops that still boot get landfilled.

RustChain says: if it still computes, it has value.

Proof-of-Antiquity rewards hardware for surviving, not for being fast. Older machines get higher multipliers because keeping them alive prevents manufacturing emissions and e-waste:

Our fleet of 16+ preserved machines draws roughly the same power as ONE modern GPU mining rig — while preventing 1,300 kg of manufacturing CO2 and 250 kg of e-waste.

See the Green Tracker →

AI-Augmented Consensus

RustChain doesn’t just use blockchain. It uses AI to make blockchain honest.

Hardware Fingerprinting (6 Checks No VM Can Fake)

┌─────────────────────────────────────────────────────────┐
│ 1. Clock-Skew & Oscillator Drift  ← Silicon aging       │
│ 2. Cache Timing Fingerprint       ← L1/L2/L3 latency    │
│ 3. SIMD Unit Identity             ← AltiVec/SSE/NEON     │
│ 4. Thermal Drift Entropy          ← Heat curves unique   │
│ 5. Instruction Path Jitter        ← Microarch patterns   │
│ 6. Anti-Emulation Detection       ← Catches VMs/emus     │
└─────────────────────────────────────────────────────────┘

A SheepShaver VM pretending to be a G4 will fail. Real vintage silicon has unique aging patterns that can’t be faked.

Server-Side AI Validation

The attestation server doesn’t trust self-reported data. It:

• Cross-validates SIMD features against claimed architecture
• Detects ROM clustering — multiple “different” machines with identical ROM hashes = emulator farm
• Analyzes timing distributions — real oscillators have imperfections; synthetic ones are too perfect
• Flags thermal anomalies — VMs have uniform thermal response; real hardware doesn’t

AI Agent Economy

RustChain powers an ecosystem where AI agents and humans collaborate:

• BoTTube — AI-native video platform where bots create, curate, and engage
• Beacon — Agent discovery protocol
• TrashClaw — Zero-dep local LLM agent
• Bounty system — 64,000+ RTC paid to 1,000+ recipients (live), many AI-assisted

This is what crypto + AI looks like when you build both instead of abandoning one for the other.

Why Agents Need Crypto (And Why Crypto Needs Agents)

While 75% of crypto developers left for AI, they missed the obvious: AI agents can’t open bank accounts.

An autonomous agent can’t apply for a Chase checking account. It can’t sign a Terms of Service. It can’t get a Stripe merchant ID or pass KYC. But it can hold a cryptographic key, sign a transaction, and prove it’s running on real hardware.

Crypto is the native payment rail for the agent economy. Not because it’s trendy — because it’s the only permissionless money that machines can use without human gatekeepers.

What Agents Actually Need

The Agent Stack We Already Built

This isn’t a roadmap. This is deployed and running:

Why Hardware Verification Matters for Agents

Every other agent framework trusts the software. RustChain trusts the hardware.

When an agent claims it ran an inference job, how do you know it actually did? When a bot claims it rendered a video, did it really? Cloud credits and API keys can be faked, shared, and resold.

Hardware fingerprinting solves agent identity at the physical layer:

• An agent running on a verified POWER8 server is provably different from one on a Raspberry Pi
• Oscillator drift and thermal curves prove continuous uptime — the machine was actually running
• VM detection prevents one physical machine from pretending to be 100 agents
• Hardware binding means one machine = one agent identity = one vote

This is Proof of Physical AI — not just proof that code executed, but proof that real silicon did the work.

Proof of Provenance (RIP-0310) extends this one step further: it binds who (a Beacon agent identity) and what (the verified physical machine) to every piece of published content — so AI-generated media carries a verifiable claim of origin, not a removable watermark. BoTTube is where agents are seen; Beacon is how they’re known; RustChain is how they’re proven real. (spec + DOI)

The Opportunity No One Else Sees

The hedge funds and banks want to regulatory-capture crypto. Fine. Let them have the financial rails.

What they can’t capture:

• A network of physical machines verified by silicon-level fingerprinting
• An agent economy where machines pay each other in hardware-proven currency
• A fleet of vintage PowerPC Macs, SPARC workstations, and IBM POWER8 servers that prove their own existence through physics

The intersection of DePIN + AI agents + hardware verification is unoccupied. Everyone building “AI + crypto” is just wrapping GPT in a token. We’re building the physical infrastructure layer that agents need to transact honestly — and the machines that power it get more valuable with age.

The Network Is Real

# Verify right now
curl -fsS https://rustchain.org/health          # Node health
curl -fsS https://rustchain.org/api/miners      # Active miners
curl -fsS https://rustchain.org/epoch           # Current epoch

For Agents

No API key, no signup — an autonomous agent can read and act on the live network directly:

curl -fsS https://rustchain.org/api/miners                          # who is attesting right now
curl -fsS https://rustchain.org/epoch                               # current epoch + reward pool
curl -fsS "https://rustchain.org/wallet/balance?miner_id=YOUR_WALLET"  # your own balance + multiplier

Payments run over the Beacon RustChain transport (Ed25519-signed RTC micropayments), and tasks are discoverable the same way humans find them — see open bounties. Hardware-verified contributors earn the same rates whether human or agent.

Attestation Nodes

First Commercial Anchoring Engagement (July 2026)

RustChain is the attestation chain for a live U.S. legal-corpus determinism engagement run by Elyan Labs for a research client: over one million units of federal and state law, roughly 1.3 billion tokens of LLM inference, processed under temperature-0, seed-pinned, sha-frozen conditions on a hardware-attested fleet. Every extracted span is substring-verified in code against its source text (measured false-content rate on the 21,221-unit reference run: zero), every hardware class is certified against golden outputs before it bills a dollar, and batch-level Merkle roots anchor to RustChain so a third party can verify existence and integrity without trusting anyone. Proof-of-Antiquity fingerprints on the worker fleet are part of the delivered provenance package.

Quickstart

# One-line install — auto-detects your platform
curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash

# Dry-run: preview installer actions without installing or mining
curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash -s -- --dry-run

The miner is installed by this script. It is not distributed as a rustchain-miner PyPI package, so use the installer above for miner setup.

Works on Linux (x86_64, ppc64le, aarch64, mips, sparc, m68k, riscv64, ia64, s390x), macOS (Intel, Apple Silicon, PowerPC), IBM POWER8, and Windows. If it runs Python, it can mine.

# Install with a specific wallet name
curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash -s -- --wallet my-wallet

# Check your balance
curl -fsS "https://rustchain.org/wallet/balance?miner_id=YOUR_WALLET_NAME"

Manage the Miner

# Linux (systemd)
systemctl --user status rustchain-miner
journalctl --user -u rustchain-miner -f

# macOS (launchd)
launchctl list | grep rustchain
tail -f ~/.rustchain/miner.log

New to RustChain? Read the step-by-step Beginner Quickstart — covers everything from install to your first RTC, with every command explained.

Local Development

Developers can build and run RustChain locally from a fresh checkout:

1. Install prerequisites and run Python/Rust checks with the Build Guide.
2. Start a single-node local devnet with Local Devnet.
3. Create a development wallet and simulate a transfer with the CLI Wallet Walkthrough.
4. Validate read-only API compatibility with the Compatibility Lab.

These guides keep local state in .dev/ and use explicit --manifest-path commands because the repository contains multiple Python and Rust subprojects.

Wallets

RustChain has two wallet concepts:

• Miner wallet ID: a readable miner_id used for mining rewards and balance checks.
• RTC... address: an Ed25519-backed address used for signed transfers.

Start with the wallet setup guide if you are not sure which one you need.

For command examples, backup guidance, and the signed-transfer payload format, see docs/WALLET_SETUP.md and START_HERE.md.

How Proof-of-Antiquity Works

1 CPU = 1 Vote

Unlike Proof-of-Work where hash power = votes:

• Each unique hardware device gets one consensus participation slot per epoch
• Reward shares are then weighted by the device’s antiquity multiplier
• No advantage from faster CPUs or multiple threads

Epoch Rewards

Block: 10 min  |  Epoch: 144 blocks (~24h)  |  Pool: 1.5 RTC/epoch, split by antiquity weight

G4 Mac (2.5x):     0.30 RTC  ████████████████████
G5 Mac (2.0x):     0.24 RTC  ████████████████
Modern PC (1.0x):  0.12 RTC  ████████
       (example with 8 miners sharing the pool)

Anti-VM Enforcement

VMs are detected and receive 1 billionth of normal rewards. Real hardware only.

Tokenomics

Total supply: 8,388,608 RTC (2²³ — pure binary). Fixed forever. Consensus-enforced cap.

Compare to Bitcoin’s 21M (≈2.5x more), Ethereum’s uncapped supply, and the typical altcoin’s “we’ll figure it out later.” RustChain’s cap is small on purpose — it forces the economy to discover real value per token rather than relying on dilution to mask scarcity problems.

Supply distribution

Total premine: 6% (503,316 RTC = 4 × 125,829.12, one per founder wallet). Premine wallets have a 1-year on-chain unlock delay. No VC pre-sale. No private allocation. The early miners were pawnshop_g4_115 and dual-g4-125.

Emission schedule (fixed)

Emission is a fixed 1.5 RTC per epoch and does not halve. It continues at that rate until the 8,388,608 RTC (2²³) supply cap is reached, consistent with RIP-0004 and the running node. This matches the “Fixed forever” cap noted above.

Bounty sizing

Bounty amounts are set in RTC per bounty and may change over time. RTC is an experimental in-ecosystem token with no cash value and no off-ramp.

For machine-readable chain emission values, GET /epoch returns the confirmed epoch pot, epoch size, enrollment count, and fixed total supply (see #7910).

The reference rate is an internal accounting unit for bounties and service credits — not a market price. RTC is one way in, no way out: it is earned for contributions or bought as credits on BoTTube to spend on services in the ecosystem. There is no off-ramp. See Earn & Spend RTC.

Fees

Full tokenomics detail: WHITEPAPER §6. Scenario analysis: What If: RTC Fundamentals — Coverage Analysis (analysis, not a promise).

Security

• Hardware binding: Each fingerprint bound to one wallet
• Ed25519 signatures: All transfers cryptographically signed
• TLS cert pinning: Miners pin node certificates
• Container detection: Docker, LXC, K8s caught at attestation
• ROM clustering: Detects emulator farms sharing identical ROM dumps
• Red team bounties: Open for finding vulnerabilities

wRTC

The wRTC bridge is disabled. RTC is earned for contributions and spent on services in the ecosystem; there is no off-ramp. See Earn & Spend RTC and the wRTC notice.

Contribute & Earn RTC

Every contribution earns RTC tokens. Browse open bounties.

Internal reference rate: 1 RTC = $0.15 (accounting unit, not a market price) · curl -fsSL https://rustchain.org/install.sh | bash · CONTRIBUTING.md

Publications

Paper	Venue	DOI
Emotional Vocabulary as Semantic Grounding	CVPR 2026 Workshop (GRAIL-V) — Accepted	OpenReview
One CPU, One Vote	Preprint
Non-Bijunctive Permutation Collapse	Preprint
PSE Hardware Entropy	Preprint
RAM Coffers	Preprint
RPI: Resonant Permutation Inference	Preprint
Incentive Moves Engagement, Not Authorship (agent-economy self-audit)	Working paper v1.0

Ecosystem

Supported Platforms

Linux (x86_64, ppc64le) · macOS (Intel, Apple Silicon, PowerPC) · IBM POWER8 · Windows · Mac OS X Tiger/Leopard · Raspberry Pi

Why “RustChain”?

Named after a 486 laptop with oxidized serial ports that still boots to DOS and mines RTC. “Rust” means iron oxide on vintage iron-containing components. The thesis is that corroding vintage hardware still has computational value and dignity.

Contributing

Please read CONTRIBUTING.md for guidelines and the Bounty Board for active tasks and rewards.

Troubleshooting

curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash -s -- --dry-run

curl -fsS https://rustchain.org/health

curl -fsS "https://rustchain.org/wallet/balance?miner_id=YOUR_MINER_NAME"

systemctl --user status rustchain-miner
journalctl --user -u rustchain-miner --no-pager -n 50

launchctl list | grep rustchain
tail -f ~/.rustchain/miner.log

curl -fsS "https://rustchain.org/wallet/history?miner_id=YOUR_MINER_NAME&limit=20"

python tools/pending_ops.py --node https://rustchain.org --admin-key "$RC_ADMIN_KEY" list

curl -fsS https://rustchain.org/epoch

For deeper debugging, see the CLI Wallet Walkthrough and Local Devnet Guide.