Projects

Built on Felix

Real apps that keep all of their state in Felix, with no other datastore, and can be self-hosted. Each one exercises a different part of it.

felix-canvas

0.3.2

A multiplayer drawing canvas with live cursors, rich text, history you can scrub, and per-room sign-in.

Felix features it uses

A durable stream per room holds every edit; the board is a fold of it
An in-memory stream carries cursors and selections
A cache holds snapshots, and another holds who is in the room, with a TTL
Counters hand out per-session sequence numbers
Replicated with Quorum consistency when you run more than one replica

Quick start

curl -fsSL https://github.com/GetFelix/felix-canvas/releases/download/v0.3.2/felix-canvas-compose-0.3.2.tar.gz | tar xz
cd felix-canvas-compose-0.3.2
sed -i.bak \
  -e "s|^FELIX_BOOTSTRAP_TOKEN=.*|FELIX_BOOTSTRAP_TOKEN=$(openssl rand -base64 32)|" \
  -e "s|^FELIX_RAFT_PEER_TOKEN=.*|FELIX_RAFT_PEER_TOKEN=$(openssl rand -base64 32)|" .env
docker compose up -d

Needs Docker or Podman with Compose 2.20 or later; with Podman, run podman compose up -d (see Docker or Podman). Open localhost:8787 in two windows, sign in as ana and ben, and draw. The self-hosting guide covers sign-in, TLS and Kubernetes.

GitHub Docs

felix-arena

0.1.6

A browser team deathmatch in 3D, played through Felix with the simulation deciding every hit. When you are destroyed, the kill cam replays the last seconds from the match's log in Felix.

Felix features it uses

One durable stream holds the match, a record per simulation tick, replicated with Quorum
Atomic commits write each tick together with its keyframe pointer
An in-memory stream carries player inputs
TTL caches track who is connected and each arena's status
A counter holds the simulator's epoch

Quick start

curl -fsSL https://github.com/GetFelix/felix-arena/releases/download/v0.1.6/felix-arena-web-v0.1.6.tar.gz | tar xz
cd felix-arena-web-v0.1.6
python3 -m http.server 5173

Open localhost:5173/play.html?offline to play against bots in the page. To play through Felix, start the development stack from the repository first.

GitHub Docs

felix-webhook-relay

0.2.0

A webhook relay that stores each webhook durably, delivers it with retries, and replays any endpoint after an outage.

Felix features it uses

A durable stream per source, with one shard so every endpoint sees one total order
A consumer group per endpoint, each an independent cursor over the same log
The idempotent producer, so a lost answer never stores a webhook twice
A cache for best-effort deduplication of a sender's retries
A Felix namespace per relay tenant, enforced by the broker

Quick start

curl -fsSL https://github.com/GetFelix/felix-webhook-relay/releases/download/v0.2.0/felix-webhook-relay-compose-0.2.0.tar.gz | tar xz
cd felix-webhook-relay-compose-0.2.0
sed -i.bak \
  -e "s|^FELIX_BOOTSTRAP_TOKEN=.*|FELIX_BOOTSTRAP_TOKEN=$(openssl rand -base64 32)|" \
  -e "s|^FELIX_RAFT_PEER_TOKEN=.*|FELIX_RAFT_PEER_TOKEN=$(openssl rand -base64 32)|" \
  -e "s|^RELAY_SECRET_KEY=.*|RELAY_SECRET_KEY=$(openssl rand -base64 32)|" .env
docker compose up -d --wait

Needs Docker or Podman with Compose 2.20 or later; with Podman, run podman compose up -d --wait (see Docker or Podman). Keep .env, since the relay cannot open its stored secrets without RELAY_SECRET_KEY. Open localhost:8090/admin/acme to sign in; the README walks through the first endpoint.

GitHub Docs

felix-gateway

0.7.0

A WebSocket gateway between browsers and Felix, with sign-in narrowed to one room or match.

Felix features it uses

Stream publish and subscribe from an offset or from live, with each event's offset
Cache reads, writes and watches, with a TTL per cache
Counter adds
Tokens narrowed to one scope, exchanged at the control plane and enforced by the broker
Sender stamping on streams, so a browser cannot speak for someone else

Quick start

git clone --depth 1 --branch v0.7.0 https://github.com/GetFelix/felix-gateway
cd felix-gateway
dev/up.sh
export GATEWAY_FELIX_CA_FILE=dev/state/broker-cert.pem GATEWAY_SCOPE_FILE=dev/scope.toml
export GATEWAY_TENANT=demo GATEWAY_OIDC_CLIENT_ID=felix-gateway
cargo run -p felix-gateway

Needs Docker or Podman, Rust 1.97 and Node 24; set CONTAINER_ENGINE=podman to pick Podman (see Docker or Podman). The gateway listens on localhost:8787; connect from a browser app with npm install felix-gateway-client.

GitHub Docs

felix-metro

0.1.0

A live 3D city simulated on Felix. Each district is a shard, residents commute, and day and night follow the simulation clock. Switch between cities, and a reconnecting browser picks up without losing a tick. Time travel, dragging the timeline back to any earlier moment, is next.

Felix features it uses

A durable stream per city with one shard per district, a record per simulation tick
Atomic commits write each tick, with keyframes pointed to by stream state
Bounded range reads will load a past moment from the nearest keyframe for time travel
Subscribing from an offset plays forward into live with no gap
An expected-offset commit keeps a single simulation writing each city

Quick start

curl -fsSL https://github.com/GetFelix/felix-metro/releases/download/v0.1.0/felix-metro-compose-0.1.0.tar.gz | tar xz
cd felix-metro-compose-0.1.0
./up.sh

Needs Docker or Podman. up.sh returns once the cities are serving; then open localhost:8088/#harbor. The design covers the data model and how seeking will work.

GitHub Design

felix-blocks

In design

A voxel building game in the browser. Dig and build alone, or open your world to friends and build in it together, each of you seeing the other's blocks as they land.

Felix features it will use

A log-backed cache holds the world, one key per edited chunk, so untouched terrain is never stored
Conditional writes let two players edit one chunk at once without either losing a block
A retained cache watch shows a joining player the whole world, then every change
Compaction keeps a world at its current blocks however many edits it has seen
Permissions in Felix separate builders from visitors

Nothing runs yet. Multiplayer waits on conditional writes through felix-gateway, which are planned. The design covers the data model and how edits resolve, and the milestones track the build.

GitHub Design

felix-agents

In design

A swarm of AI workers with Felix as its data backend. Tasks flow out to many workers and results flow back. The viewer is a live picture of the swarm, with workers claiming tasks, sending and receiving work and returning results, and any run can be replayed.

Felix features it will use

A consumer group hands each task to one worker and gives it to another when a worker dies
Conditional cache writes keep workers from overwriting each other's findings and locks
Counters hold a run to its budget when workers race
One durable log records every step, with who wrote it, for replay
Permissions in Felix refuse a prompt-injected worker's writes outside its grants

Nothing runs yet. The clip is the viewer's style frame playing a hand-written run. Workers reach Felix through an MCP server, so any MCP host can join a run. Scrubbing in the browser waits on range reads in felix-gateway's client, which are planned. The design covers the data model and the Felix mapping, and the milestones track the build.

GitHub Design