Orbital Compute Simulator

March 26, 2026 · View on GitHub

The honest, open-source answer to "should we put GPUs in orbit?"

Tests 222+ Tests Python 3.9+ License: MIT 24K+ Lines

Live Demo | 3D Globe | Cost Calculator | Constellation Designer | Data Pipeline

Everyone in orbital compute is selling a dream. We sell the math.

  • Orbital compute is 24-50x more expensive than AWS. We publish the numbers.
  • In-orbit processing saves 99% of downlink bandwidth. We prove it with simulation.
  • Battery capacity fades to 66% in 3 years of LEO cycling. We model the physics.
  • The PHOENIX algorithm improves worst-case battery by 23 percentage points. We implemented the paper.

This is the only open-source tool that models the complete space datacenter stack — from orbital mechanics to job scheduling to business economics — and tells you the truth about what works and what doesn't.

No hype. No hand-waving. No "trust us." Run the simulation yourself.

Who Is This For?

You are...You need...Start here
Startup founder pitching orbital compute to VCs"Is this economically viable?"python -m orbital_compute.cost_model (30 sec)
Grad student writing an OEC thesisA baseline simulator to compare your algorithm againstpip install orbital-compute && python -m orbital_compute
Engineer at Starcloud/Axiom/Kepler"Will PHOENIX scheduling help our battery life?"python -m orbital_compute.phoenix
Mission planner sizing a constellation"How many sats do I need for 1000 GPU-hours/day?"python -m orbital_compute.designer
Journalist writing about space datacenters"Is orbital compute actually viable?"Data Pipeline Visualization
Conference reviewer checking an OEC paper"Are these numbers realistic?"REPRODUCIBILITY.md
pip install orbital-compute
python -m orbital_compute

PyPI

Why In-Orbit Processing?

The data pipeline simulator proves the core value proposition:

Strategy                   Generated   Downlinked   Saved    Backlog
raw_downlink                 1042 GB      900 GB    13.6%    142 GB  (growing!)
image_classification         1042 GB       10 GB    99.0%      0 GB
object_detection             1042 GB        5 GB    99.5%      0 GB

Raw downlink can't keep up — 142 GB backlog growing every day. In-orbit processing saves 99% of bandwidth. This is why orbital compute exists.

What It Does

26 Python Modules

CategoryModulesWhat It Models
Orbital Mechanicsorbit.py, constellations.pySGP4 propagation, TLE data, eclipse detection, real Starlink TLEs from CelesTrak
Power & Thermalpower.py, thermal.pySolar panels, battery charge/discharge, Stefan-Boltzmann radiative cooling
Schedulingscheduler.py, scheduler_v2.pyGreedy + look-ahead schedulers with eclipse forecasting (PHOENIX-inspired)
Networkingisl.py, network.pyInter-satellite optical links, routing, topology analysis, Floyd-Warshall
Radiationradiation.pySEU fault injection, South Atlantic Anomaly, 4 recovery strategies
Workloadsworkloads.py9 realistic types: Earth obs, AI inference, defense/ISR, scientific
Ground Stationsground_stations.py10 global stations, elevation-angle contact windows, pass prediction
Data Pipelinedata_pipeline.pySensor → storage → in-orbit processing → downlink. Proves 99% bandwidth savings
Mission Planningmission_planner.pyOps timeline, conflict detection, data budget calculator, availability
Designdesigner.pyAuto-design optimal constellation from requirements + budget
Economicscost_model.pyCAPEX/OPEX, break-even, ROI, terrestrial comparison. Honest: 24-50x more expensive
Reliabilityreliability.pyMTBF, constellation availability (binomial), SLA analysis, degradation curves
Debris & Propulsiondebris.py, propulsion.pyCollision avoidance, CAM planning, Kessler risk, drag model, station-keeping, deorbit
Federated Learningfederated.pyTrain ML models across constellation (FedAvg/FedProx/SCAFFOLD), ISL-aware aggregation
K8s Integrationk8s_scheduler.pyKubernetes scheduler extender for orbit-aware pod placement
Standardsformats.py, standards.pyCCSDS OEM, STK ephemeris, ECSS power/thermal/link budgets
Interfaceapi.py, cli.py, simulator.py, visualize.pyREST API, unified CLI, core engine, 3D globe generator

Interactive Web App

Live at shipitandpray.github.io/orbital-compute

  • Dashboard — Configure constellation, run simulation in-browser, see fleet stats + timelines
  • 3D Globe — Three.js visualization with orbits, ground stations, ISL links, play/pause
  • Cost Calculator — Drag sliders, see CAPEX/OPEX/break-even update in real-time
  • Constellation Designer — Input requirements, get optimal design with Walker geometry
  • Data Pipeline — Canvas chart proving why in-orbit processing is necessary
  • API Docs — REST endpoint documentation with curl examples

All runs in the browser. No server. No login. No cold starts.

Quick Start

git clone https://github.com/ShipItAndPray/orbital-compute.git
cd orbital-compute
pip install -r requirements.txt

# 30-second overview of everything
python -m orbital_compute

# Full demo (all subsystems: orbit + power + thermal + ISL + radiation + scheduling)
python demo.py

# Custom simulation
python run_sim.py --sats 12 --hours 24 --jobs 100

# Constellation designer (auto-design from requirements)
python -m orbital_compute.designer

# Cost analysis
python -m orbital_compute.cost_model

# Data pipeline comparison
python -m orbital_compute.data_pipeline

# Reliability/SLA analysis
python -m orbital_compute.reliability

# Mission planning timeline
python -m orbital_compute.mission_planner

# ECSS standards compliance
python -m orbital_compute.standards

# Industry format export (CCSDS OEM, STK)
python -m orbital_compute.formats

# Web dashboard
python dashboard.py

# REST API
python -m orbital_compute.api --port 8080

# Scheduler benchmark (greedy vs look-ahead)
python benchmark.py

# Fetch real Starlink TLEs
python -m orbital_compute.constellations

# Or use make shortcuts
make test        # Run 200+ tests
make demo        # Full demo
make cost        # Cost analysis
make pipeline    # Data pipeline proof
make serve       # Local web app

Key Results

Constellation Designer

Input:  1000 GPU-hours/day, global coverage, \$50M budget
Output: 6 satellites, 8 GPUs each, 2000 km altitude
        \$45.9M total (under budget), 1017 GPU-hours/day

Reliability Analysis

12-satellite constellation:
  99%    SLA: YES (1 operational needed, 11 spare)
  99.99% SLA: YES (1 operational needed)
  99.999% SLA: NO (need all 12 — not feasible with 1.4yr MTBF)

Cost Model (Honest Assessment)

Orbital compute: \$86-172/GPU-hour (12 sats, Falcon 9)
AWS equivalent:  \$4.10/GPU-hour
Ratio: 24-50x more expensive

But: processing in orbit saves 99% downlink bandwidth.
The value prop is NOT raw $/hr — it's avoiding the downlink bottleneck.

Full Simulation (12 sats, 12h, 80 jobs)

Jobs completed:     80/80
Fleet utilization:  32%
Eclipse fraction:   26-37% per satellite
Radiation SEUs:     303 events, all recovered via checkpoint-restart
ISL links:          6 active (mesh topology)
Temperature range:  -19°C to 24°C (within limits)

Architecture

orbital_compute/          # 26 Python modules
├── orbit.py              # SGP4 propagation, eclipse detection
├── power.py              # Solar + battery model
├── thermal.py            # Stefan-Boltzmann radiative cooling
├── scheduler.py          # v1: Greedy orbit-aware scheduler
├── scheduler_v2.py       # v2: Look-ahead with eclipse forecasting
├── ground_stations.py    # 10 stations, contact windows
├── isl.py                # Inter-satellite links, LOS, routing
├── network.py            # Topology analysis, Floyd-Warshall routing
├── radiation.py          # SEU injection, SAA, recovery strategies
├── workloads.py          # 9 workload types + mixed traffic generator
├── data_pipeline.py      # Sensor → processing → downlink pipeline
├── mission_planner.py    # Ops timeline, pass prediction, data budgets
├── designer.py           # Auto-design constellation from requirements
├── cost_model.py         # Full economics + terrestrial comparison
├── reliability.py        # MTBF, SLA, degradation curves
├── constellations.py     # Pre-defined configs + real TLE fetch
├── formats.py            # CCSDS OEM, STK ephemeris, JSON Schema
├── standards.py          # ECSS power/thermal/link budgets
├── debris.py             # Collision probability, CAM planning, Kessler risk
├── propulsion.py         # Atmospheric drag, station-keeping, deorbit planning
├── federated.py          # Federated learning across constellation (FedAvg/FedProx)
├── k8s_scheduler.py      # Kubernetes scheduler extender for orbit-aware pods
├── api.py                # REST API
├── simulator.py          # Core simulation engine
├── visualize.py          # 3D Three.js globe generator
└── cli.py                # Unified CLI

docs/                     # Web app (GitHub Pages)
├── index.html            # Landing page
├── dashboard.html        # Interactive simulator
├── globe.html            # 3D orbit visualization
├── cost.html             # Cost calculator
├── designer.html         # Constellation designer
├── pipeline.html         # Data pipeline analysis
└── api-docs.html         # API documentation

tests/                    # 107 tests, all passing

Research References

  • PHOENIX (IEEE 2024) — Sunlight-aware task scheduling for energy-efficient space edge computing
  • KubeSpace (arXiv 2601.21383, 2026) — Low-latency K8s control plane for LEO container orchestration
  • Krios (USENIX HotEdge 2020) — Loosely-coupled orchestration for the LEO edge
  • Comprehensive Survey of Orbital Edge Computing (Chinese Journal of Aeronautics, 2025)
  • Axiom Space AxDCU-1 — First orbital data center on ISS (2025), Red Hat Device Edge
  • Starcloud — First H100 GPU in orbit (Nov 2025), NVIDIA partnership
  • ESA ASCEND — European orbital compute initiative, €300M through 2027

Contributing

See CONTRIBUTING.md. High-impact areas:

  • Kubernetes scheduler plugin
  • Real satellite hardware integration
  • Multi-objective constellation optimization
  • Federated learning orchestrator

License

MIT — see LICENSE