One year ago today I posted the first screenshot of EF-Map into the EVE Frontier Builder Showcase. 17 August 2025. The first commit in the repo is dated the 12th, so the thing was five days old, and what I posted was a 3D star field with a search box and three tick boxes next to it.
Normally an anniversary post is a pile of screenshots and a feature list. This one turned out better than that, because while I was digging out old images I found that two of the early Netlify deployments are still online and still work, and so is the tool I built before EF-Map existed. So you can open the first week of this project in a browser, today, and click about in it.
One thing to be clear about before the links, because I nearly got it wrong myself. Neither of those old deployments is the exact launch-day build. One is a branch build from the first week and the other is the last Netlify production build before I moved everything to Cloudflare. The only honest evidence of literal day one is the image I posted in Discord, which is the first screenshot below.
Before the map there was Scout Optimizer
EF-Map exists because of a scouting problem. I was trying to work out a sensible order to visit a cluster of stars and the in-game map is not built for that. With a handful of systems you can eyeball it. With a couple of hundred inside a 15 light year radius you cannot, and I could not find anybody offering that kind of optimisation, so I asked a couple of the existing EVE Frontier map and route sites whether they would add it. That went nowhere, which is fair enough, it is a niche thing to want.
So in late July 2025 I built Scout Optimizer. It had no map in it at all. You gave it a start system and a radius in light years, and it read the system coordinates and tried to find a short route through everything inside that radius. It builds a quick first route with a nearest neighbour pass and a 2-opt cleanup, then runs configurable simulated annealing across several browser workers, each of them trying to beat the current best. You set how many passes you want and how long each pass gets, and it just grinds away in the tab and reports each pass as it improves.
The post I put in Builder Showcase at the time carried a line I am still quite fond of. "Huge Disclaimer - I am not a builder, I knocked this up in gemini." That was accurate. I am a vibe coder, and Scout Optimizer was the project where I learned how to get an LLM to produce something that actually runs, how to work on it locally, how to put it on the internet with Netlify, roughly what route optimisation is, and eventually how to use Git and GitHub. None of that was knowledge I had a month earlier.
Its limitation is the interesting part. It knew where every system was and nothing else. It did not know about stargates, so it could not tell you that two of those stars were a single gate jump apart, and it could not show you anything at all. When somebody asked me in Discord whether it handled gates, the honest answer was that it did not, but that I was building something else which would. That something else was the map.
Day one
That is genuinely all of it. Literal tick boxes, no panels, no window chrome, no settings. Show Distance let you pick a system and then hover others to read the separation. The git history for that day is region and planet selection at 02:41, a loading screen and some icons at 08:42, and the distance feature merged at 16:51, so the screenshot is from some time after that afternoon.
What strikes me looking at it now is not how little there was. It is how much of the part that matters was already right. The 3D star field, the turntable camera, hover a star and get a label, all of that was working. I had already replaced the camera on 13 August, one day into the project, because the stock orbit controls did not give a proper turntable yaw, and the camera in that screenshot behaves like the camera does today. Everything I have added since sits around that view rather than replacing it.
Routing turned up the same evening
Five hours after the distance feature merged, at 19:14 on 17 August, I committed point-to-point routing. Not a stub either. That one commit has From and To fields, a max jump distance, a choice between optimising for fuel or for jump count, an A* search running in a web worker so the interface stayed responsive, the route drawn on the map with curved lines where a leg was a ship jump rather than a gate, autocomplete on the system inputs, and a Notes export that formats the route for pasting into the in-game notes, paginated to stay under the character limit. Route summary statistics landed eight minutes after that.
I have seen that timeline read as somebody building a 3D map and then casually inventing a pathfinder the same night. It was not that. Scout Optimizer had already made me spend a few weeks on route costs, distance metrics, browser workers and how to stop a long computation from locking up a tab. Routing was not the new part. The map was the new part, and routing walked in behind it more or less immediately.
Two days later I added a Dijkstra option alongside A* and put a spatial grid and a neighbour cache into the worker, because the naive version got slow as soon as you asked for a long route. On 20 August the Scout Optimizer machinery went into the map itself as a panel, this time running its annealing against real gate-aware distances rather than straight lines. The standalone tool stopped being developed around then, because everything it did now lived somewhere that could also draw it.
I could not date that build from Git, which I was not expecting. The branch was deleted long ago, and the bundle contains a couple of button labels that were never merged to main, so it is a snapshot of work in progress rather than any commit I still have a copy of. What I did instead was download the JavaScript bundle and grep it for strings. The simulated annealing and 2-opt code is in there, so it is after the 20th. The Reset button is not, and that shipped at 02:17 on 23 August, so it is before then. Cinematic Mode, route sharing, Hide UI and the interface scale slider are all missing too, which agrees. Call it somewhere around 20 to 22 August 2025.
Three weeks old, and already recognisable
On 7 September 2025 I moved the site off Netlify and onto Cloudflare Pages. It happened over one morning, between roughly half seven and half ten, and the commit that closes it out is called "Cutover: remove Netlify fallbacks". That is 21 days after the first Builder Showcase post. The last build Netlify ever made is still sitting at ef-map.netlify.app, and of the three checkpoints it is the one that surprised me most.
Twenty one days in, EF-Map had a feature rail, draggable panels with their own window controls, routing split into Point to Point, Scout Optimizer and Reachability, Cinematic Mode, region comparison, station display, a personal overlay, display settings, a hide-the-interface toggle, an interface scale slider, route sharing and a help panel. Reachability had landed on 2 September, Compare Regions on the 3rd, the intro transmission on the 4th. It had been through 72 numbered pull requests by then. Cinematic Mode, which people still use as a stream background, shipped on 24 August, one week after launch.
I think that is the genuinely interesting thing about the year, and it is not flattering in the way an anniversary post is supposed to be. The product model was basically settled inside three weeks. Understand the universe, plan movement through it, put your own information on top of it. Almost everything since has been those same three ideas getting deeper.
The shape stopped moving, the depth did not
A straight feature-list comparison makes the year look thinner than it was, because the headings barely moved. September 2025 had Routing. August 2026 has Routing. They are not remotely the same thing.
Take movement first. A year ago that meant A* or Dijkstra over gates and ship jumps, with a max range and a fuel-or-jumps switch. Today the same panel has a fourth tab called Yeet Planner which plans catapult infrastructure, chaining Mini Catapults at 65 LY and Heavy Catapults at 365 LY together with existing stargates, with required waypoints and systems to avoid. Player-built Smart Gate links can be folded into a route where you are authorised to use them. The solver has a Rust implementation compiled to WebAssembly sitting behind it. And the default max jump distance is now 0, which is the biggest change on that screen and has nothing to do with me. Routing starts from infrastructure, and a non-zero range is there to simulate a jump drive you might get back one day. The year-old build defaults to 60 and quietly assumes you have one. That assumption does not hold any more, which is a good example of why an old build is fun rather than useful.
Understanding the universe went the same way. Planet counts and a region highlight became a Solar System View with planets, moons, Lagrange points and orbital data, a System Finder where you can type something like "cold red stars with lots of moons" and have an AI turn it into visible filters you can then adjust by hand, an Item Codex, map layers, nebula types, and a starfield built from three point layers with a parallax backdrop instead of plain white dots. The scale of the EVE Frontier universe did not change at all, mind. The map database still draws 24,018 systems, the same ones, in the same places.
The third idea moved furthest. A local overlay of your own marks turned into tribe bookmarks encrypted at rest, public scout reports, a killboard, an activity tracker, a gate activity panel, live on-chain events, a shoutbox, and for subscribers a Query Console where you ask the chain indexer a question in plain English and get a table or a chart back, plus a Panel Creator for assembling your own dashboard windows out of those queries. None of that existed as an idea in September 2025. All of it is still the same third thing, which is putting information onto space.
Then there is the part nobody sees, which is most of it. A Cloudflare Worker with KV, R2 and a durable object. A VPS running indexers and cron jobs. A data pipeline that pulls the map out of the EVE Frontier game client after every patch. Seven interface languages. A test suite that is 348 files and 7,294 tests as of this morning, against zero tests for the whole of August 2025.
What did not change
The map still owns the screen. If all you want to do is find a system and plot a route from A to B, that workflow is broadly where it was a year ago, in roughly the same place, and the extra depth sits behind a tab or a panel you never have to open. I would love to claim that was discipline. It is closer to the first arrangement happening to be reasonable, and me being too nervous to move things people had already learned.
The most recent stretch of work was specifically about that, though. Over July and August this year I went through the whole shell and made twelve months of individually sensible decisions agree with each other. Shared control heights, one continuous instrument dock instead of a stack of boxed cards, panels that open from the same origin, and a real visual difference between a window that is closed, one that is open behind another, one that is minimised and the one you are actually working in. I wrote that up in Polishing EF-Map. The constraint there was the same as the constraint in this post, which is that it had to still be EF-Map when I finished.
Go and click them
The early branch build from the first week is at feat-p2p-routing--ef-map.netlify.app. The final Netlify production build from the Cloudflare cutover is at ef-map.netlify.app. Scout Optimizer, the thing that started it, is at scout-optimizer.netlify.app. And today's version is at ef-map.com. I would open the first-week one and today's one side by side, because that comparison is the whole post.
Fair warning on the old two. They are static files now, so anything that ever talked to a server is gone, and route sharing will not work. They also carry their own frozen copy of the map database. It holds the same 24,018 systems at the same coordinates, which is why routes in them still look sensible, but roughly 11,400 of the names have drifted since. About 7,370 of those are my own doing, from a later fix where I started taking system names from the game client's authoritative field instead of the one I had been reading. So treat an old build as a museum piece rather than a route planner, and use the current one if you need an answer.
One year, and 3,646 commits since that first Builder Showcase post. The bit I keep coming back to is that all of this started because I could not work out what order to visit a couple of hundred stars in. I solved that in about a fortnight and then apparently could not stop. If something in the current version is broken, tell me and I will have a look. The old ones I am leaving exactly as they are.
Related Posts
A year of EF-Map, read back from its own decision log covers the same twelve months through the commits and the decision log, including several places where the record contradicts itself.
Polishing EF-Map: turning 12 months of UI into one system is the interface pass that closes out this first year, and explains why the shell was systematised rather than redesigned.
Half a million light years of EF-Map usage data is what people actually did with the routing over that time, from the anonymous counters rather than the code.
A vibe coder stumbles into software engineering covers how the working method changed between the tick boxes and today.