OpenWorld is a pixel-art open-world RPG that runs in the browser, together with the engine and editor it is built on. Everything in the world follows rules written as data. When a player tries something no rule covers, a language model can propose a new rule, which the engine validates before applying it. The game is fully playable without a model.

Play it at openworldrpg.ai · project page

OpenWorld is the research platform for the paper Large Symbolic World (in preparation).

• Features
• How the AI fits in
• Getting started
• Controls
• Engine and editor
• AI setup
• Repository layout
• Development
• Documentation
• Contributing
• Citation
• Credits and license

The game

• A world of more than a thousand maps: villages, cities, wilderness and dungeons
• A main story with side quests and repeatable jobs
• Real-time combat, with boss fights whose attacks are telegraphed on the ground
• Crafting, farming, and building on your own land
• Characters with homes, jobs and daily routines, who trade and react to what they see
• English and Chinese

The engine and editor

• A deterministic TypeScript engine that runs in a Web Worker; a game's rules and content are data
• Optional modules for character classes, hunger, loot, characters' social behaviour and more
• An editor, in the browser or as a desktop app, for maps, characters, items, rules, story and quests, with playtesting and export
• Games packaged as standalone bundles that the same player runs

Every interaction in the game is decided by rules attached to types of objects. When no rule defines what an action does, the engine can ask a language model for one. The new rule may only fill that gap, never change behaviour that is already defined, and it is tested in a sandbox before it is accepted. Accepted rules are shared, so the next player who tries the same thing gets the same result. Without a model, such actions fall back to a default, usually that nothing happens. Details: docs/design.md §5.

Requirements: Node.js 24 and npm. A language model is optional.

npm install
npm run gen:world     # generate the world data
npm run dev           # the game at http://localhost:5173, the AI rule service on port 8787

npm run dev asks which model backend to use (AI setup); npm run dev:client starts the game alone. npm run build produces a static site in games/openworld/client/dist.

All keys can be rebound in Options → Keys.

npm run play                          # the standalone player: http://localhost:5174/?game=/games/starter/
npm run editor                        # the editor: http://localhost:5175/editor/
npm run editor:build                  # build the editor as a standalone program, then: npm run editor:start
npm run desktop                       # the editor as a desktop app (npm run desktop:dist builds installers)
npm run game -- check games/starter   # validate a game project (build <project> --out <dir> makes a bundle)

The editor opens game projects from any folder. It edits maps, characters, items and other data, sprites and sounds, rules, story and quests; fills gaps in the rules by hand or with a model; starts a playtest anywhere on a map; and exports a game as a standalone web build. games/starter is a minimal example project.

The AI rule service is optional. Choose a backend with npm run dev -- --backend <name> or LSW_MODEL_BACKEND, and put its settings in .env (not committed):

--model <id> and --effort <level> pick the chosen backend's model and effort; left out, the backend's default or .env is used. --fast asks claude-code for fast mode and codex for its fast tier.

npm run dev -- --backend codex --fast                      # Codex, gpt-6.1-sol, fast tier
npm run dev -- --backend codex --model gpt-6-luna --effort medium
npm run dev -- --backend claude-code --model claude-sonnet-5-5

npm run modder -- serve                    # run the service on its own, on port 8787
npm run modder -- serve 8787 --script packages/ai/fixtures/offline.json --data var/offline   # scripted, no model

In development the game connects to http://localhost:8787. Elsewhere, pass ?modder=<url> or set VITE_MODDER_URL at build time (?modder=off disables it). Players of a published build can instead enter their own API key, which stays in their browser (Options → Your model; docs/byok.md). An overview of the AI code is in docs/ai.md.

The engine packages never import a game, and games never import each other (packages/engine/test/boundaries.test.ts).

npm run check         # typecheck and tests, as in CI
npm test
npm run typecheck
npm run coverage      # rule coverage report; commit the updated baseline with rule changes
npm run check:world   # headless playtest over two in-game days
npm run scale         # performance check across fifty maps
npm run test:ui       # browser tests of the interface (first run: npx playwright install chromium)

The interface components and their test page are described in docs/ui.md.

Wiki. An encyclopedia of the game with a page for every item, character, creature, place and quest, partly generated from the game data. It is written in Chinese, with an English edition. Editing guide: wiki/pages/帮助/编辑入门.md.

npm run wiki          # http://localhost:5180/wiki/
npm run wiki:check    # check links and that every item and system has a page
npm run wiki:build

Assets. The subset of the Ninja Adventure pack the game uses is committed in games/openworld/public/assets/na/. To update it, put the full pack in assets/ninja-adventure/ and run npm run assets.

• Open a pull request against main. CI runs the typecheck and tests, and also builds the game without packages/ai.
• Add game behaviour as rules in games/openworld/content, not as engine code.
• Changes to the demo maps need a matching check in games/openworld/tools/test/demo.test.ts.
• New items, characters and systems need a wiki page (npm run wiki:check enforces this).
• Build new interface panels from the shared components (docs/ui.md).
• Write code, comments and documentation in English.

Architecture notes and project conventions: CLAUDE.md.

If you use OpenWorld in your research, please cite:

@misc{openworld2026,
  title        = {OpenWorld: A Large Symbolic World},
  author       = {{OpenWorld Team}},
  year         = {2026},
  howpublished = {\url{https://openworldrpg.ai/}}
}

• Code: MIT.
• The project's own art (games/openworld/public/assets/lsw/): CC0 1.0.
• Art and audio from Ninja Adventure by Pixel-boy and AAA: CC0.
• Font: Fusion Pixel, under the SIL Open Font License 1.1 (packages/runtime/src/fonts/).