SpaceSphere

Track live satellites on a 3D globe, follow earthquakes, wildfires and storms in real time, and let AI explain it all. Real data from NASA, USGS and CelesTrak, never simulations. Learn as you watch.

Comment

Inspiration

Modern Earth and space data is fragmented across dozens of specialized platforms: satellite trackers, weather maps, earthquake feeds, astronomy apps, and scientific dashboards. Each system is powerful on its own, but there is no unified way to understand what is happening on and around our planet.

SpaceSphere Live was born from a simple question: when was the last time you actually knew what was above your head? I wanted a single live portal where anyone can see Earth and orbit as they really are, right now, ask questions about it in plain language, and then learn the science behind what they just watched.

With the rise of multimodal AI, particularly Gemini, it became possible to move beyond static dashboards and build an interface where the data explains itself, and beyond static courses to a curriculum that teaches on live data instead of textbook illustrations.

What it does

SpaceSphere Live is a real-time Earth and orbit intelligence portal with an AI-native space science school built into it, running on one non-negotiable principle: zero fake data. Everything on the globe is real and live, never simulated or pre-rendered, and the AI explains confirmed data rather than generating it.

See the living planet. A 3D globe with the ISS tracked in real time from CelesTrak orbital elements, the next real launch counting down on its pad, earthquakes pulsing where they struck in the last 24 hours, and live wildfires, storms and volcanic activity from NASA EONET. A flat Earth map for disaster monitoring (USGS, GDACS, NWS), a Moon module, a Solar System module with the Voyager fleet on real JPL Horizons trajectories, and a Sun module carrying live space weather from NOAA SWPC with solar imagery from SDO.

Ask, and get a grounded answer. Eight distinct Gemini surfaces run in production, each built for one job rather than one chatbot bolted onto everything: event briefs for natural events, mission briefs for launches, natural language commands that steer the globe, in-lesson explanations, news briefs per article, a per-lesson AI tutor with server-validated citations, sky-synced recall prompts, and a space weather brief. Every call is metered, rate limited per plan, and logged.

Learn on the real sky. A twelve-lesson Beginner track in six languages with spaced repetition scheduling, an AI tutor that can only answer from the lesson it is teaching, ten Mission Ranks earned through an idempotent experience ledger, and Live Recall: when a real earthquake or launch happens, the platform surfaces the lesson that explains it, so review is triggered by the sky rather than by a calendar. Progress persists for free accounts and syncs across devices for paid ones.

Follow the story. A live space news feed with AI briefs, connected by a knowledge graph that stores only real relations between real records, with a source and a confidence value on every edge.

The platform runs on a three-tier plan ladder (Free, Pro, Orbit) with live Stripe payments on the Pro tier, so the free tier stays genuinely useful while advanced AI headroom, cross-device sync and personalization support sustainability. Every lesson stays free on every tier.

How I built it

SpaceSphere Live is a solo-built production application, developed with an AI-native workflow: I act as the architect and AI coding agents execute implementation under review at defined checkpoints. This is not a gimmick, it is the operating model that lets one person ship at the velocity of a small team.

The workflow has a written constitution. Every code package passes two stops: a numbered plan approved before a single line is written, and a staged diff approved before the commit. Every package touching the database passes three gates: an architect audit of the migration SQL, human application of that SQL, and independent verification of the result read back from the database before any application code runs. Read-only discovery precedes every milestone, because the most expensive class of error is a correct solution to a misremembered problem.

Key components:

  • Next.js 15 and TypeScript in strict mode, hosted on Vercel
  • CesiumJS for the 3D globe, with satellite.js propagating real CelesTrak orbital elements
  • Leaflet for the Earth module, Three.js and astronomy-engine for the Solar System module
  • Same-origin API routes that proxy, cache and rate limit every external data source, so the client never depends on a fragile third-party endpoint
  • Gemini across eight dedicated production endpoints, each with its own grounding context
  • Supabase for auth and Postgres with row level security, plus plan enforcement implemented as database policies and guard triggers rather than application checks alone
  • A knowledge graph (entities and relations with pgvector semantic search) as the connective layer between news, lessons, live events and celestial bodies
  • Stripe in live mode for tiered subscriptions
  • next-intl for full internationalization across six languages, enforced by a key parity script

Content is data and the engine is a registry: adding a lesson means adding a validated JSON file, adding a lesson type means registering a plugin. No core engine code is edited for content growth.

Challenges I ran into

Unifying heterogeneous live data sources was the core challenge: every provider has different formats, update frequencies and rate limits. The answer was a consistent layer of same-origin API routes with caching and rate limiting, and a rule that a live layer always carries a freshness window, a significance floor and a hard count cap, so it can never quietly turn into an archive.

Rendering performance was the second battle. A live 3D globe with propagated satellites is heavy, especially on mobile. Solutions included request render mode, pausing rendering when the tab is hidden, lazy-loaded textures, and a shared layer engine that applies scene changes only once the scene declares itself ready. That engine exists because of a race condition invisible in development and only reproducible in a production build, which is now a standing rule: hero verification always includes a local production build.

Cross-device state was harder than expected. An early version awarded experience twice when the same account was open on two devices, because a synced completion flag met a device-local ledger. The fix became a durable rule: any derived counter must deduplicate on a stable business key rather than on a per-write id, and any denormalized total must be recomputed from its source rather than merged.

Grounding the AI was the last and most important battle. A tutor that invents a plausible number is worse than no tutor at all in an education product. The answer was a quadruple shield in the system instruction plus server-side citation validation: the model returns source ids, the server filters them against the real grounding document, and a fabricated citation is therefore impossible to display.

Accomplishments that I'm proud of

  • A production application live on the web, built and shipped entirely solo, with Stripe in live mode and the full payment path verified end to end on a real card: checkout, webhook, plan upgrade, cancellation and refund
  • The zero fake data principle held throughout: every satellite, quake, launch and event is real, every AI surface explains confirmed data, and approximations appear only behind an explicit label
  • Eight purpose-built Gemini endpoints in production, each metered and rate limited, with more than 1,200 logged calls across consecutive days of real usage
  • A full learning loop in six languages: twelve lessons, spaced repetition, a grounded AI tutor with verifiable citations, ten Mission Ranks, and Live Recall firing on real world events
  • Plan enforcement pushed down into the database, so a paid feature cannot be reached by bypassing the application layer
  • A three-tier plan ladder with live payments, usage metering and database-level plan gating, plus a running paid acquisition campaign
  • An AI-native development workflow with real governance, which is the actual product behind the product

What I learned

The real value of AI in geospatial systems is not displaying more data, it is removing the cognitive barrier between data and understanding. Users do not want dashboards, they want answers, context and interpretation, and then they want to understand why.

I also learned that an AI-native solo operation is viable in this category, but only with governance. Speed comes from delegation, safety comes from checkpoints, and the two are not in tension when the checkpoints are cheap and specific. The stops and gates in this project were not bureaucracy, they were the reason a solo operator could touch production databases and live payments without an incident.

The third lesson is about honesty as architecture. Refusing to fake a single data point forced better engineering: typed feeds with localized fallbacks, approximation badges, citation validation, and a knowledge graph that stores only relations between real records. Discipline that starts as an ethical rule ends up as a technical moat.

What's next for SpaceSphere Live

The roadmap is architected, not aspirational, and every new live layer compounds: it becomes teachable surface for the school, a trigger source for recall and alerts, and a data source for the knowledge graph.

  • Overhead: click any point on the globe and see what is above it now, what passes today, and what is visible tonight, on a shared orbital propagation engine running off the main thread
  • Satellite identity and exploration: per-object detail panels, search, filters, and a full catalog density view including rocket bodies and debris
  • Alert Engine: standing queries on the knowledge graph, so a subscription becomes a question the platform answers the moment reality changes
  • Sky Rewind: describe what you saw in the sky, and the platform reconstructs what it actually was from confirmed orbital data
  • Global topographic map on self-hosted open elevation data
  • Learn expansion into Intermediate and Advanced tracks, taught on the modules that shipped this summer
  • Native mobile apps for iOS and Android via Capacitor

Long term, SpaceSphere Live aims to be the place where anyone, in any language, can look at the real, living planet, ask what is happening, and walk away understanding it.

Built with

  • TypeScript
  • Next.js 15 / React
  • CesiumJS and satellite.js (3D globe and real-time orbit propagation)
  • Leaflet (Earth and disaster monitoring)
  • Three.js and astronomy-engine (Solar System and celestial mechanics)
  • Google Gemini API (eight production endpoints: event briefs, mission briefs, globe commands, lesson explanations, news briefs, AI tutor, live recall, space weather briefs)
  • Supabase (auth, Postgres with row level security, pgvector, usage metering)
  • ts-fsrs (spaced repetition scheduling)
  • Stripe (live tiered subscriptions)
  • next-intl (six-language internationalization)
  • Vercel (hosting and deployment)
  • Google Analytics 4 with Consent Mode v2
  • Live data: CelesTrak, USGS, NASA EONET, GDACS, NWS, NOAA SWPC, Helioviewer (SDO), Launch Library 2 (The Space Devs), JPL Horizons, Spaceflight News API
Share this project:

Updates