Building a Xianxia Cultivation MMO: How I Built a Self-Evolving Text-Based World with Go Microservices

NJHHBJSJKAsjdsasa — Fri, 08 May 2026 09:02:44 +0000

go microservices gamedev opensource mud xianxia

Ever wanted to play a cultivation novel — where you start as a mortal, break through realms, form sects, and contend with heavenly tribulations — all in a world that evolves even when you are offline?
I have been building exactly that: an open-source, multiplayer text-based cultivation world (MUD) powered by Go microservices and AI-driven NPCs. Here is the full story — the architecture, the tech choices, the battles with PostgreSQL, and what it is like to let NPCs loose with an LLM brain.
The Vision: A Living Cultivation World
Chinese xianxia novels describe worlds where mortals climb the path of immortality — forging spiritual roots, mastering techniques, enduring heavenly tribulations. I wanted to capture that feeling in a multiplayer game where the world does not wait for you. NPCs cultivate, form their own sects, trigger world events, and remember their interactions with players.
The core design goals were:
• Persistent world — server ticks even when no players are online
• Deep cultivation system — 10 realms, spiritual roots with purity and mutation, spell discovery
• AI-driven NPCs — not scripted dialogue trees, but actual autonomous agents
• Cause and effect — a Heavenly Dao engine that tracks karma and triggers tribulations
• Scale from day one — microservices so combat, AI, and world events do not compete for CPU
Why Go + Microservices?
I chose Go for three reasons: simplicity under concurrency, fast compilation, and excellent gRPC/Protobuf tooling. Each player action (cultivate, explore, combat, trade) maps cleanly to a gRPC operation, and Go goroutines handle hundreds of concurrent WebSocket connections without breaking a sweat.
The architecture breaks into five services:
Gateway — The single entry point. JWT auth, WebSocket upgrade, and message routing. Players connect here and the Gateway forwards their actions to the right backend via gRPC. It is a thin layer — no game logic, just transport.
Game Server — The core. It handles 31+ action types (cultivate, breakthrough, combat, explore, gather, craft, trade, form sects, etc.), manages entity state, and coordinates with other services. Uses the repository pattern with clean interface boundaries — swap PostgreSQL for something else by implementing a handful of interfaces.
Heavenly Dao — The cosmic rules engine. This service calculates cultivation efficiency, breakthrough probabilities, tribulation triggers, and karma balances. It is the most tested service (table-driven tests with testify) because getting the math wrong means angry cultivators.
AI Scheduler — Where the magic happens. NPCs use behavior trees for routine decisions (wander, rest, gather resources) and fall back to DeepSeek LLM calls for complex social interactions. Each NPC has personality traits, long/short-term memory, and autonomous goal pursuit. Yes, NPCs can start their own sects.
World Engine — Region management, resource spawning, and world events. Things like beast tides, heavenly anomalies, spirit tide surges, and secret realm openings. Events cascade — a beast tide in one region can trigger NPC migration, resource scarcity, and sect conflicts.
The Cultivation System Deep Dive
The cultivation system is the heart of the game. Here is how it works under the hood:
Spiritual Roots
On registration, each player gets 1-3 randomly generated spiritual roots (elemental affinities). 5% chance of a mutation — Wind, Lightning, or Ice instead of the basic Metal/Wood/Water/Fire/Earth. Primary roots have 60-90 purity, secondary roots 20-50. This creates meaningful character diversity from the start.
Cultivation Formula
Efficiency = BaseRate x RootBonus x SpellMatch x RealmDecay x MentalState x (1 - AgingPenalty)
Every term is computed by the Heavenly Dao service. RootBonus depends on element matching with ambient qi. SpellMatch checks if your cultivated techniques align with your roots. RealmDecay prevents staying in low realms forever. MentalState tracks meditation and breaks. AgingPenalty adds urgency — cultivate too slowly and your mortal body degrades.
Breakthrough & Tribulation
Advancing to the next realm requires a breakthrough attempt. Probability is:
P = BaseSuccess x Accumulation x SpellQuality x ResourceBonus x MentalState x Luck
Clamped to [5%, 80%] — you always have a chance, but never a guarantee. Past Nascent Soul, breakthroughs trigger heavenly tribulations with lightning calculations, damage, and potential death. Karma matters too — players who commit too many evil acts face darker, stronger tribulations.
AI NPCs: Letting Characters Loose
The NPC system is what makes the world feel alive. Instead of static shopkeepers and quest-givers, every NPC has:
• A behavior tree for routine actions (explore, rest, gather, cultivate)
• An LLM-powered planning system for complex goals (form a sect, seek revenge, pursue an artifact)
• Personality traits that modify decision weights (aggressive NPCs prefer combat, scholarly ones seek knowledge)
• A memory system with short-term (recent events) and long-term (summarized experience) storage
• Autonomous relationships — NPCs can befriend, rival, or attack each other
The dual-loop design is key: the behavior tree handles 90% of decisions efficiently in-memory, while LLM calls (with prompt caching) handle the 10% that need real understanding. This keeps costs reasonable while delivering unexpected, emergent behavior.
The Tech Stack (Why These Choices)
Component Choice Why
Language Go 1.21/1.25 Concurrency, fast builds, great gRPC support
DB PostgreSQL + Redis PG for ACID compliance, Redis for caching and pub/sub
RPC gRPC + Protobuf Strong typing, code generation, efficient binary protocol
HTTP/WS Gin Lightweight, well-tested, WebSocket support
AI DeepSeek LLM Cost-effective for Chinese and English text generation
Clients CLI / Bubble Tea TUI / Gio GUI Meet players where they are
Orchestration Docker Compose Simple local dev, one command to start everything
Lessons Learned (The Hard Way)
State synchronization is hard: When the Game Server updates a player realm, it needs to notify the Gateway (push to client), Heavenly Dao (recalculate formulas), and World Engine (update visibility). I started with a simple event bus pattern, then migrated to a more robust outbox pattern with Redis streams.
NPC memory management is an unsolved problem: Storing every NPC interaction as raw text grows unboundedly. We use summarization triggers — when short-term memory exceeds a threshold, the LLM summarizes it into long-term memory and discards the raw log. It is not perfect, but it works.
Testing the Heavenly Dao saved us: The karma and tribulation logic is complex — edge cases like: what happens when a player with negative karma faces a tribulation while wearing cursed equipment? The table-driven test pattern in heavenly-dao caught at least a dozen logical errors before they hit production.
CLI-first was the right call: Building the CLI client before the GUI meant we iterated on the protocol and game feel fast. The Bubble Tea TUI came later and reused the same WebSocket message handling. The Gio desktop client taught us what NOT to do in Go GUI development.
What is Next?
The project has come a long way — 5 microservices, 21+ player actions, AI-driven NPCs with personality and memory, a full karma system, world events, mail, shops, leaderboards, and even a Bubble Tea TUI client. But there is more to build:
• Cross-server party dungeons — co-op PVE with friends
• Sect wars and territory control — guild-scale conflict
• A proper Web UI — so players can jump in from a browser
• More world events — player-triggered catastrophes, celestial auctions, wandering demons
Try It Yourself
The entire project is open source on GitHub:
https://github.com/xiuxianxiuxianxiuxian/diershij
It is a single docker-compose up to start everything, plus a Go CLI client that connects in seconds. The README has full instructions in both Chinese and English.
Whether you are a xianxia fan, a Go enthusiast, or just curious about AI-driven game worlds — I would love to hear your thoughts. Open an issue, send a PR, or just star the repo and watch the world evolve.

Built with Go, PostgreSQL, Redis, gRPC, and a healthy obsession with cultivation novels.

DEV Community: NJHHBJSJKAsjdsasa

Building a Xianxia Cultivation MMO: How I Built a Self-Evolving Text-Based World with Go Microservices