We Found 441 Collision Risks in 6 Seconds on a $250 Computer

There are 14,368 active objects in orbit right now. Every day, hundreds pass within kilometers of each other. Most operators don't know until after the fact.

We built something to fix that. Here's what we found.

The Problem Nobody's Solving

If you operate satellites, you have two options for collision monitoring:

• Free but unusable: Download raw TLE data from CelesTrak, figure out SGP4 propagation yourself, manually analyze thousands of close approaches, miss the ones that matter.
• Enterprise-grade expensive: Pay $2,500 per satellite per month for conjunction data services. If you have 10 satellites, that's $300K/year.

There's nothing in between. No tool for the small operator with 3-20 satellites who needs automated screening but can't justify enterprise pricing. That's where most collisions will happen.

What We Built

OrbitGuard is an open-source Python library that screens the entire active catalog for collision risks. It runs on commodity hardware. It's Apache 2.0 licensed. And it's fast.

That's the entire active catalog, screened for 24 hours of conjunctions, in less time than it takes to load a webpage.

What We Found

Out of 590 close approaches, 441 were real collision risks. The other 174 were formation-flying pairs we auto-filtered — ISS modules docked together, TanDEM-X radar twins, PIESAT constellation birds.

Here's what stood out:

Closest real threat: STARLINK-31941 and STARLINK-32792 passed within 1.16 km at a relative velocity of 2.54 km/s. Same operator, but that's still close enough to trigger evasive maneuvers in a well-coordinated system.

Hubble Space Telescope: Three close approaches with Starlink satellites in 24 hours. Hubble has no propulsion. It can't dodge. It relies entirely on other operators avoiding it.

Cross-operator risk: NUSAT-41 (Satellogic) came within 2.49 km of STARLINK-36054 at 11.55 km/s. Different companies, different orbits, no coordination mechanism beyond what SpaceX monitors internally. This is where the gaps are.

596 close approaches happen every day. The operators know about some of them. Not all.

How It Works

The bottleneck in conjunction screening isn't the orbital math — it's the combinatorics. Checking 14,368 objects against each other naively is O(n²), or ~100 million comparisons. That's slow.

We solve it with spatial indexing:

from sgp4.api import SatrecArray
from scipy.spatial import cKDTree

# Vectorized propagation: 31.5ms for full catalog
positions, velocities = sat_array.sgp4(jd_dates, fr_dates)

# Build KD-tree: O(n log n) spatial index
tree = cKDTree(positions)

# Query pairs within threshold: O(n log n)
pairs = tree.query_pairs(r=10.0)  # 10 km

# Deduplicate, track minimum distance over time
# Filter formation flying: relative velocity < 0.05 km/s

We use SatrecArray from sgp4 for vectorized propagation — it's 100x faster than looping through individual satellites. Then scipy.cKDTree gives us O(n log n) nearest-neighbor queries instead of O(n²) brute force.

At each timestep (5-minute intervals over 24 hours), we:

1. Propagate all satellites to that time
2. Build a KD-tree from their positions
3. Query for pairs within 10km
4. Track the minimum distance for each unique pair

Formation-flying satellites are automatically classified by relative velocity — if two objects are always within 5km and moving slower than 0.05 km/s relative to each other, they're formation flying, not collision risks.

For a full technical deep-dive into the algorithms, see How Satellite Collision Prediction Works.

Why This Matters

The Kessler Syndrome isn't a distant risk anymore. We're already seeing close calls every single day. 596 close approaches in 24 hours. That's 25 per hour. One every 2.4 minutes.

The operators with the most satellites have the resources to track conjunctions. The operators with 5-20 satellites — research institutions, startups, universities — are flying blind. They rely on Space Force warnings that come hours or days late, if at all.

The gap between free raw data and $2,500/satellite/month is where most operators live. And it's where most collisions will happen.

The code is open. The data is public. The problem is solvable. Let's solve it before the next collision.