Free Arena

Build it like it's 1999, but much faster

An arena shooter in the spirit of Quake 3, written in Rust with Bevy. CPMA movement, seven weapons, two duel maps, bots and netcode. Every model, texture, sound and map is code or text, and all of it lives in Git.

I work in IT operations and had never built a video game before. It started as a weekend experiment with AI doing the typing. How that went is further down.

Now

Where it is now

Two maps, seven weapons on six models, ammo, health pickups, a HUD that tells you something, and an engine that's current again. Still everything in text and code, still all in Git.

All six weapon models side by side: FORGE, RIVET, SPINE, SURGE RIFLE, LANCE and FUSE
Left to right: FORGE, RIVET, SPINE, SURGE RIFLE, LANCE, FUSE.

Arsenal

Seven weapons, six models

You spawn with RIVET; everything else comes from pickups. Each weapon has its own limit: ammo, heat, or a recovery that grows with every shot. Like everything else, the models are built in Rust from primitives.

Maps

Two duel maps

Both maps are written by Python scripts and dressed by the game from what the map file says about each area. Both are selectable from the menu, and the server tells clients which one to load.

Origin story

One weekend, then a month later

What can be done in a weekend, starting from zero, to build a modern multiplayer arena shooter with Rust, Bevy, and “Super Intelligence” (🌚) that is playable and has a vibe of its own?

Quite a lot, I'd say. I work in IT operations and had never built a video game before, so someone who has will likely get much sleeker results. This is the log of that weekend, and of picking it up again a month later.

A Weekend Experiment

A 1999 Quake III Arena print advertisement arranged around a CRT gaming setup
Quake III Arena, 1999. The reference point.

Back in 1999 I would never have imagined building something that could pass as a homage to Quake III Arena. Especially not in a language I wasn't familiar with, on an engine I hadn't heard of until that Friday, with a netcode library that by pure chance worked with it.

I had some tokens left over that weekend, so I wanted to see what was possible. A pure Q3 clone could probably be one-shotted in a day with some prompting. My goal was different: a Q3-inspired “boomer” shooter built from scratch, not a carbon copy of anything, with some of the ideas I'd always had while playing the shooters I loved. CPMA movement was a must, so that was one of the first decisions. And it wasn't supposed to be a case of “AI came up with everything”.

Who Does What

ChatGPT drove Claude. ChatGPT wrote a plan with milestones for each part of the game: engine research, netcode, weapons, firing styles, projectiles, sounds, and performance (tl;dr: “don't make the next Crysis”; 60 FPS on a two- or three-year-old laptop iGPU at medium detail, without bloom). Claude implemented them.

Smaller level and gameplay improvements went to Qwen3.6 35B running locally, with ChatGPT as its advisor.

Text as Source

The rough outline: use an existing engine, find netcode that works with it so I wouldn't have to bake my own, and describe models, sounds and textures in text files with metadata for each weapon. Everything gets generated from scratch but stays somewhat reproducible, because the descriptions and the resulting code live in Git.

Two Hours In

About two hours in, I had the first primitive map, cheap textures, and placeholder weapons “inspired” by the procedural descriptions. CPMA movement worked right from the get-go.

Measuring Quake

Map structure and distances, basically how long it takes to get from x to y, were hard to work out by playing on my own. It would have taken hundreds of attempts to find out what works. So while tokens were being sunk into the next milestone, I ran a small experiment on the side.

Movement traces parsed from an old competitive Quake 3 demo
Player movement traces parsed from a competitive Quake 3 demo.

I found some old Quake 3 demo recordings from QuakeCons and looked for parsers that could turn them into heatmaps. A demo is a recording of the client/server traffic during a match, which the game can play back. Back then bandwidth was an issue, and streaming decent video to thousands of people over the Internet wasn't really possible, so matches were shared as demos.

A parsed demo gives you every player's position over time. From that I extracted how long two pro players took to get between specific positions, where they spent their time and how fast they moved, and stored it all in JSON files. That gave me reproducible targets instead of visual estimates. I'll also be able to derive item placement from it if I need to.

Using the Numbers

During the weekend I mapped those timings to the engine's physics values. duel1, the first map, was already built by then and isn't based on the data.

duel2 is. It was laid out around the travel times from the demos: for a skilled player, 1.5–3 seconds between neighbouring fights, 5–7 seconds across the map, and 12–18 seconds for a useful loop. A map scaled like that also makes CPMA movement much more useful, because you can reach decent speeds without crashing into something all the time.

Part 1

The weekend

End of the weekend

Where it landed

I played quite a few rounds myself and enjoyed it. It felt more Quake-like with every pass, although there were still plenty of kinks to iron out: weapon balance, spawn points, ammo, pickups, and how all of that affected the map. What I wanted next was to get it in front of another human.

Full match recording · 10:09 A complete duel against the bot. Final score: 19–18.

Part 2

A month later

Then it sat for about a month. I was waiting for lightyear, the netcode library, to support Bevy 0.20, so I could move the engine to the latest major release. Once it did, I went back to the list from the end of the weekend: weapon balance, ammo, pickups, and how all of that affects the map. Two days later, this is where it went.