0.1-alpha
North Qeynos from above

FQ

A fan-made recreation of 1999 EverQuest, written from scratch in plain C.

Login, world and zone servers, a low-poly OpenGL client under heavy fog, and a world you can walk on foot from Qeynos to Freeport. Built by AI coding agents, one zone at a time.

Browse the screenshots Open the zone atlas

Fan project. Not affiliated with or endorsed by Daybreak Game Company. Details

Scrub through the build

Each bar counts the screenshots taken in that stretch of time. Drag, or use the arrow keys, to step through the highlights.

    Releases

    Each version is a snapshot of the world. What is built is in view; what comes next is still in the fog, the way the far hills were in 1999.

      Rebuilt from nothing

      Three kinds of server run the world, as they did in 1999: a login server, a world server and zone servers, talking over their own reliable UDP. A Windows client draws it all in low-poly OpenGL, with day and night under heavy fog; a game day lasts 72 minutes.

      Nothing is borrowed. There is no engine and no library beyond the C standard library and the operating system, and no file from the original game. Every zone, creature, spell and line of dialogue is written new: inspired by the classic, never copied.

      Today you can walk from North Qeynos to West Freeport, clear Blackburrow and Befallen, and ride a ship across the Ocean of Tears. The other classic zones, from Halas to the Plane of Sky, are being built now, and so is sound.

      How it is built

      FQ is written by AI coding agents (Claude Code), with one person deciding what to build and playing the result. The agents cannot talk to each other while they work, so everything they share is written down: contracts to build against, a script for each feature, and tests that decide when a piece is done.

      It began as a three-line request: work out what a game like this needs, then build it, with enough zones to make the run from Qeynos to Freeport. The first commit, on 25 September 2026, could not run a game: it held the plan, the contracts, a shared base library and stubs that compile. The servers, the client, the bot and the first eleven zones landed on top of it less than four hours later.

      Every big feature since has been one workflow: a script, written and started by the main session (the one agent the owner talks to), that runs agents in phases, up to 21 of them at the same time. So far 16 workflows have run 388 agents, and between them they have made 40,742 tool calls, mostly shell commands, file reads and edits.

      1. Contracts first

        Agents working in parallel cannot ask each other anything, so the rules come first. Before there was a server, a client or a tool, there was a network protocol that fixes every message down to the byte, a zone file format, a game data format, an architecture document and 28 C headers with stubs that compile. An ownership map gives each agent its own files and no one else's. If a contract lacks something, the agent works around it inside its own files and says so in its report. Only the main session changes a contract.

        Three critics read the contracts before anyone built on them: one as a client developer, one as a server developer, one as a content author. They found 69 problems, 2 of them blockers, and those were fixed first. The big features since then (boats, sound, the rest of Classic) open the same way, with their contracts locked and the whole tree building before any builder starts.

        One piece of code is shared outright. The client and the zone server run the same movement and collision code, and check on connect that they loaded the same game data, so the step the client predicts is the step the server checks.

        The contracts and the parts built against themIn the middle, three sealed scrolls: the network protocol (1,713 lines), the zone file format (1,202 lines) and the game data format (656 lines), written before the code, with the plan, the architecture, the ownership map and the C headers. Around them, each part of the game and the contracts it is built against: the client and the zone servers use the protocol, the zone format and the data format; the world server the protocol and the zone format; the login server the protocol; game data the data format; zone files the zone format; zonecheck the zone and data formats; the bot the protocol and the zone format. The client and the zone servers also share the same movement and collision code. written before the code locked while the agents build Zoneformat 1,202 lines Dataformat 656 lines Protocol 1,713 lines FQ with the plan, the architecture, the ownership map, C headers Client protocol · zones · data Zone servers protocol · zones · data World server protocol · zones Login server protocol Game data data format Zone files zone format Zonecheck zones · data Bot protocol · zones the same movement and collision code The contracts and the parts built against themIn the middle, three sealed scrolls: the network protocol (1,713 lines), the zone file format (1,202 lines) and the game data format (656 lines), written before the code, with the plan, the architecture, the ownership map and the C headers. Around them, each part of the game and the contracts it is built against: the client and the zone servers use the protocol, the zone format and the data format; the world server the protocol and the zone format; the login server the protocol; game data the data format; zone files the zone format; zonecheck the zone and data formats; the bot the protocol and the zone format. The client and the zone servers also share the same movement and collision code. written before the code, locked while the agents build Zoneformat 1,202 lines Dataformat 656 lines Protocol 1,713 lines FQ with the plan, the architecture, the ownership map, C headers Client protocol · zones · data Zone servers protocol · zones · data Bot protocol · zones World server protocol · zones Zonecheck zones · data Login server protocol Zone files zone format Game data data format the same movement and collision code
        The contracts in the middle, the parts of the game around them, each marked with what it is built against. Line counts are today's.

      2. One feature, one workflow

        The phases hardly change from feature to feature. Contracts are locked first. Builders then work in parallel, each on the files it owns. QA agents walk every new zone, take screenshots and look at them. An integrator runs every test. Then reviewers attack the result, each through one lens, and report only defects they have confirmed with a failure scenario. A fixer repairs them, adds a regression test for each and runs everything again.

        Hard problems get competing designs first. For boats, three agents each designed a ship system and three judges scored them: a sceptical distributed-systems engineer, a veteran of the 1999 game and a lead who knows this codebase. The winner was a timetable that every server and client computes the same way, so ships never have to be sent over the network. The judges' objections were fixed, and good ideas were taken from the other two designs.

        The boats workflow, stop by stopA road with ten stops, each figure one agent: research (1), three competing designs (3, the winning deterministic design drawn in red), three judges (3), contracts locked by an architect (1), build (14 agents in four groups of 4, 5, 3 and 2), QA of the new zones (5), integration (1), adversarial review with four lenses (4) and a fixer (1), then the merge into master. 33 agents in all. 1Research1 agentroutes, stops,timings2Designs3 agentsthree ideas,one each3Judges3 agentsscore allthree4Contracts1 architectlocked; thetree builds5Build14 agentsfour groups, eachowning its files6QA5 agentswalk, screenshot,look, fix7Integrate1 agentevery test,voyages, journey8Review4 agentsone lens each,try to break it9Fix1 agent16 findings,each tested10Mergeinto masterclean rebuild,then merge The boats workflow, stop by stopA road with ten stops, each figure one agent: research (1), three competing designs (3, the winning deterministic design drawn in red), three judges (3), contracts locked by an architect (1), build (14 agents in four groups of 4, 5, 3 and 2), QA of the new zones (5), integration (1), adversarial review with four lenses (4) and a fixer (1), then the merge into master. 33 agents in all. 1 Research 1 agent routes, stops, timings 2 Designs 3 agents three ideas, one each 3 Judges 3 agents score all three 4 Contracts 1 architect locked; the tree builds 5 Build 14 agents four groups, each owning its files 6 QA 5 agents walk, screenshot, look, fix 7 Integrate 1 agent every test, voyages, journey 8 Review 4 agents one lens each, try to break it 9 Fix 1 agent 16 findings, each tested Merge into master clean rebuild, then merge
        The boats workflow on 26 September: 33 agents from research to master. Each figure is one agent; the winning design is drawn in red.
        1. Research. The classic routes, stops and timings, and the swimming rules.
        2. Three designs. Deterministic, server-authoritative and free-form: one agent each, none seeing the others.
        3. Three judges. Each scores all three for robustness, fidelity, risk to the codebase and testability.
        4. Contracts. An architect merges the winner with the best other ideas and locks the docs, headers and protocol version 2. The tree builds with warnings as errors.
        5. Build. 14 agents in four groups: game core, content, services, and the client with the bot.
        6. QA. One agent per new sea or landing zone and one for the harbours: zonecheck, then screenshots they look at and fix.
        7. Integrate. The new zones join the cluster; every suite, the voyage tests and the journey run.
        8. Review. Four adversarial reviewers: riding and crossings, protocol and security, swimming, the client.
        9. Fix. All 16 findings fixed, each with a regression test, and everything run again.
        10. Merge. The main session rebuilds from clean, runs it all once more, commits and merges.

      3. A road for each feature

        Each feature is built on its own git branch, in a separate working copy, so the main copy stays playable: the owner plays from it while the agents work. Builders never commit. When a workflow ends, the main session rebuilds from clean with warnings as errors, runs every test suite and zonecheck, and only then commits and merges.

        Three roads have rejoined master so far: dungeons and boats on 26 September, and sound on 27 September. One is still out: the rest of the classic zones.

        Feature branches as roads leaving and rejoining masterA time line from the first commit on 25 September 2026 to 27 September. The main road, master, carries the foundation and the first full build. The dungeons road leaves it on 26 September and comes back five hours later (31 agents, 7 zones). The boats road leaves right after and comes back that evening (33 agents, 4 zones). Two roads leave that night: sound comes back on 27 September (38 agents), and the rest of the classic zones is still out in the fog (51 zones, 214 agents so far). Each small gem is a commit, each large one a merge. 25 Sep 26 Sep 27 Sep masterFoundationthe plan and the contractsFirst full buildservers, client, bot, 11 zonesDungeons31 agents · 7 zonesBoats, oceans and swimming33 agents · 4 zonesplans for sound, the zone roadmapSound38 agents · mergedThe rest of Classicbeing built · 51 zones · 214 agents so far Feature branches as roads leaving and rejoining masterA time line from the first commit on 25 September 2026 to 27 September. The main road, master, carries the foundation and the first full build. The dungeons road leaves it on 26 September and comes back five hours later (31 agents, 7 zones). The boats road leaves right after and comes back that evening (33 agents, 4 zones). Two roads leave that night: sound comes back on 27 September (38 agents), and the rest of the classic zones is still out in the fog (51 zones, 214 agents so far). Each small gem is a commit, each large one a merge. 25 Sep 26 Sep 27 Sep masterFoundationthe plan and the contractsFirst full buildservers, client, bot, 11 zonesDungeons31 agents · 7 zonesBoats, oceansand swimming33 agents · 4 zonesSoundmerged38 agentsThe restof Classic51 zones214 agents
        Git branches as roads, from the first commit to 27 September. Small gems are commits, large ones are merges. Agent counts include each feature's design or planning workflow.

      4. Tests decide

        No feature merges on an agent's word. It merges when these pass.

        • 878 Unit tests in 23 suites, built with warnings as errors.
        • 22 Zones checked by zonecheck: routes you can walk, zone lines that arrive somewhere, spawns that exist.
        • 13.8 km The journey A bot runs North Qeynos to West Freeport on the zones' own roads: 11 zones in 461 s at five times run speed, and 0 position corrections from the server.
        • 5 Voyage tests Both ship lines both ways, a zone server killed mid-crossing, skewed clocks, 5% packet loss. The full run takes about 76 minutes.

        The ship tests earned their keep. The first full voyage run failed at the South Qeynos gangway, the fix for that broke jumping overboard, and it took more rounds before a run came back clean.

        Sound is checked the same way. Its workflow script puts it plainly: “We cannot listen.” So the agents render test mixes to files and measure them instead: peak level and loudness, clipping, clicks at loops and crossfades, silent gaps. The sound build was validated that way before it joined master on 27 September.

      5. Every screenshot is kept

        QA agents take screenshots and then open them to look; they have done that 8,774 times. Every capture is archived. The archive holds 10,975 so far, and it is what this site is made of: 3,967 are published here. Newer captures join at the next data build, and any that show a local file path are left out.

        This site was built the same way. Three design agents each made a working prototype from real screenshots. The owner liked A best, preferred B's terrain map, and wanted C's build timeline, screenshot archive, zone list and releases, so those parts were rebuilt in A's stone and parchment.

        1. A Norrath 1999stone, bronze and gold leaf

        2. B Night fog, lantern lighta low-poly terrain map

        3. C Draw distancea build log you can scrub

        The site you are readingA's look, B's map redrawn in ink, C's timeline, archive, zone list and releases

      6. What people still do

        One person decides what gets built, and plays it. Ships with dock callers who tell you when the next boat is due, different music for day and night, and home cities that look like different cultures were all the owner's requests. A ship the owner saw frozen at a zone edge while playing is now a top-priority item on the to-do list.

        The agents work to a usage allowance. When it ran out partway through, the sound and classic-zone builds stopped mid-phase; their work was checkpointed, and finish workflows picked it up. Plenty is still open, and the to-do list in the repository says so.

        From the to-do list

        • Ships look frozen while they wait at a zone line.
        • Jumping down steep slopes can rubber-band: about 450 moves in 50,000 in North Qeynos.
        • The Linux build has never been compiled.
        • One network test failed once under a fully parallel run, and nobody knows why yet.
        • Passwords cross the network in clear text. Fine for a development server, not for a public one.

      Zone atlas

      All the classic zones and how they join. Lit zones are open to play today; the rest are being built. Pick a zone to see where it leads and what it looks like.

      Map of the classic zones Use the arrow keys to move between zones and Enter to open one. Every zone is also listed in the table below the map.

      Drag the map sideways to see all of it, or use the list below.

      All zones

      Progress

      The same place, the same camera, build after build. Pick a viewpoint and drag across the picture to compare.

      Viewpoints

        The list is one stop for the Tab key: the up and down arrows move through it, Enter compares.

        See every tracked viewpoint

        Open the lossless PNG