Orbital Computing-as-a-Service
Compute beyond Earth.
Deploy your software on orbital computing infrastructure. Process spaceborne data closer to where it is generated — without building your own space infrastructure.
Why orbital computing
Not every byte needs to reach Earth.
Spacecraft generate more data than they can send down. Bandwidth, communication windows, latency and storage all constrain what reaches the ground. Orbital computing lets you process data near its origin — and choose what deserves the trip home.
Downlink constraints
Process closer to the source
Run computation where the data is generated. Onboard CPU/GPU resources let your software operate on spaceborne data in orbit.
Reduce unnecessary data transfers
Downlink capacity, contact windows and onboard storage are finite. Select which results are worth transmitting instead of raw everything.
Enable new space-based applications
A software-defined execution environment in orbit opens the door to applications that were impractical with ground-only processing.
Platform overview
Your software is just the beginning.
Today you deploy your workloads on our orbital infrastructure — validation, deployment, execution environment, resource management, telemetry and results delivery. Tomorrow, the platform grows with you.
Customer Workload
Your application, model, algorithm or processing pipeline — packaged as a deployable workload.
Develop, package & validate
Build against supported environments, verify compatibility and prepare deployable artifacts.
Manage, authorize & deploy
Version-controlled deployments, authorization workflows and mission management.
Execute on onboard CPU/GPU
Your workload runs on orbital compute hardware with managed resource allocation.
Run customer-defined workloads
Controlled access to input data. Your software performs the mission-specific processing.
Store, monitor & deliver
Telemetry, execution status and outputs delivered back through the platform.
Workload compatibility depends on data profiles, resource envelopes and platform security policies. Not every data format or application is automatically supported — each workload is validated before deployment.
Platform roadmap
Deploy your software
Your workloads run on Mininode's onboard CPU/GPU to process spaceborne data.
Bring your own models
Upload and execute your own models on the satellite's GPU.
Software catalog
Ready-made workloads you can deploy without developing your own.
Model catalog
Pre-built models organized by purpose, ready to run in orbit.
Fully custom solutions
End-to-end tailored missions — dedicated configurations built around your needs.
How it works
From code to orbit.
A defined lifecycle takes your software from development to execution on orbital hardware — with validation at every step.
Develop
Build your application or processing pipeline using SpaceNet Forge and the supported development tools.
Validate
Package your workload and verify compatibility, resource requirements and security constraints.
Deploy
Authorize and deploy a specific workload version through SpaceNet Helm.
Execute
Run your workload on orbital compute infrastructure and monitor execution and results.
Workloads execute within supported runtime environments and defined resource envelopes. Compatibility is verified during validation — not assumed.
Built for different workloads
One platform. Multiple applications.
Customers bring their own algorithms — the specific software depends on the use case and the compatibility of its data profile. These are illustrative applications, not certified capabilities.
Earth observation analytics
Run geospatial processing pipelines on imagery where it is captured.
Image filtering & compression
Screen, rank and compress imagery onboard before downlink.
AI inference at the edge
Deploy your trained models to run inference on spaceborne data.
Scientific data processing
Execute research pipelines on instrument data in orbit.
Signal processing
Process RF and sensor signals with customer-defined algorithms.
Custom orbital applications
Bring your own software for workloads we haven't imagined yet.
Two interfaces. One lifecycle.
Forge & Helm
A developer environment to build and prepare workloads — and an operations platform to manage them in orbit.
SpaceNet Forge
Developer environment
Build and prepare workloads for orbital computing.
Test against a full PRO replica — never against PRO itself.
- Package applications
- Validate workload requirements
- Prepare deployable artifacts
- Test against supported environments
$ forge init eo-cloud-mask
✓ workspace created · runtime: orbital-py3.11
$ forge validate --profile gpu-a
✓ manifest ok ✓ resources within envelope
✓ data profile: eo-multispectral-v2
$ forge package --version 0.4.2
→ artifact: cloud-mask_0.4.2.ocw (ready)
SpaceNet Helm
Mission & operations platform
Manage your workloads and orbital operations.
- Manage deployments and versions
- Monitor execution and telemetry
- Manage missions
- View results and workload status
Interface concepts shown for illustration
Built for developers
Bring your own software.
You don't need us to write your algorithms. Develop your software, package it as a workload and deploy it into a supported execution environment — subject to validation and authorization.
# workload.manifest
name: cloud-mask
version: 0.4.2
runtime: orbital-py3.11
profile: gpu-a
data: eo-multispectral-v2
resources:
cpu: 4 · gpu: 1 · storage: 8GB
# validated → authorized → deployed
Customer-owned workloads
Your software stays yours. Package it, deploy it, iterate on it.
Defined execution environments
Supported runtimes and data profiles — no ambiguity about what runs.
Versioned deployments
Every deployment maps to a specific, authorized workload version.
Resource-aware execution
CPU, GPU and storage allocated within declared envelopes.
Controlled access to data
Workloads receive governed access to the inputs they need.
Security & control
Built for controlled execution in orbit.
Running third-party software on space infrastructure demands discipline. The platform is designed around validation, authorization and observability at every stage.
Workload validation
Every workload is checked against compatibility and policy requirements before it can fly.
Authorized & versioned software
Only reviewed, authorized workload versions are eligible for deployment.
Controlled resource allocation
CPU, GPU and storage are assigned within declared envelopes — no silent overreach.
Isolated execution environments
Workloads run in contained environments separated from the platform and each other.
Traceability & observability
Execution status, telemetry and results are visible throughout the workload lifecycle.
SpaceNet provides
- Orbital compute platform & Mininode hardware (CPU/GPU)
- SpaceNet Forge & SpaceNet Helm applications, running on our infrastructure
- GitHub integration — your code builds on our micros
- Observability APIs — telemetry, execution status, results
- Prepared execution environments for your software
The customer operates
- Forge & Helm — you manage missions, simulations and PRO usage
- What your software does on the satellite — logic, behavior, outputs
- Orbit corrections & maneuvers your mission requires
- Your data, models and how results are used
- Compliance of your workload with your own requirements
Security mechanisms
Get in touch
Ready to bring computing to orbit?
Whether you're building space infrastructure, developing orbital applications or exploring new ways to process spaceborne data — let's talk.
Discuss a pilot mission
Exploring a concrete use case? Tell us about your data profile and processing needs — we'll assess workload compatibility together.
Partnerships & investment
We work with satellite operators, technology partners and investors building the next layer of space infrastructure.