🧩 HyperToken

The Distributed Simulation Engine

A simulation engine where relationships create meaning, and meaning creates worlds. No servers. No blockchain. Just math that works.

Play ⚔️ Cuttle now!

The problem

Multiplayer games and simulations have a dirty secret: they all depend on servers. Servers cost money. Servers get shut down. When the company dies, the world dies with it.

Blockchain tried to fix this. It made things worse. Gas fees. 15-second confirmation times. Environmental disasters. And you still can't play offline.

Meanwhile, researchers building multi-agent AI systems have to cobble together their own networking code, or pay for cloud infrastructure, or just run everything single-player and hope it generalizes.

HyperToken's answer

The entire game state is a CRDT (Conflict-free Replicated Data Type). Built on Automerge, the same technology behind local-first software.

This means:

• No servers required — Any peer can host
• Instant local execution — No waiting for confirmation
• Mathematically guaranteed consistency — Desyncs are impossible
• Perfect audit trail — Every action recorded with actor and timestamp
• Offline-first — Play continues during network partitions

Traditional multiplayer: You → Server → Permission → Maybe 💸

Blockchain: You → Smart Contract → Gas Fee → Wait 15 seconds ⛽

HyperToken: You → CRDT Merge → Same result everywhere 🆓

Who benefits

Technical architecture

┌─────────────────────────────────────────────────────────────────┐
│                          Engine                                  │
│  Coordinates game logic, dispatches actions, manages networking │
├─────────────────────────────────────────────────────────────────┤
│   ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐     │
│   │  Stack  │    │  Space  │    │ Source  │    │ Agents  │     │
│   │ (cards) │    │ (zones) │    │ (decks) │    │(players)│     │
│   └────┬────┘    └────┬────┘    └────┬────┘    └────┬────┘     │
│        └──────────────┴──────────────┴──────────────┘           │
│                     ┌────────▼────────┐                         │
│                     │    Chronicle    │                         │
│                     │  (CRDT State)   │                         │
│                     └────────┬────────┘                         │
└──────────────────────────────┼───────────────────────────────────┘
                    ┌──────────▼──────────┐
                    │   Network Layer     │
                    │  (P2P / WebSocket)  │
                    └─────────────────────┘

• Chronicle — Automerge CRDT for distributed state
• Token — Immutable game entities (cards, pieces, items)
• Stack/Space/Source — Containers with domain semantics
• Rule Engine — Declarative game logic
• Gym Interface — OpenAI Gym / PettingZoo compatible

AI research integration

Any HyperToken game is automatically a reinforcement learning environment:

from hypertoken import HyperTokenAECEnv

env = HyperTokenAECEnv("ws://localhost:9999")
env.reset(seed=42)

for agent in env.agent_iter():
    obs, reward, term, trunc, info = env.last()
    action = policy(obs) if not (term or trunc) else None
    env.step(action)

Deterministic replay means every experiment is reproducible. No graphics overhead means faster training. Multi-agent support is native, not bolted on.

What it actually does

• 67 built-in actions (draw, shuffle, place, move, flip, merge, split...)
• Host-authoritative P2P networking
• WebSocket + WebRTC transport
• WASM acceleration (Rust core, ~20x performance)
• MCP server for LLM integration
• Docker deployment ready
• Works in browser, Node.js, or Python

Try it

git clone https://github.com/flammafex/hypertoken
cd hypertoken
npm install
npm run build
npm test

Run the blackjack example:

npm run example:blackjack

Start a multi-agent server:

npx hypertoken bridge --env blackjack --port 9999

Why this matters for the open web

Local-first software is the future of user-respecting computing. Data lives on your device. Sync happens when convenient. No company can revoke your access to your own creations.

HyperToken extends this philosophy to interactive shared experiences. Games, simulations, and virtual worlds that:

• Don't require corporate infrastructure
• Can't be shut down by a boardroom decision
• Fork and merge like Git repositories
• Outlive their creators

This is community ownership of digital spaces, made mathematically possible.

Funding goals

We're seeking support for:

• Documentation & tutorials — Lower the barrier for researchers and indie devs
• Reference implementations — More example games beyond blackjack
• Browser sandbox — Try HyperToken without installing anything
• Academic partnerships — Integration with ML research workflows
• Protocol standardization — Interoperability with other local-first tools

Status

• ✅ Core engine complete
• ✅ CRDT synchronization working
• ✅ P2P networking functional
• ✅ Python bridge for RL training
• ✅ WASM acceleration ready
• 🔄 Documentation in progress
• 🔜 Browser playground

Built by The Carpocratian Church of Commonality and Equality. Apache 2.0 licensed. Source on GitHub.