# DexterHuang/CyberCodeOnline: a text MMORPG whose world is a set of JSON files

> CyberCode Online is a browser and mobile MMORPG built with React and TypeScript, but the interesting part of the repository is not the game code. It is a content pipeline where enemies, dungeon layouts, item lore, tutorials and localizations are contributed as files, validated by a TypeScript script and normalized into the shape the game expects.

**DexterHuang/CyberCodeOnline** — Cyberpunk Text MMO RPG, built with React.js & Typescript

- Repository: https://github.com/DexterHuang/CyberCodeOnline
- Stars: 1,390 · Forks: 1,344
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/dexterhuang-cybercodeonline

## The world is data, and the data is contributed

CyberCode Online is described as a browser and mobile based MMORPG game, built with React.js and TypeScript, and it is meant to be played casually with AFK tasks, leveling and crafting. The game includes a large array of randomly generated enemies, dungeons and locations, and those locations are pulled from a user-contributed list.

That last clause is the design decision that shapes the repository. A game with randomly generated dungeons needs a source of raw material, and instead of hardcoding that material in the game code, the project accepts it as files that anyone can edit. The README's help needed list is effectively the content specification:

- `contribution/words.json` for random words
- `contribution/dungeon/layout/structure-mask.json` for dungeon layouts
- `contribution/mobile/{lang}/tips.md` for tips on mobile
- `contribution/mobile/{lang}/tutorial/*.md` for tutorials
- `contribution/mobile/{lang}/procedural-names` for equipment names, with a note to avoid adding additional tier prefixes so things stay less confusing
- `contribution/mobile/{lang}/item/lore`, `scenario/**` and `dungeon-lore/**` for item, drop and dungeon lore
- `tips.txt` for desktop tips and `tutorial/*` for the desktop tutorial
- `contribution/lang/` for localizations

Two things stand out. The content is split by platform, with separate desktop and mobile trees, which means the same game has two content pipelines. And the lore files are directories rather than single files, so the number of items in the game is bounded by how many people write stories about them.

## Five developer scripts do the unglamorous work

The `package.json` is small, and it tells you what kind of repository this is. The dependencies are `nodemon`, `pathfinding`, `ts-node` and `typescript` itself, with type definitions for Node and for the pathfinding library in the dev dependencies. There is no game engine, no state management library and no build script for a bundle, and the manifest's license field reads ISC.

What it does have is a set of scripts for working with the content, and they are the most useful part of the manifest for anyone who wants to contribute:

```json
"scripts": {
  "watch": "nodemon --watch src src/ValidateJson.ts",
  "start": "ts-node src/ValidateJson.ts",
  "normalize-structure-mask": "ts-node src/Normalize.ts",
  "print-line-numbers": "ts-node src/LineNumbers.ts",
  "print-rooms": "ts-node src/RoomsPrinter.ts"
}
```

`ValidateJson.ts` is the gate. Running the `watch` script restarts it whenever something under `src` changes, and running `start` executes it once, so a contributor editing a layout file gets told immediately whether the JSON is acceptable rather than finding out in a review.

`Normalize.ts` handles the structure mask, which is the file that describes how a dungeon is laid out, and normalising it is what keeps hand-edited layouts consistent with what the generator expects. `RoomsPrinter.ts` prints rooms and `LineNumbers.ts` prints line numbers, and both exist for the same reason: a contributor staring at a large JSON layout needs a way to find the part they are editing, and dumping the structure to the console in a readable form is the cheapest way to do that.

The `src/` directory therefore contains both the game and the tooling that keeps the content honest.

## Pathfinding as a declared dependency

The `pathfinding` package in the dependencies is a small but telling detail. A text MMO with dungeons is a game about moving through a graph of rooms, and the questions of what is reachable from where, and how an agent gets from one room to another, are exactly what a pathfinding library exists to answer.

Its presence also explains the `RoomsPrinter` script. A dungeon layout expressed as a structure mask is a geometric description, and the rooms that come out of it are derived, so being able to print the room list is how you check that a layout you edited produces the space you expected.

The type definitions are pinned separately, with `@types/node` at 18.x and a specific version of `@types/pathfinding`, which is the usual sign of a codebase that was written against a particular toolchain and does not track the latest major of its dependencies. The TypeScript dependency is 4.x, which is a further indication of the same thing. This is a project that pins what it knows works.

## Playing it, and where the bugs go

The game is live at cybercodeonline.com, with a mobile app on Google Play and the Apple App Store, and the README links to both store listings. So the repository is the source for a running product rather than a demo, and the contribution model exists to feed that running game.

The support model is small and direct. Bugs are reported in a Discord server, in a bug report channel, and requests and suggestions are left on the same Discord server. The one exception is notable: if there is a serious exploit, the instruction is not to create an issue on GitHub but to email the maintainer directly. That is a sensible triage rule for a game with a public issue tracker, and it tells you the maintainer is a single person rather than a team.

Contributors are invited directly. The README asks for pull requests from anyone who would like to help maintain the game, and the documentation includes a video on simply editing the files and a note that someone with time to make a better one should say so. The repository also carries `CONTRIBUTING.md`, `Credits.md` and `UpdateNote.md`, plus an `archives/` directory, which is where a project with a long history keeps the material it no longer uses.

## What it is not, and the licence question

The first thing to say is that this is a game, not a platform, and treating it as a TypeScript library will disappoint. There is no published package, the `main` field points at `index.js`, and the scripts are developer utilities. The React and TypeScript code is the client of one specific game with one specific content schema, and the value of the repository lies in that content and the tools that validate it rather than in reusable code.

The second thing is that the content format is simple but not free. The dungeon layout file is a structure mask that has to be normalised, the procedural names have a naming discipline to keep, and the lore directories need a naming scheme to be found. A contributor who skips the validation script will find out in review or, worse, in the game.

The licence needs a note, because the two statements do not match. The repository's licence field is listed as a custom licence that GitHub cannot classify, with a `LICENSE.md` file at the top level, while the `package.json` records ISC. When the manifest and a custom `LICENSE.md` in the tree disagree, the file in the tree is the one to read. And a project with published apps on two app stores has commercial arrangements that the source licence alone does not describe.

On maintenance, the last push was on 2026-10-10 and the repository has no GitHub releases, so the content changes constantly while the versioning is done by app store releases. The `.opencode/` and `.cortexkit/` directories at the top level suggest tool-assisted contribution workflows, and the `hacktoberfest` topic means parts of the content backlog are shaped for seasonal contributions.

## Conclusion

Adopt this repository if you want to run or extend a community text MMO, since the content format is the clearest thing about it, and a dungeon layout, a word list or a localisation can be added without touching the game logic. Do not adopt it as a game engine or a TypeScript library, because the React and TypeScript code is the client of a specific game with a specific content schema, and the package manifest exposes only developer scripts rather than a published library. Verify first which licence governs reuse, since the repository carries a custom `LICENSE.md` while the `package.json` records ISC, and check that the JSON you contribute passes the validation script before opening a pull request.

## FAQ

### What is CyberCodeOnline?

It is a browser and mobile based MMORPG text game built with React.js and TypeScript, meant to be played casually with AFK tasks, leveling and crafting, with randomly generated enemies, dungeons and locations drawn from a user-contributed list. The game runs at cybercodeonline.com and has mobile apps.

### How do I contribute content to CyberCodeOnline?

Edit the files listed in the help needed section, such as `contribution/words.json`, `contribution/dungeon/layout/structure-mask.json`, the mobile tips, tutorial, procedural names and lore files under `contribution/mobile/{lang}/`, or the `contribution/lang/` localizations, then open a pull request.

### How do I check that my JSON contribution is valid?

The package scripts include a validator, `ValidateJson.ts`, which you can run with `npm run start`, or watch continuously with `npm run watch` using nodemon. There are also `npm run normalize-structure-mask`, `npm run print-line-numbers` and `npm run print-rooms` for inspecting dungeon layouts and rooms.

### Where should I report a bug in CyberCodeOnline?

Bugs are reported in the Discord server's bug report channel, and requests and suggestions go to the same server. The exception is a serious exploit, which the README asks you to email to the maintainer directly rather than to post as a GitHub issue.

## Sources

- [DexterHuang/CyberCodeOnline on GitHub](https://github.com/DexterHuang/CyberCodeOnline)
- [Issues](https://github.com/DexterHuang/CyberCodeOnline/issues)
- [README](https://github.com/DexterHuang/CyberCodeOnline/blob/master/README.md)

---

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