01Case study · Performance

Our own project: software we built and operate ourselves.

AstrOS Engine

You open the page and watch 50,000 satellites move around Earth, with live NASA and NOAA data. Nothing to install. We wrote the engine from scratch in Rust and compiled it to WebAssembly; WebGPU means the math runs on your graphics card, so everything moves smoothly.

Open the live demoGet my free audit
AstrOS mission console: an Earth globe with 50,000 satellite orbits and a NASA telemetry panelLive demo
02Challenge

Tens of thousands of moving objects live, with no install

Thousands of moving objects at once usually kill smoothness: the CPU and off-the-shelf libraries cannot keep up, frame after frame. We wanted to prove the browser can carry the whole population when the graphics card does the math. No install, a small download, no dropped frames.

03How it works

All the work on the GPU, zero CPU cost per object

Seed once

The orbital elements for ~50,000 satellites are uploaded to the GPU buffer one time, from the real CelesTrak catalog or a procedural fallback.

Compute per frame

A WGSL shader propagates every object in parallel (Kepler + J2 + drag). The CPU never touches a single satellite.

Render with no copy

The render pass reads positions straight from the buffer (vertex pulling): one draw call per layer, with no rewriting of data on the CPU.

The engine is platform-agnostic: the same code builds real pipelines on a native Metal or Vulkan device, which lets it be tested in headless CI without a browser.

04Performance

Measured, not claimed

~1100×

faster satellite-catalog load: the scene starts right away instead of making you wait for the browser to crunch raw data.

25k–1M

objects on the slider: you pick the scale of the scene yourself, and smoothness is measured live, not claimed.

~447 KB

the whole app weighs less than one phone photo: it opens instantly, nothing to install.

The baked blob is the array of GPU elements; decoding is practically a copy, with no per-object math. The realism rides the same zero-CPU-cost path as the rest of the engine. The SGP4 reader itself (pure Rust) matches the CelesTrak reference implementation to within 2×10⁻⁷ km.

Check these numbers yourself in the live demo
05Live data

NASA and NOAA telemetry console

A panel sits over the 3D scene and thinks like a flight controller. Instead of five tables you get the conclusion straight, e.g. "ELEVATED: NOAA WARNING G2". A time slider (×0.125–×4096, log scale) speeds up the simulation, and the aurora on the globe reacts to the real Kp index, a measure of geomagnetic storms. It all works on a phone too.

NOAA SWPC
Planetary Kp, solar wind, space-weather alerts
NASA NeoWs
Near-Earth asteroids, hazard flags, closest approaches
NASA EONET
Natural events: wildfires, storms, volcanoes, floods
APOD / EPIC / GIBS
Picture of the day, Earth from DSCOVR, daily satellite imagery
Launch Library 2
Upcoming orbital launches with countdowns
06Stack

Every choice has a reason

Language
Rust → WebAssembly
No runtime, memory safety, small binary artifact
Graphics
wgpu 30 (WebGPU)
Direct pipeline control, zero framework overhead
Physics
Compute shader (WGSL)
50,000 satellites in parallel, zero CPU per object
Render
Vertex pulling
Positions read straight from the buffer, one draw call per layer
Data
CelesTrak catalog (SGP4)
Real objects, baked into a zero-copy blob
07Contact

Got a nagging problem? Describe it, I'll code the rest.

One sentence is enough to start. Tell me what's bothering you. Within 48 hours I come back with a clear answer: can it be done, and at what fixed price.

No obligation: describing your problem costs nothing
Free intro audit: you keep the report either way
Fixed price agreed upfront or we don't start: no surprises on the invoice
A limited number of projects at a time, each with full attention: reach out early if the deadline matters
We reply within 48 hours