Ship ground software.
Not another ground system.
Open-source core under the OpenC3 Builder's License. Plugin architecture. REST, WebSocket, and MQTT APIs. Container-native. Air-gap friendly. COSMOS is the platform aerospace software engineers stop rebuilding — so you can spend your sprint on the mission, not on the framework.
The pain we keep hearing from aerospace software engineers.
If any of these sound like your sprint, you're in the right place.
Rebuilding the ground console from scratch — again.
COSMOS is the console: screens, plugin SDK, real APIs.
Every protocol becomes a hand-written bridge in its own repo.
Hundreds of drivers in the box; add new ones via one typed interface.
Ops scripts are a graveyard of bash, Tcl, MATLAB, and one-off Python.
Script Runner: first-class Ruby + Python on one shared dictionary.
Six-week Qt UI sprint every mission — and the author already left.
Text-based configurations or drop in your own React/Vue widgets.
Anomaly hits and you're tailing logs to reconstruct what happened.
Every packet, limit break, and action is indexed and replayable.
Deploy = tar.gz on a jump box and sudo make install.
Docker Compose in dev, K8s + Helm in prod — same image, one-command rollback.
Vendor is cloud-only SaaS; security blocks it before the SCIF.
Installs offline on-prem — classified-enclave and ATO friendly.
Wrangling FlexLM,per-seat, per-target, per-protocol license — source under NDA.
Core ships on GitHub under the OpenC3 Builder's License.
Ground system is the test rig is prod — regressions ship to ops.
Run procedures headless in CI against a sim target.
A platform a developer can actually love.
Open source. Real APIs. Container-native. None of this is bolted on — it's the platform.
Builder's License on GitHub
COSMOS Core is open source under the OpenC3 Builder's License. Read it, fork it, run it in prod. No license surprises, no vendor lock-in.
Plugin architecture
Targets, protocols, microservices, widgets, tools, conversions — extend without forking. Plugins ship as gems and wheels.
Real APIs
REST for the control plane, WebSocket for live telemetry, MQTT bridge for embedded clients. Same primitives as any modern service.
Ruby + Python scripting
Both first-class in Script Runner. Pick by team or by procedure — share the same dictionary and the same evidence trail.
Container-native
Docker Compose locally, Kubernetes in prod, Helm charts in the box. Live reload during plugin dev.
Air-gap friendly
Offline plugin install, on-prem registries, classified-enclave deploys. Modern dev ergonomics without the cloud dependency.
The layers you actually touch.
A platform built like a platform — every layer extensible, every interface documented.
- ▸Vue + React widgets
- ▸TEXT-BASED SCREEN BUILDER
- ▸Plugin SDK for custom widgets
Drop in a React widget; it ships as part of your plugin.
- ▸REST (commanding, config, query)
- ▸WebSocket (live telemetry, events)
- ▸MQTT bridge
- ▸gRPC bridges
Talk to COSMOS from any language — JS, Python, Go, Rust, embedded C.
- ▸Command + telemetry router
- ▸Limits engine
- ▸Script Runner (Ruby + Python)
- ▸Recorder + replay
Add a microservice plugin; it joins the rest like a first-class service.
- ▸Redis streams (live)
- ▸S3 (LONG RETENTION)
- ▸QUESTDB (DECOMMUTATED DATA)
Point at your existing object store; bring your own retention policy.
- ▸CCSDS · HTTP · GEMS · SNMP · GRPC
- ▸Ethernet · UDP · TCP · Serial
- ▸MAVLink · MQTT · custom binary
Implement one interface to add a new protocol — typed, tested, drop-in.
- ▸Docker Compose (dev)
- ▸Kubernetes + Helm (prod)
- ▸On-prem · classified · air-gap
Pick your posture; the platform doesn't care if it's a laptop or a SCIF.
APIs you'd choose on a greenfield project.
COSMOS exposes a clean control plane and a streaming data plane. Drive it from a browser, a Python script, an embedded MQTT client, or a curl pipeline — pick the surface that matches the job.
- REST
- Commanding, config, query, plugin management. Token auth, OpenAPI.
- WebSocket
- Live telemetry and events. Subscribe to mnemonics, packets, or whole scopes.
- MQTT bridge
- Bidirectional bridge for embedded and IoT clients. Topic = mnemonic.
- Scripting API
- Ruby + Python with cmd, tlm, wait_check, limits hooks, scope switching.
# Script Runner procedure — Python flavor
from openc3.script import *
set_scope("FLIGHT")
wait_check("GND ANT_LOCK == 1", 60)
cmd("SAT MODE_NORMAL")
wait_check("SAT BATT_V > 27.0", 30)
# SSR dump with a limits-driven hold
cmd("SAT SSR_DUMP_START with RATE_KBPS 8192")
wait_check_expression(
"tlm('SAT SSR_REMAINING_MB') < 1",
timeout=600,
hold_on="SAT BATT_V < 26.0",
)
cmd("SAT SSR_DUMP_STOP")Target
A new spacecraft, bus, or piece of GSE. Defines telemetry, commands, and limits.
Interface
Drop-in interface for a new wire protocol — typed, tested, hot-installable.
Microservice
Background worker that joins the bus — autonomy, decoders, custom bridges.
Widget
Custom screen widget in Vue or React. Ships inside the plugin, no core fork.
Tool
Add a new app to the COSMOS launcher — your team's bespoke ops tool, scoped and authed.
Routers
Custom telemetry transforms — engineering units, derived mnemonics, CRC checks.
Script Engines
Add custom DSLs to COSMOS, like CSTOL
Plugins ship as gems and wheels · version-controlled · hot-installable · offline-installable on air-gapped sites.
Extend the platform. Don't fork it.
Six plugin types cover every extension point a ground-software team has ever asked for.
Modern dev ergonomics. Aerospace posture.
The platform optimizes for the developer's inner loop and the program's outer loop in equal measure.
Local in one minute
git clone, docker compose up, browser at localhost — a working ground system with sim targets, live reload on plugin changes.
CI for procedures
Script Runner procedures run in your CI against sim targets. Pass/fail gates, captured evidence, parameterized test matrices.
Replay into a dev branch
Pull any historical pass into a local install. Debug the anomaly in the same console operators saw it on — packet-for-packet.
Observability built in
Structured JSON logs, Prometheus metrics, distributed tracing on the API surface. Drops straight into your existing stack.
From a laptop to a SCIF — same platform.
Pick your posture. Nothing about COSMOS assumes the cloud, and nothing about it forbids it.
What you stop maintaining the day you adopt COSMOS.
Questions software engineers actually ask.
Can we contribute upstream or fork without losing support?+
How do we add a new protocol or hardware target?+
What's the upgrade story — do plugins break on minor versions?+
Can I run COSMOS in CI for regression testing?+
What does the WebSocket telemetry API look like under load?+
How do air-gapped sites get plugin updates?+
Stop rebuilding ground software. Start shipping it.
Bring your protocol, your container target, and the API surface your team wants. We'll show you the same COSMOS your developers will live in from sprint one.