Technical guides, feature updates, and optimization stories from the EVE Frontier mapping project.
Adding Xbox controller support to EF-Map: controller-native map navigation, an EVE Frontier style flight mode with automatic banking, and recorded camera flights you can replay or hand to the Director.
EVE Frontier explained by a player with 18 months of founder access: single-shard survival, cycles and wipes, what it costs, and what state the alpha is really in.
An honest EVE Frontier review from 18 months inside the alpha: the best kill of my year, the worst tutorial, real population numbers, and who should buy founder access.
EVE Online vs EVE Frontier compared by a player of both: combat occlusion, fuel-cost travel, player-built markets, skills by doing, and which game suits you.
What the Sui blockchain actually does in EVE Frontier, from a player and tool builder: the chain as a public game database, the Ethereum move, and what players touch.
The EVE token explained in plain English: how Lux converts to EVE, why the money flows both ways at launch, and what a normal EVE Frontier player actually touches.
The Panel Creator lets EVE Frontier players build custom intelligence dashboards over live chain data. Describe one in plain English, or build it by hand.
One Claude Fable 5 orchestrator and 38 Claude Opus 5 subagents built a major EVE Frontier tool overnight. The raw numbers, the cost, and the method.
I pointed seven agents at a year of EF-Map's decision log, git history and usage data. What the record says about EVE Frontier tooling, and where it is wrong.
Six months of new EF-Map features had no translation keys at all. How 1,750 strings reached five languages overnight, and the prompt that missed the point.
A Discord argument about faster-than-light travel sent me to Müller and Weiskopf's 2011 paper on geodesics in the Alcubierre warp spacetime, and then into EF-Map's fly-through mode to apply it to 24,000 stars. Here is the approximation, the compromises, and why the visual range stops at 9c.
What one Saturday of LLM-assisted development across EF-Map, CivilizationControl and RootFit actually looked like: 66 commits, seven production deploys on one app alone, prompts dictated by voice while playing EVE Frontier, and the year of scaffolding that made it possible.
Open Market puts an EVE Online style order book on an EVE Frontier Smart Storage Unit: browse every live market, buy remotely from the browser or in game, and collect at the storage. As of this week you no longer need CivilizationControl to see them.
System Finder on EF-Map now takes plain-English requests: describe the EVE Frontier systems you want and an AI selects the filters for you. Free, unannounced, and built in an afternoon.
Star glow was quietly EF-Map's most expensive effect. Why additive point sprites melt GPUs on fill rate and why bloom now carries the 24,000-star Three.js starfield.
EF-Map Intelligence subscribers can now query the chain indexer live: preset questions, a query builder, and a plain-English assistant that builds the query for you.
EF-Map has counted anonymous usage since August 2025. Eleven months later the numbers tell the story of a game changing underneath the site: route planning fading, yeeting taking over, and half a million light-years saved.
Performance Mode stopped matching EF-Map's UI after the Ember work. The depth fade and a themed backdrop cost nothing. Bloom was the expensive one.
A Sui testnet outage took down EF-Map's gas sponsor, Intelligence purchases and treasury dashboard at once. I read it as a deprecation and built a proxy anyway.
How a blunt 6 out of 10 critique turned EF-Map's accumulated controls into a coherent instrument dock and product shell without redesigning the map.
I dictate everything I give an AI agent. Eleven months and 14,625 recordings later, here is what the archive shows about how working with AI agents actually changed.
EF-Map now has an optional paid Intelligence layer on EVE Frontier's testnet. What it is, what stays free, why we are testing payments now, and why 100 testnet EVE is not mainnet pricing.
Filling EVE Frontier's Cinematic Mode with interstellar gas between the stars, fixing a long-standing bloom flicker, and making supernovae light the gas.
Gate jumps we indexed but ignored became an intelligence panel in two hours: who owns EVE Frontier's gates and catapults, and who jumps through whose network.
Players kept asking what EVE Frontier's sensor modules do. The scan data was in RootFit all along — now it's a Scanning stat panel plus a full explainer of strength, resolution and stacking.
A hand-made progress chart in Discord showed what tribes needed: bookmarks now carry catapult and gate links with build statuses, turning a Yeet Planner route into a shared construction tracker.
EVE Vault is a desktop extension, so every wallet-gated tool in the ecosystem is desktop-only. EF-Map now borrows the WhatsApp Web trick: scan a QR on desktop and your phone browser is signed in as you for seven days. No wallet on the phone, no app, works in plain Safari.
An agent-readiness test scored us 29 for the wrong reasons, but one finding mattered: WebMCP. The operator spotted that our Ctrl+K command palette was secretly the hard 80 percent, and seven in-page agent tools shipped the same afternoon.
Two friends should not need a market interface to pool their ore. Shared Storage turns any storage unit into an open container that looks exactly like the game's own screen.
A power user asked for a keyboard-only command line on EF-Map's EVE Frontier map. It shipped in hours — built on AI command plumbing almost nobody uses.
EF-Map's oldest feature, rebuilt: Cinematic Mode drops its faked effects for a lush take on the new HDR EVE Frontier starfield, plus a directed auto-tour.
EF-Map is now in closed testing on the Google Play Store. How an eight-month-old layout decision made the app easy, why the Play Console paperwork wasn't, the honest story on pricing — and how to join the test.
Default fonts, stock icons, rounded corners everywhere — EF-Map looked like every LLM-built app. How Claude Fable 5 designed a bespoke identity, made Ember the default, and rethemed 105 pages in an afternoon.
How Claude Fable 5 rebuilt EF-Map's star rendering: HDR bloom ranked by real stellar temperature, an accent-themed nebula, and a backdrop that draws far less GPU.
How we split EF-Map's 19,846-line App.tsx to 9,776 lines by giving Claude Fable 5 free rein — and why the app isn't faster, but every future change is.
How EF-Map built Yeet Planner, an EVE Frontier Catapult infrastructure planner, from announced patch rules, then polished it through player feedback.
Explorer Cards turns EF-Map's extended hover label into a map layer for EVE Frontier, showing system info cards for a whole constellation at once.
How a weekend spike became RootFit, a browser ship-fitting planner for EVE Frontier, and how shipping early let players shape Trace Fit and Try Add Modules.
EF-Map now preserves a Cycle 5 archive for EVE Frontier, freezing map data, killboard, structures, smart gates and activity snapshots for future reference.
EXTI is hosting a community 3v3 EVE Frontier PvP event in ESP-J64 on June 20, 2026, with Reavers provided and teams formed on the day.
EF-Map's Killboard now has mobile Simple and Expanded modes, ship and structure breakdowns, CSV export, and shareable Snapshot cards for EVE Frontier.
How EF-Map uses Performance Mode, an FPS cap, idle throttling, and a Three.js and WebGL benchmark to keep the EVE Frontier star map usable on more hardware.
How EF-Map's EVE Frontier map finally got a clearer near, mid and far parallax backdrop without adding confusing background stars.
How EF-Map made its EVE Frontier map usable on phones by reusing the existing desktop panels inside a mobile host instead of maintaining two apps.
How EF-Map turns system, player, tribe, route and report intelligence into shareable PNG cards with QR links back to the live map.
How EF-Map uses ChatGPT, Claude Code Cowork and VS Code agents to turn audits, plans and domain review into safe feature batches.
How EF-Map reuses killboard, activity, structure and Smart Gate data to generate a weekly EVE Frontier field report.
A plain-English look at EF-Map's extended solar system database, from stars and planets to L-points, frost lines and underused fields.
How EF-Map used Claude Cowork, Claude in Chrome, and Claude Code as a browser-and-repo-aware UX audit loop for practical product polish.
A grounded look at how EF-Map's extended solar system database may hint at EVE Frontier's System Resource Potential UI.
How EF-Map's System Finder and System Name Visualizer help EVE Frontier players filter systems and explore generated name patterns without changing map data.
EF-Map's Intelligence panel uses indexed Sui-era signals to help EVE Frontier players inspect player, tribe, system, and structure context.
EF-Map separates public Scout Reports, local personal marks, and current-tribe bookmarks for clearer EVE Frontier map collaboration.
How we overhauled EF-Map's outdated Help system in under 30 minutes of operator time using LLM sub-agents - fixing 20+ outdated entries, adding search, and cleaning up the UI.
How we built a DIY HLS video streaming pipeline on Cloudflare R2 to deliver preservation-grade EVE Frontier cinematics—because YouTube compression destroys dark gradients.
How we enhanced EF-Map's discoverability for EVE Frontier players through dedicated landing pages, Google Analytics 4 instrumentation, Search Console integration, and AI Engine Optimization.
Yes, there is a map for EVE Frontier. EF-Map is a free interactive 3D star map with Smart Gate routing, region analysis, and collaborative tribe marks—no account required.
EF-Map includes a free blueprint calculator for EVE Frontier that calculates material requirements, supports batch quantities, and shows complete material trees in your browser.
Yes, EF Helper is a free Windows desktop companion for EVE Frontier available on the Microsoft Store. Get real-time location sync, in-game overlay, and mining telemetry.
Turn your EVE Frontier game logs into actionable insights—locally. Introducing the Log Parser: a privacy-first analytics dashboard that never sends your data anywhere.
How we evolved from mobile-only fixes to automatic GPU detection and Performance Mode—ensuring smooth map rendering for integrated graphics users on any device.
How we diagnosed a user's 11.5 FPS performance issue on an AMD RX 7600S, discovered the root cause through collaborative debugging, and implemented safeguards to prevent future occurrences.
A complete breakdown of how EF-Map works—what runs client-side, what data we access, what requires login, and why we built a privacy-first EVE Frontier mapping tool.
How we discovered and fixed a non-deterministic bug in FOAM attribution that caused kill statistics to fluctuate between runs—a deep dive into SQL behavior and greedy algorithms.
How we tried nebula textures, fought UV seams and pole pinching, built user-adjustable sliders, then discovered procedural noise with those same controls delivered the best results.
How we're preparing EF-Map's blockchain indexer for EVE Frontier's migration from Ethereum L2 to SUI—researching Move contracts, comparing indexing approaches, and building a migration timeline.
How a community performance report led to discovering Chrome Task Manager quirks, implementing idle render throttling, and ultimately separating event capture from visual display—cutting CPU usage by 85% while preserving all history features.
How we built a complete Module Mission feature—tracking all 114 Assembler modules with checkboxes, materials totals, and persistence—in under an hour using existing patterns, data pipelines, and LLM-assisted development.
How we added five layers of depth effects—glow, flare, parallax, brightness, and desaturation—to make 24,000+ stars feel like a living universe. Iterative development with LLM collaboration and subtle-by-design philosophy.
A comprehensive chronicle of EF-Map's development from August 12 to December 27, 2025—1,116 commits, 55,000 lines of code, and a complete EVE Frontier mapping ecosystem built by vibe coding with LLMs.
How we unified Smart Assemblies, Smart Gates, and SSU Finder into one tabbed panel, standardized UI styling across windows, and surfaced the Blueprint Calculator for better discoverability.
How we tracked down a 'network error' that halved our connected users—from POST to /null bugs to Cloudflare Durable Objects auto-response for zero-cost WebSocket keepalives.
A weekend of UI polish for EVE Frontier Map: fixing window scaling and positioning, adding vertical resizing to the feature bar, implementing scrollable tools section, and introducing the Beta/Storage panel for power users.
The complete story of migrating EVE Frontier Map's backend infrastructure from a Windows workstation to a Hetzner VPS—why Docker made it trivial, the cost breakdown, and lessons learned.
How we built a comprehensive killboard for EVE Frontier Map using blockchain-indexed kill mail data, Docker cron jobs, and Cloudflare KV snapshots—from schema discovery to production deployment.
How we transformed EVE Frontier's live event ticker from a pretty-but-useless feature into a powerful intelligence tool with IndexedDB persistence, multi-speed replay, and 24-hour event history.
How we built real-time event streaming for EVE Frontier using Cloudflare Durable Objects and WebSockets—watch smart gate links, tribe actions, and fuel deliveries happen live.
How we added S/M/L size filtering to EVE Frontier's Smart Assemblies panel—modifying a Docker container, blockchain indexer, Cloudflare KV snapshots, and React frontend—all in under an hour.
How we added natural language command parsing to EVE Frontier Map using Cloudflare Workers AI—from model selection to compound command support, all at 16x lower cost.
How we built a 9-step guided tour using Driver.js to teach new users EF-Map's routing workflow, complete with a themed exit modal and progress persistence.
Watch Dijkstra explore the star map in real-time. We built a visualization mode that renders visited nodes as the algorithm searches, with 5-second fade-out trails.
We built an interactive configurator to help streamers, tool makers, and community sites embed EF-Map with customized styling, coordinates, and feature toggles.
Why we kept App.tsx at 9,000 lines and extracted 15+ custom hooks instead of forcing an artificial split. A case study in pragmatic React architecture.
How we optimized EVE Frontier pathfinding with bidirectional Dijkstra search and fixed a critical bug where one-way Smart Gates were traversed in reverse.
Creating a soap-bubble effect for EVE Frontier's jump range indicator using GLSL thin-film interference physics—wavelength-to-RGB conversion, flow noise, and spiral animations.
A transparent look at how we handled a leaked Cloudflared tunnel token for EVE Frontier infrastructure—rotation, history scrubbing, and updated guardrails.
How we tunneled the Assembly API through Cloudflared to stream EVE Frontier smart deployables from a local Postgres indexer directly into Solar System view.
How we reduced loading times by 99.9% through SVG conversion, IndexedDB caching, and intelligent loading screen design—cutting bandwidth costs from £12-22/month to £1-2/month while improving user experience.
The complete story of building a 3D planetary explorer for EVE Frontier Map in three days—from initial coordinate bugs to production deployment, featuring dynamic icon grouping, starfield backgrounds, and smooth camera transitions.
How we built a PowerShell diagnostic tool to troubleshoot EVE Frontier overlay injection failures remotely—reducing support time from hours to minutes.
The real .vscode/mcp.json and context7.json I ran on EF-Map, what the API key is actually for, what the rules array does, and why I removed Context7 in June 2026.
How EF-Map extracts its two EVE Frontier databases from the game client, why stage one was rewritten in-house, and how a stale input file nearly rebuilt last cycle's universe.
Designing intuitive jump distance calculators for EVE Frontier—a case study in iterative UX refinement, user feedback, and the surprising complexity of mass input fields.
How a non-coder built EF-Map in 3 months—a production tool with 124k+ lines including C++ DirectX overlay—using LLMs, structured documentation, and iterative vibe coding. The complete methodology.
How we integrated blockchain-powered Smart Gates into EF-Map through six phases—from overlay polish to SIWE authentication, authorized filtering, and opt-in routing—without breaking production.
How we expanded Smart Assembly tracking to include 19 new deployable types—portable printers, decorative totems, tribal structures—while improving tribe-based filtering and star coloring.
How comprehensive requirements documentation and methodical execution transformed ambitious goals into a production-ready interactive map tool for EVE Frontier.
The Scout Optimizer now supports min-max range filtering, letting scouts exclude already-visited nearby systems and focus their search on unexplored outer regions—saving time and fuel.
How we reduced monthly KV operations from 1.6 million to 108,000 through intelligent caching, adaptive polling, and serverless architecture—without compromising user experience.
Introducing Cinematic Mode—a fullscreen, distraction-free way to explore EVE Frontier's star map with smooth camera controls and atmospheric visuals.
The three ways EF-Map remembers where you have flown: helper all-time and session tracking, the Log Parser travel replay, and a manual region checklist.
How we built a multi-waypoint route optimizer using genetic algorithms and spatial indexing to find efficient paths through hundreds of star systems in seconds.
Creating a serverless, privacy-focused route sharing system using Cloudflare Workers and KV—compress complex routes into short URLs that work anywhere.
A* only beats Dijkstra if you can build an admissible heuristic. Free stargate edges in EF-Map's 24,026-system star map break that, so in fuel mode the heuristic is hard-coded to zero.
How we built a three-tier caching system to visualize on-chain access control lists for Smart Gates—transforming slow blockchain queries into instant map interactions.
Bridging the browser sandbox: how we built a Windows service that connects the web app to the game client via localhost HTTP, custom protocols, and DirectX injection.
How EF-Map draws EVE Frontier's 24,026 solar systems in a browser: one THREE.Points cloud, LineSegments for stargates, a 75 degree camera, why instancing would not help, and what it all measures at.
Turning millions of blockchain events into geographic intelligence—heat maps, time series analysis, and spatial aggregation for strategic decision-making.
What the Compare Regions panel really computes across 274 EVE Frontier regions, checked against the code, including why 174 of them have no stargates at all.
Inside our PostgreSQL-based indexing pipeline: how we transform slow blockchain queries into millisecond-response analytics using spatial indexes and materialized views.
Try the interactive star map with advanced routing and optimization features.
Launch EVE Frontier Map