OrbitGuard: Space Debris Collision Avoidance

Real-time collision risk detection for 24,000+ satellites and debris. Uses SGP4 orbital propagation + ML probability prediction to flag threats and simulate evasion maneuvers in 3D.

Comment

Inspiration

Every day, there are over 24,000 tracked objects moving through the Low Earth Orbits able to destroy a satellite on impact. Collisions can trigger Kessler cascades which are chain reactions of fragmentations that multiply debris, worsening the problem. These debris are almost impossible to clean, thus, they remain stuck in our atmosphere, They destroy satellites that aid GPS navigation, weather forecasting and climate monitoring, creating grave real-world consequences on earth. Additionally losing access to key orbital bands during Kessler reactions would set back climate science by decades by blinding the early warning systems that track natural disasters. We built OrbitGuard to preventatively protect our satellites.

What it does

OrbitGuard is a real-time space debris collision avoidance platform. It:

  • Tracks 24,000+ active satellites and debris objects using live CSV data from CelesTrak
  • Propagates orbits via SGP4 to detect close approaches within 5 km
  • Predicts collision probability using a trained =Gradient Boosting ML model (trained on the ESA Collision Avoidance Challenge dataset)
  • Visualizes everything on an interactive 3D globe built with Three.js
  • Lets operators simulate what-if maneuvers (altitude/inclination changes) and see exactly how risk drops

How we built it

Orbital Propagation

We use the SGP4 model to propagate each object's motion set forward in time. The orbit is governed by the vis-viva equation:

$$v^2 = GM\left(\frac{2}{r} - \frac{1}{a}\right)$$

where \(v\) is orbital speed, \(r\) is the current distance from Earth's center, \(a\) is the semi-major axis, and \(GM = 398600.4418 \ \text{km}^3/\text{s}^2\).

We derive semi-major axis directly from the mean motion \(n\) (rev/day):

$$a = \left(\frac{GM}{n^2}\right)^{1/3}, \quad n \text{ converted to rad/s}$$

Collision Screening

Checking all \(N = 24{,}749\) objects pairwise is \(O(N^2) \approx 600\text{M}\) comparisons. We use a SciPy cKDTree to reduce this to \(O(N \log N)\), querying only pairs within a 50 km screening radius, then filtering to the 5 km close-approach threshold.

ML Pipeline

We modelled collision risk as log-probability and train a Gradient Boosting regressor to predict it:

$$\hat{r} = \log P(\text{collision}) \implies P = e^{\hat{r}}$$

Features include miss distance \(d\), its log and inverse:

$$f = \left[d,\ \ln d,\ \frac{1000}{d},\ v_\text{rel},\ a_T,\ e_T,\ i_T,\ a_C,\ e_C,\ i_C,\ h_\text{apo},\ h_\text{per}\right]$$

where subscripts \(T\) and \(C\) denote the target and chaser objects respectively, and \(h_\text{apo}, h_\text{per}\) are apogee and perigee altitudes above Earth's surface:

$$h_\text{apo} = a(1 + e) - R_\oplus, \quad h_\text{per} = a(1 - e) - R_\oplus$$

  • Frontend: React + Three.js (@react-three/fiber) for the 3D globe, Recharts for probability/distance timelines, Tailwind CSS
  • Backend: Python FastAPI with async endpoints; SGP4 propagation via the sgp4 library; SciPy cKDTree for O(n log n) spatial collision screening
  • Data: CelesTrak OMM CSV format, preprocessed into a unified 24,749-object catalog

Challenges we ran into

  • Scale: Screening 24k objects pairwise is \(O(N^2)\): we solved this with spatial indexing (cKDTree) and a 50 km pre-screening radius, cutting runtime dramatically
  • XGBoost on macOS: Hit an OpenMP/libomp compatibility wall; migrated to scikit-learn's GradientBoostingRegressor without sacrificing accuracy
  • Coordinate systems: Transforming ECI (Earth-Centered Inertial) coordinates to Three.js world space required careful axis mapping
  • Graceful degradation: Built heuristic fallbacks so the app stays useful even when the ML model or live data is unavailable

Accomplishments that we're proud of

  • Built a full orbital mechanics pipeline from scratch. raw CSV data → SGP4 propagation → ECI coordinate transforms → 3D globe rendering
  • Screened 24,749 satellites and debris objects for close approaches in real time using spatial indexing (cKDTree), reducing what would be a 600M+ pairwise comparison to milliseconds
  • Trained and deployed an end-to-end ML collision probability model on the ESA dataset, integrated live into the API with per-alert risk scores
  • Shipped a usable 3D visualization

What we learned

  • Orbital mechanics and SGP4 propagation from scratch, including how \(a\), \(e\), and \(i\) define an orbit and how they translate to real positions in 3D space
  • How spatial indexing changes brute-force \(O(N^2)\) problems into tractable \(O(N \log N)\) ones
  • The real complexity behind collision probability estimation
  • Building full-stack systems under time constraints

What's next for OrbitGuard: Space Debris Collision Avoidance

  • Conjunction Data Messages (CDM): Ingest official Space-Track CDM files for higher-fidelity probability estimates using full covariance matrices: the industry standard, where collision probability is computed as a 3D Gaussian overlap integral: $$P_c = \iint_{A} \frac{1}{2\pi\sqrt{|\Sigma|}} \exp!\left(-\frac{1}{2}\mathbf{x}^T \Sigma^{-1} \mathbf{x}\right) dA$$
  • Δv maneuver optimizer: Automatically compute the minimum-cost maneuver using the Hohmann transfer approximation: $$\Delta v = \sqrt{\frac{GM}{r_1}}\left(\sqrt{\frac{2r_2}{r_1+r_2}} - 1\right)$$
  • Push alerts: Notify satellite operators via email/SMS when a new high-risk conjunction is detected
  • Multi-step propagation accuracy: Replace linear heuristics with full numerical integration (Runge-Kutta)
  • Hosted deployment: Ship to Render (backend) + Vercel (frontend) so anyone can use it without running locally
  • Historical conjunction database: Store and replay past close approaches to validate model accuracy against known near-misses

Built With

Share this project:

Updates