Universe-native infrastructure

Ignite runtimes. Hold orbit. Command the fleet.

Spin up isolated microVM sandboxes in ~180ms — on hardware you own. Like Modal or Daytona, but your servers, your data, your bill.

Get started free See how it works
Currently in private beta · Request access →
Boot
~180ms
TLS
policy-driven
Runtime
on-request

Products: sun · sky · particle · stars

sky
the substrate: surfaces, layout, clarity
particle
motion + data: telemetry, activity, flow
stars
discovery: navigation, tags, wayfinding
sun
authority: policies, primaries, source of truth
Powering in production
WHO IT'S FOR

Pick your orbit.

◎
SOLO DEV / HOMELAB

Run your own infra at home or on a VPS. Full control plane, no cloud bill. Provision microVMs from your laptop, serve real traffic, pay nothing to a vendor.

  • Personal projects with real uptime
  • Local GPU inference, zero cloud cost
  • Self-hosted everything
◎
STARTUP / SMALL TEAM

Skip the AWS bill shock. Own your compute, keep your data, stay fast. Deploy dozens of services without Kubernetes complexity or a platform engineer.

  • No vendor lock-in, ever
  • One control plane, any hardware
  • Scale on your own terms
◎
AI / INFERENCE WORKLOADS

Run LLMs and inference pipelines without a GPU tax. CPU-first by default, connect your own GPU cluster when you need acceleration. Your models, your hardware.

  • CPU inference out of the box
  • Bring your own GPU cluster
  • Ephemeral or persistent runtimes
◈ PRIVACY FIRST your data never leaves your infra
◈ DATA SOVEREIGNTY you own every byte
◈ 100% OWNERSHIP subscription is control plane only
◈ MEMORY SAFE Rust-native orchestration
HOW IT WORKS

How it works.

Three steps from zero to production. No Kubernetes. No DevOps hire.

Step 01
Deploy
Push your code or select a pre-built runtime. One command — microVM boots in ~180ms.
Step 02
Connect
Attach a domain, TLS issues automatically. Expose services internally or publicly.
Step 03
Scale
Set autoscale policies, monitor metrics, manage the fleet from your dashboard or CLI.
WHY SUN

Own the stack.
Not just the bill.

sun
Modal / Daytona
Kubernetes
AWS Lambda
You own the infra
✓
✗
✓
✗
Sub-second cold start
~180ms
~300ms
minutes
~100ms*
Kernel-level isolation
microVM
container
container
container
No per-request markup
✓
✗
✓
✗
Data stays on your hardware
✓
✗
✓
✗
Zero-ops control plane UI
✓
✓
✗
partial

* AWS Lambda cold starts vary widely by runtime and memory allocation.

-->

Constellation Map

Capabilities are not cards. They are stars: connected, navigable, and stateful.

sun
policy core
Domains + SSL
certs by policy
Runtime Policy
on-request control
Build Worker
fast, calm queues
Observability
telemetry streams
Projects Canvas
diagram you can move
Billing + Credits
metered, explicit
AI INFERENCE

One click.
Your own AI endpoint.

Deploy small language models on your own CPU — get back an OpenAI-compatible API endpoint. No GPU bill, no rate limits, no third-party data exposure. Use it anywhere the OpenAI SDK works.

CPU_FIRST

Small Language Models on CPU

Quantised SLMs run efficiently on any compute node — no GPU required to start. Deploy Qwen, Phi, Mistral, or Llama variants and get a live, private endpoint in seconds. Your models. Your hardware. Your data never leaves.

Qwen 1.5B Phi-3 Mini Mistral 7B Q4 Llama 3.2 1B + more
0
GPUs required
to start
① Deploy
▶ sun deploy llm/qwen-1.5b
pulling model layer ok
allocating microVM ok
loading runtime ok
issuing TLS cert ok
◉ live · qwen.my-infra.sun.run
→
② Use — OpenAI SDK compatible
from openai import OpenAI
client = OpenAI(
base_url="https://qwen.my-infra.sun.run/v1",
api_key="sun-xxxx",
)
resp = client.chat.completions.create(
model="qwen-1.5b",
messages=[{"role": "user",
"content": "Hello!"}]
)
∞
clusters you
can connect

Optional GPU Clusters

When you need raw acceleration — connect your own. Local GPU rigs, your own cloud fleet, or a hybrid. You bring the hardware, sun handles the orchestration and routing.

GPU_OPTIONAL
ACCESS LAYER

Two ways in.
Zero friction.

MODE_01

No-code Interface

Visual canvas. Wire apps together without touching a terminal. Deploy, scale, and route — from your browser.

┌─────────────────────────────────┐
│ [ postgres ] ──▶ [ api ] │
│ │ │
│ ▼ │
│ [ cache ] │
│ │ │
│ ┌───────┘ │
│ ▼ │
│ [ expose :443 ] │
└─────────────────────────────────┘
OR
MODE_02

Chat Interface

Natural language ops. Ask your infrastructure what's happening. Tell it what to do. It understands context.

▶ how many containers are running?
12 containers across 3 groups.
api-prod (healthy), worker-queue (healthy),
cache (healthy) ...
 
▶ scale api-prod to 4 replicas
✓ api-prod scaling 2 → 4
✓ new replicas healthy in 0.8s
 
▶ █
AGENT CLOUD

Your own private
agent runtime.

Run AI agents the way you run containers — isolated, monitored, networked. One-click install for popular agent frameworks. Persistent memory, tool access, and inter-agent networking inside your own infra.

sun — agent capacity
sun capacity
 
agents (sorted by cpu):
node-eu-1 healthy=true cpu=12.4% mem=38.1% disk=22.7%
node-eu-2 healthy=true cpu=31.0% mem=61.5% disk=45.2%
node-home-gpu healthy=true cpu=78.3% mem=52.0% disk=33.8%
 
3 agents · 0 unhealthy█
◈
Persistent or ephemeral
Long-running agents with persistent memory, or burst agents that spin up per task and vanish.
◈
Tool & sandbox access
Agents can invoke sandboxes, read project files, and call internal services — all within your network.
◈
Inter-agent networking
Group agents into projects. They communicate over an internal bus. Nothing external unless you route it.
SANDBOX

Instant environments.
Zero setup.

Like Modal or Daytona — but you own the infra. Spin up an isolated, reproducible sandbox in under a second. Run untrusted code, test pipelines, prototype ideas. Destroy it when you're done.

ISOLATED
Every sandbox is its own microVM
Full kernel isolation. No container escape risk. Each environment is a clean slate.
EPHEMERAL
Lives as long as you need it
Set a TTL or destroy on exit. Pay zero for idle time. Boot again in milliseconds.
REPRODUCIBLE
Snapshot and restore any state
Checkpoint a running environment. Replay it exactly. Share it with your team.
NETWORKED
Internal routing out of the box
Sandboxes inside a project group talk to each other. Nothing leaks out unless you expose it.
$ sun sandbox run python:3.12 --ttl 30m --isolate → sandbox-a3f9 · ready in 0.4s
BUILD PIPELINE

Push code.
It ships.

A Vercel-like build and runtime pipeline — for JS, TS, and beyond — running on your own infra. Git push triggers a build. Build produces an artifact. Artifact deploys to a microVM. Done.

⌥
GIT PUSH
any branch · any provider
──▶
⚙
BUILD
npm · bun · deno · custom
──▶
◫
ARTIFACT
versioned · cached · bit-packed
──▶
⬡
DEPLOY
microVM · TLS · live URL
──▶
◉
LIVE
preview URL · or production
SUPPORTED RUNTIMES
Node.js Bun Deno Python Rust Go + any Dockerfile
APP LAYER

One click.
Secure container.
Online.

Every app launches inside its own isolated microVM. Networking is internal by default. Nothing is exposed unless you say so.

nginx postgres redis mysql python-app node-server llm-runner ollama minio + your app
$ sun install postgres --group my-project --ephemeral
✓ postgres · microVM provisioned · internal:5432 · ready in 0.6s
Launch your first container →
RUNTIME LAYER

Built for zero waste.
Engineered for precision.

sun — runtime status
$ sun status --capabilities
 
[ ✓ ] ON-DEMAND ONLY       no idle server reservation — pay for what runs
[ ✓ ] PERSISTENT / EPHEMERAL choose runtime mode per container, per deploy
[ ✓ ] COLD START           sub-second boot from absolute zero
[ ✓ ] BIT-LEVEL PACKING    space optimisation at the block level
[ ✓ ] MEMORY SAFE RUNTIME  Rust containers — no memory unsafety
[ ✓ ] PROJECT GROUPS      namespace containers for isolated internal networking
 
6 capabilities active · 0 issues detected█
WEBASSEMBLY

Deploy WASM.
One click.

WebAssembly modules run natively — no container overhead, no cold start penalty. Drop a .wasm file, click deploy. It's live, sandboxed, and isolated. The smallest possible runtime footprint.

<5ms
cold start
~0
overhead
KB
footprint
Drop .wasm → instant live endpoint
Memory-safe sandbox — Rust WASM runtime
Scale to zero, start in microseconds
Compatible with WASI and component model
wasm deploy
sun deploy my-module.wasm
 
validating wasm module ok
allocating microVM slot ok
loading wasm runtime ok
issuing TLS certificate ok
routing traffic ok
 
◉ live · my-module.sun.run · 3.1ms cold start
MOBILE CONTROL

Launch a VM from
your phone.

Full mission control in your pocket. Provision a temporary VM on the go — run a quick task, share a demo link, spin up an agent — then tear it down when you're done. No laptop required.

◎
Temporary by default
Set a duration. VM self-destructs. Zero cleanup.
◎
Shareable live URL
Instant public URL for the duration of the VM. Share with anyone.
◎
One tap to destroy
Tap destroy. MicroVM gone. No residual cost.
Sun Shell
ws-3f9a
ws-c12b
+ ⚙
[session created for dep-3f9a (vm-08a1)]
root@vm-08a1:~# ls
app/ logs/ .env
root@vm-08a1:~# sun capacity
agents (sorted by cpu):
  node-eu-1 healthy=true cpu=12.4%
root@vm-08a1:~# █
WORKSPACES
vm-08a1
dep-3f9a · running
Launch Session →
vm-c12b
dep-a77f · idle
+ New VM
ALPHA TESTERS

From the launchpad.

"We replaced a €400/mo DigitalOcean setup with a single €40 VPS running sun. Same throughput. Way more control."
MK
Mikael K.
Founder, stealth AI startup
"The 180ms boot time is real. We run untrusted code sandboxes for our product — sun is the only thing that actually isolates at the kernel level without Kubernetes overhead."
RP
Rahul P.
CTO, developer tools company
"Finally a platform that feels like it was built by engineers, not by a growth team. Policies I can read, metrics I can trust."
SL
Sara L.
Platform engineer, fintech
QUICKSTART

From zero to running
in four commands.

01
Install the control plane
curl -fsSL https://sun.run/install | sh
Installs the sun CLI and starts the local control plane daemon.
▼
02
Provision a microVM
sun vm create --name my-node --size micro
Boots a memory-safe Firecracker microVM in under a second.
▼
03
Deploy an app
sun install postgres --group my-project
Pulls, isolates, and wires the container into your internal network.
▼
04
Expose to the world
sun expose my-project/api --domain app.example.com
TLS issued, domain routed, traffic flowing. Done.
PRICING

Own the infra.
Subscribe to the intelligence.

Your servers, your data, your bill from your hardware provider — not us. We charge only for the control plane that orchestrates it all.

YOUR INFRA
$0 to us

Your hardware. Your VPS. Your cloud account. You pay your provider directly — we never touch that money.

  • Any bare metal or VPS
  • Any cloud provider
  • Your own GPU cluster
  • Local homelab hardware
+
CONTROL PLANE
Free during beta

The sun control plane: orchestration, routing, TLS, build pipeline, observability, autoscale, and the web UI.

  • Unlimited microVMs
  • Unlimited project groups
  • No-code + chat interfaces
  • SSL, domains, autoscale
Get early access →
No per-seat pricing. No egress fees. No surprise invoices.
EARLY ACCESS

Be first on the launchpad.

sun is in private beta. Drop your email and we'll reach out when your slot opens.