u/DANAMITE

Official game title: Bitiverse

Bitiverse is a free old-school sandbox MMORPG that runs directly in your browser. It has one persistent shared world where players fight monsters, train skills, gather resources, craft equipment, trade, join guilds, complete quests, claim land, build houses and eventually construct personal dungeons beneath their estates.

I’m the solo developer. The game is fully released and actively developed, as is tradition with MMOs, it will presumably stop receiving updates shortly after the sun burns out.

The presentation is deliberately tiny and lightweight. You can enter as a guest without creating an account, then register later if you decide your underqualified adventurer is worth preserving.

Minimum requirements

• OS: Windows 10 64-bit or a current 64-bit Linux distribution
• CPU: Dual-core processor at 2.0 GHz
• GPU: Integrated graphics with WebGL 2.0 support
• RAM: 4 GB
• Storage: Approximately 100 MB available
• Internet connection and a current version of Chrome, Edge or Firefox

Peripherals

A keyboard and mouse are recommended. No controller or specialized hardware is required.

Play here

https://fortisq.itch.io/bitiverse

Bugs and support

Open the in-game Help panel with ?, select the Support tab and submit a private ticket. You can also reply there when I respond.

A few useful tips

• Walk into enemies for the basic melee attack.
• Press E to interact, gather and speak with nearby NPCs.
• The font can be changed in Settings.
• Follow the opening tutorial and read your uncle’s letter if you would prefer slightly less aimless wandering.
• Expect an old-school sandbox rather than a guided theme-park MMO. The game gives you systems, a world and questionable freedom; what you do with them is largely your problem.

It probably won’t replace your forever-MMO, but I’d genuinely appreciate people trying it on older or low-end hardware and reporting how it performs.

About a week ago I asked r/mmo to try Bitiverse. A surprising number of you actually did. You built houses, formed neighborhoods, joined the Discord, found bugs and occasionally got murdered by crabs.

So I spent the week building what those homesteads eventually become.

High-level players can now dig persistent dungeons beneath their own houses, clear and decorate the rooms, stock a safe area, and attract NPC heroes above the normal level cap. You equip, feed and support your hero while they fight the things you can’t. Friends and guildmates can help, and if your hero dies, their equipment and five Dungeoneering levels go with them.

It’s basically an endgame where your character stops being the disposable adventurer and becomes the strange dungeon landlord sending someone else into danger.

I also added music, clearer combat feedback, better-looking dungeons, and a much shorter new-player introduction.

Still early, still free, still playable immediately without an account:

https://fortisq.itch.io/bitiverse

Returning characters are still there. Their basements may now contain problems.

Hey! I’ve been building Bitiverse, a weird little persistent 1-bit RPG that runs in your browser.

It has finally reached the point where I need actual humans to come wander around and break things in ways I never anticipated.

There’s no account wall anymore just press Play, make a character, and jump in. You can create an account later if you decide the character is worth keeping.

It’s one shared world where you can explore, fight monsters, raid procedural dungeons, gather resources, craft equipment, trade, join a guild, and build a homestead. Houses can be named and expanded with upper floors, and the nicer spots around established areas are first come, first served. There’s still plenty of wilderness, but this is probably the fun time to plant your flag before the neighborhood develops opinions.

The game is very early. Some parts are surprisingly deep; other parts may be held together by one pixel and a nervous goblin. I’m not expecting anyone to call it their new forever-MMO, I’d just love some people to try it, tell me where they got confused or bored, and help make the world feel inhabited.

You can play free here:

https://fortisq.itch.io/bitiverse

If you build a house, let me know where. I’m curious what the first actual neighborhoods will look like.

This is Bitiverse, a browser-based multiplayer RPG I’ve been developing.

Players share a procedurally generated world with persistent characters, houses, guilds, markets, vendors, and an economy. You can fight monsters, cast spells, complete quests, gather materials, craft equipment, trade with other players, build a home, and explore dungeons.

I used Codex as an AI development assistant for implementation, debugging, and testing. The visual assets are not AI-generated; they come from the CC0 Urizen one-bit tileset.

It’s currently free to play in a browser:

https://fortisq.itch.io/bitiverse

My main concern now is whether the tiny graphics successfully communicate what is happening, or whether every screenshot resembles an unusually organized ant colony.

I began Bitiverse with the famously safe sentence, “I’ll make a small multiplayer RPG.”

It now has a persistent procedural world, real-time combat, magic, quests, crafting, housing, guilds, trading, banks, player vendors, dungeons, support tickets, and admin tools. The feature list escaped containment some time ago.

It’s a browser game built with TypeScript, Canvas2D, Vite and SpacetimeDB. I also used Codex heavily during development for implementation, testing and debugging. The artwork is not AI-generated; it uses the CC0 Urizen one-bit tileset.

The biggest challenge wasn’t adding individual features. It was preventing each new feature from quietly breaking three older ones. I eventually wrote down strict architectural rules for the project and built tests around the dangerous systems. Procedural generation, for example, must produce exactly the same world on the client and server. The base terrain is never stored in the database,only changes made by players are saved.

That structure made it possible to keep growing the game without turning the codebase into an archaeological site.

The game is now playable for free here: https://fortisq.itch.io/bitiverse

I’m entering the much scarier stage where other humans can press the buttons.

Game Title: Bitiverse

Playable Link: https://fortisq.itch.io/bitiverse

Platform: Web Browser

Description:
Bitiverse is a free multiplayer RPG that runs directly in your browser. Everyone plays in the same persistent, procedurally generated world, where characters, houses, guilds, belongings, and questionable financial decisions remain after you log out.

You can fight monsters, learn magic, complete quests, gather resources, craft equipment, trade with other players, join a guild, explore dungeons, operate a vendor, use the player market, and build your own home. There is nothing to download—just create an account, make a character, and begin aggressively walking into goblins.

The game is in an early release, so I’m looking for players willing to test it and report anything confusing, broken, unbalanced, or unexpectedly hilarious. I’m especially interested in how understandable the opening experience is for someone playing without instructions.

The artwork uses the CC0 Urizen one-bit tileset.

Tiny pixels. Big world. Poor decisions.

Free to Play Status:

- [x] Free to play
- [ ] Demo/Key available
- [ ] Paid

Involvement:

I’m the creator and developer of Bitiverse. I designed the game and its systems and built the browser client, multiplayer server, procedural world, combat, economy, quests, guilds, housing, trading, dungeons, administration tools, and supporting tests. I used Codex as an AI development assistant during implementation, debugging, and testing. The artwork itself is not AI-generated.**Title:** Bitiverse — A Free Persistent Multiplayer RPG With Tiny Pixels and Poor Decisions

I started with a one-bit tileset and the extremely reasonable thought, “I’ll make a small multiplayer RPG.”

The small RPG now has a persistent procedural world, combat, magic, quests, gathering, crafting, housing, guilds, trading, player vendors, banks, dungeons, an economy, support tickets, and admin tools.

It’s called Bitiverse, and you can play it in your browser.

I built it with Codex using TypeScript, Vite, Canvas2D, SpacetimeDB, and Vitest. The artwork itself isn’t AI-generated—it comes from the CC0 Urizen one-bit tileset. The vibe coding went into the game systems, server, client, tests, tools, and the occasional investigation into why a goblin had become functionally immortal.

The biggest lesson was that vibe coding worked brilliantly while the project was small. As it grew, “please add player housing” became a dangerous prompt. The AI might build a perfectly functional house while accidentally setting fire to three architectural assumptions in another part of the game.

What helped was giving the project a written constitution. I documented rules such as:

• The server is always authoritative.
• Procedural generation must produce identical results on the client and server.
• Base terrain is never stored; only changes to the world are saved.
• Never use uncontrolled randomness in shared game logic.
• Scheduled server systems must shut themselves down when nobody is playing.
• Every database schema change must regenerate and verify the client bindings.

After that, I stopped asking the AI to build large features in one shot. I’d have it inspect the relevant systems, propose a narrow implementation, write tests around the risky logic, implement one slice, and then verify the actual running game.

That changed the experience from “slot machine that sometimes produces software” into something much closer to working with a very fast development team that requires unusually explicit management.

The funniest part is that writing tests became more important as the AI got faster. Without them, the project could accumulate plausible-looking mistakes at industrial speed. With them, I could make large changes without discovering two days later that depositing a sword into the bank had somehow disbanded your guild.

Here’s the result:

https://fortisq.itch.io/bitiverse

I’m curious how other people handle the point where a vibe-coded project becomes too large to fit comfortably in one conversation. Do you lean on project instruction files, tests, architecture docs, specialized agents, or raw confidence and frequent backups?

Tiny pixels. Big world. Questionable prompts.

Full disclosure: I’m the developer, and this is self-promotion.

I’ve been building Bitiverse, a small persistent-world multiplayer RPG that runs directly in your browser. I’m not calling it the next WoW. It’s more like WoW was placed in a hydraulic press until only the systems and approximately two colors remained.

Everyone plays in the same procedurally generated world. You can fight monsters, learn spells, complete quests, gather resources, craft equipment, trade with players, join guilds, run a vendor, explore dungeons, and build a home. The world is persistent, so your character, belongings, house, and deeply questionable financial decisions are still there when you return.

My biggest inspirations are older MMOs where the world itself mattered: player economies, recognizable towns, social systems, housing, and occasionally spending an entire evening accomplishing absolutely nothing because you got distracted talking beside a bank.

It’s still early and currently much closer to a cozy, small-community MMO than a massive theme-park production. There’s no installer, subscription, battle pass, daily login calendar, or pop-up informing you that twelve currencies are about to expire.

You can play it here:

https://fortisq.itch.io/bitiverse

Tiny pixels. Big world. Poor decisions.

Hey everyone! I’ve been building **Bitiverse**, a browser-based multiplayer RPG where everything is one bit, everyone is underqualified, and the goblins have somehow entered upper management.

I used AI as a development partner throughout the project. The interesting part wasn’t asking it to “make me a game.” It was breaking the game into small systems with hard rules, then having the AI help implement, test, and pressure-test each one.

Bitiverse has a procedurally generated shared world, real-time multiplayer, combat, spells, gathering, crafting, housing, dungeons, trading, guilds, quests, player vendors, banking, support tools, and an alarming number of ways to acquire chairs. The client runs in the browser, while the game server is a TypeScript module running inside SpacetimeDB.

One of the biggest lessons was that AI worked best when I gave it invariants instead of vague feature requests. Terrain generation has to remain perfectly deterministic on both the client and server. The database stores changes to the world, but not the base world itself. Timed systems must suspend when nobody is online. The server never trusts coordinates supplied by the client. Once those rules were written down, the AI could help extend the game without quietly turning the architecture into soup.

It was also useful for the less glamorous work: generating tests, tracing multiplayer state bugs, checking security boundaries, finding edge cases in trading and inventory operations, and building admin and support tools. I still had to make the design decisions and reject ideas that didn’t fit. AI can produce an impressive amount of technically valid nonsense when given enough freedom.

The visual assets are not AI-generated; the game uses the CC0 Urizen one-bit tileset. The generative-AI part of the project is the development workflow: architecture discussions, implementation, debugging, testing, and repeatedly asking, “What terrible thing could a player do with this reducer?”

I’d be interested to hear how other developers keep AI-assisted projects coherent as they grow. Do you rely on architecture documents, automated tests, strict task boundaries, or simply stare at the code until it becomes afraid of you?

You can play Bitiverse here: https://fortisq.itch.io/bitiverse

Tiny pixels. Big world. Poor decisions.

>

Sharing a thing I built on top of OpenClaw. Fair warning up front: I made it to scratch my own itch, so I'm genuinely not sure how useful it is to anyone else — but here it is in case it helps.

How it started: I kept running the same code-review prompt through an agent multiple times to get decent results. At some point I figured: why not run more than one agent and compare? That worked better than expected, so I made it so each agent could have its own pre-prompt — basically a roster of "experts." Then per-agent models (cheap model for the simple roles, the heavy ones where it matters). Then I added a coder agent that actually applies the changes instead of just talking about them. And it kind of grew from there.

What it does now: You give it one task. A Producer agent plans it, dispatches specialist agents in parallel, then integrates all their replies into one answer. Every agent turn is just an openclaw agent subprocess — so OpenClaw owns auth, models, and the sandbox; this just drives the team.

Features that turned out to be the good parts:

• 🧠 Per-agent system prompts — build a roster of specialists (architect, security, perf, etc.), each with its own expert persona.
• 🎚️ Per-agent model + thinking level — spend tokens where they matter, go cheap where they don't.
• ⚡ Parallel dispatch — specialists run concurrently, then the Producer merges their findings.
• 🛠️ Coder agent (--use-coder) — takes the integrated audit and actually edits the files.
• 🔁 Re-audit loop (--loop N) — applies changes, re-audits, repeats, and stops early when it hits AUDIT CLEAN.
• 🗂️ Projects as "groups" — each project gets its own Producer + roster, so your CrimeOS team and your web-app team don't bleed into each other.
• 🖥️ Desktop GUI (Tauri/Windows) — scan a project and it'll propose a team for you; edit rosters, run tasks, browse run history. Same engine as the CLI.
• 🎯 Smart-dispatch — let the Producer pick who's relevant instead of fanning out to everyone.

CLI if you want it scriptable, GUI if you don't. MIT licensed.

Repo + Windows installer: https://github.com/fortisq/crime_team/releases/tag/v0.1.0

It's early (v0.1.0) and definitely rough in spots. Happy to hear what's missing or what I got wrong.