-
-
SATELLITE SYSTEM
-
MAIN 3D ENGINE
Inspiration
$$ \text{8 Satellites.} \quad \text{300 Debris Objects.} \quad \Delta t \to 0 \implies \text{Collision Inevitable.} $$
Space is getting crowded fast. The low-Earth orbit environment is increasingly polluted with defunct satellites and fragmentation debris — and the window between a conjunction warning and a catastrophic impact can be under 9 minutes.
Existing ground-based monitoring systems are slow, opaque, and passive. Operators receive a warning. Then they wait. Then they guess.
We asked a different question:
What if the satellite already knew — and already had a plan?
Orbital Intel is a real-time AI-powered space situational awareness platform that doesn't just watch conjunctions happen. It reasons, predicts, and executes evasion maneuvers autonomously.
What It Does
Orbital Intel is a full-stack orbital intelligence system with two modes:
3D View — Live Orbital Theatre
A high-fidelity Three.js scene renders the Earth and all tracked objects in real time. The AI Reasoning Engine overlays its live decision log directly onto the 3D canvas as it works through each phase:
$$ \text{SCAN} \;\to\; \text{PREDICT} \;\to\; \text{EVAL} \;\to\; \text{PLAN} \;\to\; \text{EXECUTE} \;\to\; \text{OK} $$
Dashboard — Fleet Intelligence
A unified ops panel with six live metric cards, a ground-track map, maneuver timeline, alert triage panel, and analytics graphs — all polling the simulation backend every 2 seconds.
How We Built It
Orbital Propagation
Satellite positions are integrated using the J2+RK4 propagator — the J2 term accounts for Earth's oblateness (the dominant perturbation in LEO):
$$ \ddot{\mathbf{r}} = -\frac{\mu}{r^3}\mathbf{r} + \frac{3}{2} J_2 \frac{\mu R_E^2}{r^5} \left[\left(1 - \frac{5z^2}{r^2}\right)\mathbf{r} + \frac{2z}{r^2}\hat{\mathbf{z}}\right] $$
State vectors are propagated forward 24 hours at configurable step size to generate pre-path prediction ribbons in the 3D scene.
Conjunction Detection — KD-Tree Spatial Index
Brute-force pairwise distance checks scale as \( O(N^2) \). With 300+ debris objects this becomes untenable. We index all debris positions into a KD-Tree, reducing nearest-neighbour queries to:
$$ \mathcal{T}_{\text{query}} = O(N \log N) $$
Time to Closest Approach is found by minimising the inter-object distance over the prediction horizon: TCA=argt∈[t0,t0+24h]min∥rsat(t)−rdeb(t)∥
AI Reasoning Engine
The AI layer is an event-driven finite state machine that emits structured reasoning logs — phase tag, severity, plain-English message, and the relevant formula — into a live scrolling panel:
| Phase | Trigger | Example Formula |
|---|---|---|
SCAN |
New telemetry tick | \( d = \ |
PREDICT |
Conjunction within 2 km | \( \text{TCA} = \arg\min d(t) \) |
EVAL |
Risk scoring | \( P_c = f(\sigma_r, \sigma_v, d_{\text{miss}}) \) |
PLAN |
Maneuver design | \( \Delta v = v_f - v_i \) |
EXECUTE |
Burn commit | \( \mathbf{r}(t) = \mathbf{r}_0 + \mathbf{v}_0 t + \tfrac{1}{2}\mathbf{a}t^2 \) |
OK |
Safe separation confirmed | \( d_{\text{final}} > d_{\text{threshold}} \) |
Maneuver Planning
Evasion burns are constrained by per-satellite fuel budgets. The Δv allocation follows a simple impulsive model:
$$ \Delta v = \sqrt{\frac{\mu}{r_1}} \left(\sqrt{\frac{2r_2}{r_1 + r_2}} - 1\right) $$
Each satellite carries a fuel percentage state; the system raises
LOW FUEL alerts when \( f < 40\% \) and suppresses maneuver
suggestions below the survivable threshold.
Risk Heat Map
Orbital shells are partitioned into a spherical grid. Each cell accumulates a risk score weighted by debris density and conjunction probability, rendered as a live heatmap overlay on the 3D globe.
Stack
| Layer | Technology |
|---|---|
| 3D Rendering | Three.js + ACESFilmic tone mapping + OrbitControls |
| Physics | J2-perturbed RK4 propagator |
| Spatial Index | KD-Tree, \( O(N \log N) \) |
| Frontend | React + Vite, custom hooks, memo throughout |
| Backend | Python REST API (FastAPI), /api/simulate/step |
| AI Events | Lightweight CustomEvent bridge (zero circular imports) |
| Visualisation | Ground track SVG, spark-line metric cards, timeline |
Challenges We Ran Into
React–Three.js state sync — The renderer runs its own RAF loop at 60 fps; React re-renders are asynchronous. We solved this with a
CustomEventbridge (orbital:ai-reasoning) so the physics engine can fire events that React hooks subscribe to — no shared mutable refs, no circular imports.Debris count vs. frame rate — Rendering 300 instanced debris objects with per-frame KD-Tree queries threatened 30 fps. We culled off-screen objects, batched instanced meshes, and capped pixel ratio at 2× to keep the scene smooth.
Logarithmic depth buffer — Z-fighting between Earth's surface and low-altitude orbit ribbons at \( r \approx R_E + 400\text{ km} \) is severe. Enabling
logarithmicDepthBufferon the WebGL renderer resolved all depth artifacts.Maneuver cooldown logic — Without a cooldown gate, the AI would fire successive burns that overcorrected. We introduced a
_maneuverCooldowncounter on theSceneManagerto enforce a minimum inter-burn interval.
Accomplishments
- Live 3D orbital scene with 8 satellites + 300 debris at 60 fps
- Full AI reasoning loop — SCAN through OK — firing in under 1 s
- Collision probability scoring with CRITICAL / HIGH / MEDIUM / LOW triage and time-to-conjunction countdown
- Autonomous evasion maneuver execution with Δv fuel accounting
- Dual-mode UI: immersive 3D theatre and operator dashboard
- Sub-2-second telemetry polling with spark-line history on all metrics
- Risk heatmap rendered as a live spherical overlay on the globe
What We Learned
The hardest part of autonomous space situational awareness is not the math — it is the information architecture. Making sure the physics engine, AI state machine, and React UI never block each other, share no mutable global state, and remain independently testable required more design discipline than the orbital mechanics themselves.
We also learned that J2 is not optional for LEO. Ignoring Earth's oblateness causes RAAN drift errors of several kilometres per orbit, which completely invalidates conjunction predictions within hours.
$$ \dot{\Omega} = -\frac{3}{2} n J_2 \left(\frac{R_E}{p}\right)^2 \cos i $$
Getting this term right was the difference between a demo and a system an operator could actually trust.
What's Next
- [ ] Replace seeded alert data with live Space-Track.org TLE ingestion
- [ ] Upgrade propagator to SGP4 for full atmospheric drag and solar radiation pressure modeling
- [ ] Add multi-burn maneuver sequencing — Hohmann transfers, phasing orbits — not just single impulsive corrections
- [ ] Export CCSDS Conjunction Data Message (CDM) format for interoperability with real operators
- [ ] Deploy AI reasoning to edge — run the FSM onboard the simulated satellite for fully autonomous operations
Built With
React · Vite · Three.js · OrbitControls · FastAPI
Python · KD-Tree · RK4 Integrator · J2 Propagator
ACES Filmic Tone Mapping · WebGL · CustomEvent Bridge
$$ \boxed{ \text{Orbital Intel} \;:\; \text{SCAN} \to \text{PREDICT} \to \text{EVAL} \to \text{PLAN} \to \text{EXECUTE} \to \text{OK} } $$
Built for Hackathon Troyano 2026.
Log in or sign up for Devpost to join the conversation.