Technical guides, feature updates, and optimization stories from the EVE Frontier mapping project.
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.
How we integrated Context7 MCP server to eliminate manual file attachments for AI agents, reducing documentation lookup time from 3-5 minutes to 10-15 seconds with zero user interruption.
Complete documentation for regenerating EVE Frontier map databases from VULTUR and Phobos extraction tools—ensuring fresh LLMs can rebuild production data after universe updates.
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.
How we built a usage analytics system that tracks feature adoption and engagement using only aggregate counters—no user IDs, no sessions, no PII, complete transparency.
Reducing load time by 90% and bundle size by 65% through spatial indexing, code splitting, native APIs, and measurement-driven optimization.
Introducing Cinematic Mode—a fullscreen, distraction-free way to explore EVE Frontier's star map with smooth camera controls and atmospheric visuals.
Introducing Follow Mode—live location tracking that keeps the map centered on your in-game position, bridging the game client and browser via the helper service.
Track all-time and per-session visited systems with visual halos—integrates with the helper bridge to automatically detect systems visited in-game.
Building a DirectX 12 overlay that displays routes calculated on the web directly inside EVE Frontier—seamless navigation without alt-tabbing.
Enriched pathfinding that trades efficiency for exploration—corridor factors, overhead budgets, and discovery scoring to find wormholes and resources along your route.
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.
Lightweight shared annotations on the star map—no user accounts, just tribe names, optimistic concurrency, and serverless KV storage for real-time tactical coordination.
Creating a serverless, privacy-focused route sharing system using Cloudflare Workers and KV—compress complex routes into short URLs that work anywhere.
Offloading pathfinding and multi-destination optimization to background threads using Web Workers—message protocols, progress updates, and worker pools for parallel computation.
Understanding the difference between A* and Dijkstra's pathfinding algorithms—when to use each one, performance tradeoffs, and why we implemented both in EF-Map.
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.
Iframe embedding for partner sites—URL parameters for system focus, zoom levels, orbit mode, color palettes, and preloaded routes. Fully customizable and responsive.
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.
From 500ms to 4ms: how we used instanced rendering, spatial indexing, and GPU picking to render EVE Frontier's massive star map at 60 FPS in the browser.
Turning millions of blockchain events into geographic intelligence—heat maps, time series analysis, and spatial aggregation for strategic decision-making.
Side-by-side region comparison tool for data-driven expansion decisions—analyze resource density, player activity, gate connectivity, and strategic positioning across multiple regions.
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