# Daoyou: An AIGC-Driven Text Cultivation Game Built on Hono, React, and a Strict Numeric Core

> Daoyou (万界道友) is an open-source, AIGC-driven text game set in a Chinese xianxia cultivation world. It pairs free-form player input with DeepSeek-generated responses, while keeping combat and progression locked to a deterministic TypeScript engine.

**ChurchTao/Daoyou** — Wan Jie Dao You is an open-source game driven by AIGC, featuring a highly free-form text experience set in a cultivation (xianxia) world. You play as an ordinary cultivator, advancing your path step by step through techniques, spiritual roots, supernatural powers, magic treasures and chance encounters.

- Repository: https://github.com/ChurchTao/Daoyou
- Website: https://daoyou.org
- Stars: 154 · Forks: 51
- Language: TypeScript
- License: GPL-3.0
- Published: 2026-08-26 · Updated: 2026-08-26 · Language: en
- Canonical page: https://hysenlabs.com/projects/churchtao-daoyou

## What Daoyou Actually Solves

Daoyou targets a specific gap: most text games either hard-code every response, which limits replayability, or hand all control to an LLM, which destroys numeric consistency. The project's stated vision is a '修仙宇宙的开源骨架', an open-source skeleton for a cultivation universe. It wants to combine high-freedom text input with AIGC feedback, while keeping a strict numeric and combat model. The intended user is a developer or creator who wants to build their own xianxia world without starting from zero. They get a running game loop, a cultivation system, and a combat engine, plus an AI layer that generates character backgrounds, battle reports, encounters, and item descriptions. The README is explicit that the current implementation is Hono plus a React SPA, and that older Next.js architecture notes are obsolete. That clarity is useful, because it tells you exactly what stack you are inheriting.

## The Architecture: Engine, Service, API, and Real-Time Messaging

The repository layout shows a clean separation. The backend entry is src/index.ts, which exports a Hono API and WebSocket configuration. Under src/server you have the API, authentication, service layer, and database access. The frontend is a React SPA in src/react-app. Shared code lives in src/shared, containing the engine, configuration, types, and contracts. The engine is the part that enforces the cultivation rules: realms from Qi Refining to Tribulation, spiritual roots across five elements plus wind, thunder, and ice, techniques, fate, alchemy, and artifact refining. Combat is time-axis turn-based, with abilities, treasures, buffs and debuffs, five-element countering, and damage pipelines. That is a substantial amount of deterministic logic. The AI layer sits on top, using the AI SDK with DeepSeek as the single provider. The README does not describe how AI output is validated against the engine, which is a notable gap. Real-time features use NATS JetStream and NATS Core for messaging and broadcasting, with Redis for caching and coordination. That is a heavier infrastructure footprint than most hobby projects, but it makes sense if you plan to run multiple game servers or need live events.

## Getting It Running: Stack and Commands

The README points to docs/development.md for full setup details, but the tech overview gives the concrete stack. Server: Hono 4 on Bun. Frontend: React 19, React Router 7, Vite 8. Styling: Tailwind CSS 4. Database: PostgreSQL with Drizzle ORM. Cache and coordination: Redis. Messaging: NATS JetStream and NATS Core. Authentication: Better Auth. AI: AI SDK with DeepSeek. The repository includes a docker/Dockerfile.app for the Bun main service, and scripts/ contains deployment scripts and a NATS Compose file. There are two separate migration directories: drizzle for business tables and drizzle-auth for Better Auth. That split is practical. To run it locally, you need to install Bun, set up PostgreSQL and Redis, configure environment variables as documented, run migrations, then start the dev server. The exact commands are not in the README excerpt, so you must read docs/development.md. The presence of a Dockerfile suggests containerized deployment is supported, but the README does not give a docker-compose example. Expect to spend time wiring up NATS if you want the full real-time stack.

## The '万界' Federation Model: A Real Multi-Server Index

One distinctive feature is the '万界' (Ten Thousand Worlds) directory. It is a public index of servers deployed from this repository by different maintainers. The README lists two examples: the official server and '云梦界', which adds an underground black market, auction house, and spirit fields, focusing on player interaction, economy, and long-term progression. To join the index, a server operator must submit an issue using a template, and meet conditions: the world name must be 2 to 5 Chinese characters, not impersonate the official one; the full source code of the deployed version must be publicly accessible and retain the project's attribution and license; the website must be public and disclose features, maintainer, and any payments, ads, or data collection; no illegal or fraudulent content. Servers that become inaccessible or stop publishing source may be removed. The README explicitly states that inclusion is not an endorsement of security, availability, or content, and warns against reusing passwords across servers. This is a pragmatic approach to a common problem: how to let a community fork and run your game without losing control of the brand. It also creates a legal expectation that all listed servers remain GPL-compliant, since source must be public.

## Limitations and Wrong-Tool Cases

The biggest limitation is the lack of documented AI output validation. The README says AI generates character backgrounds, combat reports, encounters, and item descriptions, but it does not say how the engine prevents the AI from contradicting the numeric state. For example, can a generated battle report claim a character used a technique they do not have? The README does not address that. That is a critical question for any AIGC game that claims strict numeric consistency. Another limitation is the infrastructure complexity. Requiring PostgreSQL, Redis, and NATS is fine for a serious deployment, but it is heavy for a solo developer who just wants to try the game. The README also notes that the current implementation is Hono plus React SPA, which means any tutorials or blog posts about the old Next.js version are useless. The game is in Chinese, and the UI is text-based with an ink-wash aesthetic, so it is not aimed at a Western audience. If you want a graphical game or a system that works without an external AI API, this is the wrong tool. The GPL-3.0 license also means any derivative server you run publicly must release its source under the same license, which may be a dealbreaker for commercial projects.

## Alternatives: What Else Exists

The obvious alternative is to build your own text game with a generic LLM API and a simple state machine. That approach gives you full control over the validation logic, but you lose the cultivation system, combat engine, and the community index. Another alternative is to use an existing interactive fiction engine like Ink or Twine, which are designed for branching narratives but do not have a built-in numeric combat model or AI integration. Daoyou's difference is that it couples a strict engine with an AI layer, and it provides a ready-made federation mechanism. If you want a pure narrative experience, Twine is simpler. If you want a number-heavy RPG, you might start with a game framework like Phaser or even a tabletop simulator, but those do not handle text generation. Daoyou occupies a niche: a self-hostable, AI-driven, text-based RPG with a real combat system. The '万界' index is a unique feature that none of those alternatives offer, since it creates a network of interoperable servers.

## Maintenance, License, and Upgrade Considerations

The project is actively maintained, with releases v0.3.3, v0.3.4, and v0.3.5 all in August 2026, and the last push on the same day as the latest release. That suggests a fast iteration cycle. The README mentions a development and deployment guide in docs/development.md, which is the place to look for upgrade paths. The license is GPL-3.0, which means you can freely copy and modify the code, but any distributed version must be under the same license and provide attribution. The README also has a sponsorship section via Afdian, with a note that sponsorship does not affect game numbers or account rights. For operators, the maintenance cost includes running PostgreSQL, Redis, NATS, and a DeepSeek API key, which has ongoing costs. The presence of a Dockerfile for the app service helps, but you still need to manage the other services. The '万界' index rules require you to keep your source public if you want to be listed, which is a long-term commitment. Before adopting, verify the current docs for any breaking changes between versions, since the project is moving quickly.

## Conclusion

Adopt Daoyou if you want a working, self-hostable base for a text-based cultivation or fantasy game where AI generates narrative but a fixed engine governs numbers. It suits developers comfortable with TypeScript, Bun, PostgreSQL, Redis, and NATS, and willing to run their own AI backend via DeepSeek. Do not adopt it if you expect a complete game with polished UI, or if you need a system where every AI output is validated against the game state; the README does not describe such safeguards. Before deploying, verify the current docs/development.md for environment variables and database setup, confirm your DeepSeek API key works, and check the GPL-3.0 obligations if you plan to modify and distribute your own server. Also review the '万界' directory rules if you intend to list your instance publicly.

## FAQ

### What is Daoyou and what is it built with?

An open source cultivation text game where players describe their character and an AI generates feedback. The server is Hono 4 on Bun, the front end is React 19 with Vite 8 and Tailwind CSS 4, and data is in PostgreSQL through Drizzle ORM with Redis, NATS, Better Auth and DeepSeek.

### How do I run Daoyou locally?

Run bun run services up -d --wait, then bun run db:migrate, then bun run dev, and open http://127.0.0.1:5174. The services command is a Docker Compose invocation using the env/local.env file that ships with the repository. A staging variant reads env/staging.env instead.

### Does Daoyou need a language model API key to play?

The AI path is where the model calls happen. The README states that character backgrounds, battle broadcasts, encounter stories and item descriptions are generated and that DeepSeek is currently the unified provider, with the package manifest also pinning an Alibaba provider, so the provider is configurable rather than fixed.

### Can I run my own Daoyou server and list it publicly?

Yes, through an application issue. The name must be two to five Chinese characters, the deployed version's full source must be publicly accessible with attribution and licence notices retained, and the site must disclose its maintainer plus any payment, advertising or data collection. Servers that break those rules can be removed.

### What licence is Daoyou under?

GNU General Public License v3.0. You may share and adapt the work, with two obligations: give appropriate attribution, and distribute your contributions under the same licence.

### What do the Ink components in Daoyou do?

Ink is the component library behind the text-only interface, with 21 components, following an ink-wash aesthetic adapted for mobile screens. The design rule the project states is that text is the interface, so there is no rendered game world.

## Sources

- [Official documentation](https://daoyou.org)
- [Official README](https://github.com/ChurchTao/Daoyou#readme)
- [Project repository](https://github.com/ChurchTao/Daoyou)
- [Release notes](https://github.com/ChurchTao/Daoyou/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/churchtao-daoyou