World Model Engine

Create infinite experiences, in minutes.

Open source, licensed under Apache 2.0.

Website · Demos · Skill quickstart · Documentation

Your World Model needs an engine.

GENESIS remembers your inventory, characters and locations, applies the rules and describes what happens next. It gives your World Model the memory, shared state and playable interface an infinite experience needs.

Player actions change the world. GENESIS commits the outcome, gives the LLM and scene generator the context, and keeps every player's interface in sync.

Watch the demos · What can you build? · Build from a prompt · Documentation · SDK API · Connect your models · Worldstreams API

Worldstreams in action

Rick and Morty · Multiplayer Worldstream

Two players direct Rick and Morty through their own character controls. Both actions feed the shared Worldstream. Click the image to watch the multiplayer recording.

Watch multiplayer video · Explore the demos

Adventure Time · Land of Ooo	World Model games
A connected fantasy journey with audience-choice controls. Watch video · Try the preview	Explore the visual presentation of World Model game experiences. Watch video

These are recorded Worldstreams examples. Preview choices illustrate the interaction flow around prepared World Model output. Live generation uses a connected provider. Read the SDK reference and world-building skill guide, or run npm run docs:dev to open the searchable documentation site and video gallery locally.

What can you build?

Build worlds people can play, watch, explore, learn from and shape together.

These are directions for your next experience. You supply the domain content and rules, then connect the models or specialist tools it needs.

What GENESIS handles

Pick up a key, and it stays in your inventory. Unlock a door, and that location changes. Meet a character, and your controller can remember the relationship. The next scene receives that context, and every player sees the accepted result.

You define the world and its rules. GENESIS runs the state and interaction loop; connected World Models and LLMs generate the media and structured responses.

One prompt. An infinite experience.

The bundled create-world-stream agent skill turns an idea into world settings, a custom interface, controller rules and a portable project. Follow the skill quickstart to set up Genesis, describe your world and play the result.

Give a coding agent this checkout and a prompt:

Use the create-world-stream skill to build Mosslight, a forest battle
worldstream with a cream pixel interface. Let two players take turns
and have the backend LLM create four moves for each encounter.
Remember their inventory, health and progress. Give me a working
local preview and an exportable world.

The skill wires backend requests, declares assets, validates the bundle and exercises the player flow. AGENTS.md points repo-aware agents to it; other skill-capable agents can load its SKILL.md directly.

Start with labeled local fixtures. With a configured provider and budget, the agent can create and attach images, audio and video for your worldstream.

Play your first world

Requires Node 20 or later. Clone the repository and run:

git clone https://github.com/sequencer-media/genesis.git
cd genesis
npm ci
npm run build
node dist/cli.js init ./my-world --template arena-llm
node dist/cli.js dev ./my-world

Open the printed local URL. Play the vintage pixel battle, switch preview players and take a turn. The starter uses four structured move definitions, shared health and authoritative turns. Local moves and video use prepared fixtures; a connected Worldstreams host requests real backend LLM results.

Choose another starter with --template. Edit the project files, then restart the runner. Sessions pin their project version; remove the generated .genesis/ directory inside your world to start a fresh development session after code changes.

Three files. Your whole world.

my-world/
├── genesis.json      World settings, actions, tools and asset registry
├── interface.html    Your interface, controls and browser behavior
├── controller.js     World memory, shared rules and backend requests
└── assets/           Images, audio and video that travel with the project

The interface sends actions and renders accepted state. The controller updates inventory, variables, characters and locations according to your rules, then requests the next scene. The host supplies identity, credentials, storage and spending policy.

node dist/cli.js validate ./my-world
node dist/cli.js export ./my-world --out ./my-world.zip

The ZIP includes the three entry files, the JSON Schema and complete declared assets. Safe relative paths make media portable; hosting adapters copy assets and provide runtime URLs. Keep provider keys, wallets and commercial settings in the host. Read the project boundary.

Development preview

Version 0.1 is an Apache 2.0 licensed source preview. Clone the repository to build and run it locally. npm publication and the wider launch are being prepared.

npm test
npm run docs:build
npm pack --dry-run

Connect your own World Models

GENESIS works with the providers you choose. Keep your LLM and World Model adapters separate so either can evolve independently.

1. Connect your LLM. Use createLlmProvider with a server-side generate(request, context) callback. Map the prompt, world context, response schema and budget to your provider's API. GENESIS validates the returned data before sending it to the controller.
2. Connect your World Model. Implement the provider contract for submission, status and cancellation. Persist generated media and supply the video's actual end-frame checkpoint. The SDK includes prepared-media and Replicate adapters.
3. Connect your app. Run GenesisHost on your server and mountGenesisPlayer in the browser, joined by authenticated routes. Your host controls identity, credentials, permissions and billing.

Use durable result storage for paid requests. Memory and atomic file adapters support one host process; distributed deployments need transactional storage, admission control and durable scheduling. Live worldstreams also need readiness, prompt delivery, playback acknowledgments, reconnects and viewer revocation. Read the API, architecture and host authority.

Worldstreams API: instant setup

Use the included Sequencer integration to connect the Worldstreams API. One server-side SEQUENCER_API_KEY connects LLM tools, World Model streams, image/audio/video generation, assets and versioned world drafts.

Set your key in the server environment, choose your workspace and save the project:

export SEQUENCER_API_KEY="YOUR_SERVER_API_KEY"
node dist/cli.js save ./my-world --workspace YOUR_WORKSPACE_ID

The command uploads the declared assets and returns a saved draft and preview URL. Use SequencerClient to discover models, quote generation and control a private worldstream. createSequencerLlmProvider connects structured LLM tools to the same account. Follow the integration guide.

Custom LLM calls and additional media generation have separate usage charges. Compare the setup options and Worldstream models, prices and quality rating method.

Build with us

Found an issue or have an idea? Open an issue. Read the contribution guide before making a pull request. If GENESIS is useful to you, star the repository and share what you build.

Contributing · Security · Apache 2.0 license · Sequencer · Worldstreams