PhysarumChain is a Layer-1 blockchain that uses the same path-finding algorithm nature evolved in slime mold to route transactions between nodes. Built-in exchange, real Ed25519 cryptography, smart contracts, and a JavaScript SDK you can drop into any app today.
Mining is verified knowledge, not wasted compute. Each block anchors typed, signed, multi-LLM-cross-checked facts with provenance and decay. The resulting truth-tree is open data for training next-generation AI.
MKB · Native coin·Chain ID 0x504859534152554D·Enter App →
Active nodes49Tx/s266Routes0
Live simulation
PHYSARUM ROUTING · LIVEBIOLOGICAL PATHFINDING
What it is
A complete blockchain, without the complexity.
Most blockchains pick a routing algorithm and bake it in forever. PhysarumChain borrows from biology instead. Physarum polycephalum — a single-celled organism that has no brain — solves the shortest-path problem between food sources by growing tubes and keeping the ones that carry the most flow. We run the same algorithm on our peer-to-peer network.
Every node in the network maintains a conductivity score for each connection it knows about. Routes that carry a lot of traffic grow stronger. Routes that go idle fade away. The result is a network that self-organises around load without a central coordinator, and recovers from failures automatically.
On top of that routing layer sits everything you need for a real blockchain: Ed25519 signed transactions, a native coin (MKB), a built-in token standard, a decentralised exchange, smart contracts with a full stack machine, and Merkle proofs so light clients can verify state without downloading the whole chain.
Source code: open under Apache-2.0 (proposed). The repository hosts the C++20 node, the Python LLM sidecar, the wallet CLI, the test suites, the explorer, and the testnet configuration. There is no closed core.
Why a blockchain · in a cognitive stack
Not just another L1.
A cognitive stack that reasons, remembers, and acts also needs a way to trust. When an agent in our system reports a finding, when a model surgery passes its 4-axis gate, when ADAM commits a claim to its Legion graph — there must be a public, auditable record of who said what, on what evidence, at what time. That's the role this chain plays.
PhysarumChain is not an L1 chasing TVL. It is the trust layer for the rest of the CyberdyneLabs stack: a public substrate where verified claims, agent attestations, surgery results, and knowledge provenance get recorded with cryptographic finality. The DEX, smart contracts, and token standard exist because a trust layer that cannot transfer value is not actually useful to a working knowledge economy — they are the transport, not the point.
So when you see Ed25519 signatures, Cl(4,1) addresses, ~266 single-thread TPS, and the AMM — read them as infrastructure for a knowledge metabolism, not as features competing with Solana. The architectural goal is: compute produces verified claims, claims get provenance, provenance feeds back into cognition.
How it works
Seven layers. One coherent system.
01PHYSARUM ROUTINGP2P LAYER
Network paths that grow themselves.
When your node sends a transaction, it doesn't flood the network with copies. It follows the conductivity scores it has already learned. The path with the best track record gets the traffic. As traffic accumulates, that path strengthens. Idle paths decay.
This is the Physarum equation at work: dD/dt = |Q|^α − μD, where D is conductivity, Q is flow, α=0.6 keeps strong and moderate routes both viable, and μ=0.008 lets dead routes fade in about 125 steps. The network converges to efficient topology by itself.
AlgorithmPhysarum polycephalum — the same path-finding slime mold uses in nature.
Self-healsWhen a node goes offline, its conductivity scores decay to zero and traffic reroutes automatically.
No floodsDirected routing — no broadcast storms, traffic scales with node count.
Conductivity0.73Paths alive0Decay μ 0.008
Live
CONDUCTIVITY · LIVEα=0.6 · μ=0.008
02CGA ADDRESSESCl(4,1) MATH
Addresses built from 5-dimensional geometry.
Most blockchains derive addresses by hashing a public key. PhysarumChain does that too — but each address also maps to a null vector in Cl(4,1) Conformal Geometric Algebra, a 32-component space that encodes position and orientation in 5D projective space.
Why does this matter? Geometric proximity in that space corresponds to routing distance. Nodes that are close in CGA space can relay transactions to each other with lower latency. The address is already a coordinate, not just an identifier.
Dimension32-component multivectors in Cl(4,1) — 5-dimensional conformal space.
Derived fromSHA-256 of your Ed25519 public key, first 20 bytes — standard and secure.
Routing useGeometric proximity guides peer selection at the P2P layer.
Multivector Cl(4,1)Components 32Grade-2 norm0.41
Live
CGA SPACE · LIVENULL VECTOR LATTICE
03BUILT-IN DEXAMM · SWAP
Swap tokens without leaving the chain.
PhysarumChain ships with a built-in automated market maker. You don't deploy a contract to create a liquidity pool — you call a native RPC method. The AMM math runs directly on-chain using 128-bit integers so there are no overflow bugs at large pool sizes.
Create a token, add liquidity, and start trading in three API calls. The DEX also feeds conductivity data back to the Physarum routing layer — high-volume trading pairs get stronger routes between the nodes that host their liquidity.
ModelConstant-product AMM (x·y=k) — the same formula used by Uniswap v2.
Safety128-bit integer math throughout — no floating-point rounding in pool calculations.
TokensFour token types: Standard, Wrapped, LP, and Meme. Up to 7-character symbols.
Pools0 activeVolume0 MKBRatio1.00
Live
AMM · LIVEx · y = k
04REAL CRYPTOGRAPHYEd25519 · CLF-SIGN
Ed25519 on every transaction. 103× faster on the P2P layer.
Every transaction is signed with Ed25519 via OpenSSL. The signature covers your address, the recipient, the amount, the fee, a nonce, and the Chain ID — so a valid transaction on one network can never be replayed on another.
At the P2P layer we go further. Node authentication uses CLF-Sign v1, our Clifford-algebra Schnorr scheme. It runs 103 times faster than standard Ed25519 verification at the node handshake level, which matters when a node is verifying hundreds of peer connections per second.
Tx signingEd25519 via OpenSSL — industry standard, hardware-accelerated, auditable.
Replay guardCHAIN_ID=0x504859534152554D baked into every signature — cross-chain replay is structurally impossible.
// Build and sign a transactionconsttx = await wallet.buildTransaction({
to: "a1b2c3...",
amount: PhysarumRPC.mkbToGrains(10),
fee: 100_000n
});
consthash = await rpc.sendTransaction(tx);
Sig scheme Ed25519P2P auth CLF-SignSpeedup 103×
Live
CRYPTOGRAPHY · LIVESIGNING STREAM
05SMART CONTRACTSPVM · 40 OPCODES
Programs that live on the chain.
A smart contract is a small program you upload to the blockchain. Once it is there, every node on the network runs it the same way — and nobody can edit or delete it. PhysarumVM is the engine inside each node that actually executes that program.
Every action a contract takes uses gas — a metering unit that bounds execution. The schedule is deliberately lean: storage reads cost 50 gas, writes 200, transfers 100. Ethereum, by comparison, charges 5 000–20 000 gas for a single storage write — so per-operation, PhysarumChain charges 25× to 100× less compute. The fiat cost of any transaction depends on what MKB itself ends up worth, exactly like ETH on Ethereum — but the structural overhead per operation is decisively lower. The metering exists to bound execution, not to extract money.
A contract has its own wallet and its own storage. It can hold MKB, remember data between calls, and send funds to any address — exactly like a normal account, except its behaviour is the code you wrote. To deploy, you send one transaction. The contract's address is computed from your address and a counter, so you know where it will live before you publish it.
Machine64-bit stack, max depth 1024 — deterministic, sandboxed, gas-metered.
Gas costsSLOAD=50, SSTORE=200, TRANSFER=100, BALANCE=20 — predictable and transparent.
DeployOne RPC call — address is SHA-256(sender ∥ nonce), no coordination required.
Opcode
Cost
Description
SSTORE
200
Write a value to contract storage
SLOAD
50
Read a value from contract storage
TRANSFER
100
Send MKB to an address
BALANCE
20
Read an account balance
LOG
30
Emit an event
Arithmetic
1
ADD, SUB, MUL, DIV, MOD, AND, OR, XOR…
Opcodes 40Stack depth 1024Max bytecode 64 KB
Live
PVM · LIVESTACK EXECUTION
06MERKLE PROOFSLIGHT CLIENT
Verify any balance without downloading the chain.
Every block contains a state root — the top of a binary Merkle tree built from all account balances. If you want to verify that an address holds a certain balance, you only need the block header and a short proof: a list of sibling hashes that lets you reconstruct the root.
The light client keeps only 228-byte block headers. Each header is signed by the block producer, so a mobile wallet or a browser app can verify proofs without trusting a third party. The chain is auditable from a phone.
State rootBinary sorted Merkle tree over all balances — one root per block, in the header.
Proof sizeO(log n) hashes — a chain with 1 million accounts needs only 20 hashes per proof.
Header size228 bytes — a light client syncs gigabytes of state from kilobytes of headers.
Tree depth20Header 228 bytesProof O(log n)
Live
MERKLE TREE · LIVESTATE PROOFS
Economics
How fees actually work.
A simple transfer pays the floor: 0.0000001 MKB — that is 10 grains, where one MKB is divisible into one hundred million grains (1 MKB = 100 000 000 grains). Almost every user transaction pays exactly this.
A contract call pays more, in proportion to the gas it actually uses. A typical contract interaction is roughly 10× the floor (~0.000001 MKB); a heavy multi-action call can be ~100× (~0.00001 MKB). Storage writes are more expensive than reads, transfers more expensive than arithmetic — same idea as Ethereum, structurally cheaper compute units.
There is no protocol-level treasury. Every fee goes to the block producer that included the transaction. The minimum exists for one reason — anti-spam — not as a revenue model.
Note: MKB has no exchange listing yet. Whatever these numbers convert to in fiat depends entirely on what MKB ends up worth. Same as ETH or SOL — the protocol decides the structure of the fee, the market decides the price.
Network
Typical simple tx
Mechanism
Bitcoin
~$1 – 5
byte-priced, mempool auction
Ethereum
$1 – 50 (spikes $100+)
gas × gasPrice, EIP-1559 base+tip
Solana
$0.0001 – 0.01
flat fee + compute units
PhysarumChain
0.0000001 MKB floor · ~10× for contracts
flat anti-spam floor + gas-priced compute
Layer 6 · Knowledge mining
Mining is verified knowledge, not wasted compute.
Mining on PhysarumChain produces cryptographically signed, multi-LLM-verified facts about the world, anchored in blocks alongside ordinary transactions.
A fact is a typed triple (concepts[2-4], relation, context) where relation is one of ten allowed kinds: CAUSES, PART_OF, PROPERTY_OF, SIMILAR, CONTRASTS, SUPPORTS, TEMPORAL_BEFORE, TEMPORAL_AFTER, DOMAIN, ASSOCIATED. Each fact carries a source URI + SHA-256, the extractor model identifier, a self-declared confidence (0..1), an evidence DAG pointing at prior facts, and a stake-bond in MKB.
A fact reaches the chain only when three gates pass:
Inside the proposing node, a matrix of ≥ 2 small LLMs agrees on the same triple (default models: Qwen 3 0.6B, Gemma 4 E2B/E4B, Llama 3.2 3B).
≥ 2 external validators sign AGREE votes, with at least 2 distinct model_id_hash values. The Sybil gate is model identity, not the wallet.
No CONTRADICTION vote arrives, and no opposite-relation fact already exists on the same concept pair.
Accepted facts are committed into SBlock3.fact_hashes with a Merkle fact_root adjacent to state_root. Light clients can prove fact-inclusion the same way they prove balances.
Per-fact economic gates:
Stake-bond — proposer escrows MKB at submit. Refunded on ACCEPTED, burned on REJECTED / CONTRADICTING / TTL-eviction.
Validator slashing — equivocation (signing two different blocks at the same height) burns 50 % of the offender's stake + supply.
Decay — each fact's effective weight halves every 7 days without reinforcement.
Operator hardware tiers, expected throughput, and the LLM matrix configuration are documented in NODE_OPERATOR.md. The resulting truth-tree is open data for training next-generation AI.
Knowledge-mining parameters (testnet)
Fact wire size (typical)
~220 bytes
FactVote wire size (fixed)
181 bytes
Relations supported
10
Min validators for quorum
2 distinct addresses
Min distinct model families
2
Default decay half-life
7 days
Default bond floor
0 (testnet) → 1 000 000 grains (proposed mainnet)
Default equivocation slash
50 % of stake + supply burn
Fact-store unit tests
92
Multi-process e2e scenarios
11
Pluggable LLM backends.llama.cpp (default) — or CyberdyneLabs research backends linked via the same libflash.so C ABI. No centralised model registry: each operator picks 2–3 open-weight GGUF models from HuggingFace (Qwen 3, Gemma 4, Llama 3 series).
An opt-in bridge to an external ADAM-compatible substrate exists for operators who run one, but the chain is fully standalone — it does not require it.
Transactions / second
~266
Single-thread, Ed25519 included. ~51 K tx/s parallel verify on 8 threads.
Test coverage
289
289 unit tests across 5 suites + 11 multi-process e2e scenarios on real TCP.
Transaction size
208 B
Fixed 208-byte transaction struct. No variable-length encoding surprises.
CLF-Sign speedup
103×
Clifford Schnorr P2P authentication versus standard Ed25519 verify.
Security attacks blocked
40 / 40
Double-spend, replay, forgery, overflow, race — all blocked. Plus 28 fact-consensus tests (T01–T28) and 7 economic-bond tests (T29–T35).
Testnet nodes
50
50-node simulation: valid chains 50/50 on every run.
Finality depth
6 blocks
A transaction is final after 6 confirmations. Configurable per deployment.
Bloom filter
1 MB
3-hash bloom for double-spend detection. Cross-node merge supported.
Tools & ecosystem
Everything you need to build on it today.
01 · JS SDK
Build apps in one file.
physarum.js is a single JavaScript module with no required build step. Create wallets, sign transactions, call every RPC method, and subscribe to live block events via WebSocket. Works in Node.js and the browser.
import { PhysarumWallet, PhysarumRPC } from'./sdk/physarum.js';
const w = PhysarumWallet.fromRandom();
const rpc = newPhysarumRPC('http://localhost:8545');
const bal = await rpc.getBalance(w.address);
02 · Web Wallet
A self-custody wallet that lives in the browser.
The web wallet lets you generate keypairs, view balances, send MKB, and interact with tokens — all from a single HTML file. Keys stay in sessionStorage, never leave your device, and you don't need to install anything.
03 · Testnet Faucet
Get test tokens immediately.
The faucet holds 500,000 MKB on testnet. Paste your address and receive tokens in seconds. The faucet wallet is fully transparent — its address and genesis allocation are published in the genesis file.
04 · Token Launchpad
Launch a token in three clicks.
The PumpFun-style launchpad lets you create tokens, seed liquidity pools, and watch live price charts on the built-in DEX — all from a single page. No Solidity, no deployment scripts, no bridges.
05 · Block Explorer
Inspect every block, transaction, and account.
Query blocks by height, look up transaction hashes, check account balances with full Merkle proof verification, and browse DEX pool state — all via the JSON-RPC API with 31 documented methods.
06 · Docker
Run a full node in one command.
The Dockerfile sets up a complete node with RPC on port 8545, WebSocket on 8546, and metrics on 9090. Environment variables control every parameter — ports, peers, fees, Physarum dynamics, data directory.
docker run -e PHYSARUM_RPC_PORT=8545 \
-p 8545:8545 physarumchain/node
All 39 methods on a single JSON-RPC endpoint. Full request/response examples in sdk/physarum.js and the open-source repository.
Design principles
Three choices that set it apart.
01
Biology over brute force.
Classical networks route by flooding or by static tables. Physarum routing learns from traffic and self-organises. No routing committee. No configuration. The network finds good paths on its own.
02
Everything on-chain.
The exchange, the token standard, and the virtual machine ship as part of the core node — not as contracts you deploy on top. Less attack surface. No bridge risk. One binary, full stack.
03
Real numbers, honest benchmarks.
The ~266 single-thread TPS figure includes full Ed25519 signing — no shortcuts. Parallel verify on 8 threads reaches ~51 K tx/s under the same assumptions. The 289 test count is real (5 suites + 11 e2e scenarios on real TCP). The 40/40 security attacks blocked is reproducible — run the suite yourself in under two minutes.
Get started
Explore the chain. Run a node. Try it today.
Block explorer, wallet generator, DEX, token ledger, and node downloads — all live and connected to the running testnet. One click to enter, five minutes to run your own node.