Skip to content
devX
parthkapoor-dev
devex
...
Featured on
Product Hunt
–

Starting a workspace copies a template to S3, applies a Kubernetes Deployment, Service and Ingress, restores your files into the pod and attaches a terminal over a WebSocket.

A real machine,one tab away.

DevEx is an open-source cloud IDE. Every workspace is its own Linux container on Kubernetes — a code editor, a real terminal and a public URL in your browser, with files that are still there tomorrow.

$ start a workspace watch the demo
  • 0:devex*
  • Open source · MIT
  • Node.js & Python templates
  • Open source
  • Self-host on your cluster
  • Monaco editor
  • A real PTY terminal
  • Public URL for any port
  • Files persist to S3
  • MCP server for agents
  • Kubernetes native

Not a playground

01What you actually get

  • Shell01

    A real shell

    A PTY into your own container. Install packages, run servers, background jobs, Ctrl-C — nothing is simulated.

  • Disk02

    A real filesystem

    Your files live on the container's disk, not in browser storage, and sync to S3 when the workspace stops.

  • Port03

    A public URL

    Start a server on any port and it is reachable from the internet. Share it, hit it from your phone, point a webhook at it.

  • State04

    Still there tomorrow

    Close the tab and the pod's resources go back to the cluster. Come back next week and your files are exactly where you left them.

02The workspace

Editor, terminal, public URL. All in the same tab.

This is the layout you land in once a workspace is running: files on the left, Monaco in the middle, a shell and port forwarding below. Click around — switch files, flip the panel.

devex / apirunning
import { serve } from "./server"
 
// one container, one session
const port = 3000
 
serve({ port }, () => {
  console.log(`up on :${port}`)
})
connected:3000

Not a video — click a file, or collapse the panel.

03Why bother

You already have an editor. What you don’t have is the machine.

Four times a container beats the laptop you are sitting at.

Onboard01

Day one, not week one

A new contributor opens a link and gets the same Node, the same Python, the same env vars as everyone else.

Review02

Their branch, not your laptop

Open a second workspace on someone's pull request instead of stashing your own work to make room.

Ship03

A URL, not a repo

Start the server, hand over the address. It works from a phone, and from a webhook.

Offload04

Off the fans

A long install or a hungry file watcher runs on the cluster. Your battery never notices.

Not for: GPUs, privileged containers, or anything that has to outlive the tab.

04How it works

A pod, a PTY and a bucket.

No image build on the critical path and no VM to wait for. Four things happen between the click and the prompt, and none of them are yours to manage.

  1. 0s

    You pick a template

    Core copies the Node.js or Python template into object storage under your account and records the workspace.

    POST /api/repl/new → s3://…/<you>/<id>/
  2. ~0.2s

    Kubernetes takes over

    A Deployment, a Service and an Ingress are applied. The scheduler places the pod; the runner image is usually already cached on the node.

    apply deploy · svc · ingress → Pending
  3. 10–20s

    The runner attaches

    The container pulls your files down and forks a PTY. Your browser connects over WebSockets straight to it, through the Ingress.

    wss://…/<id> → pty attached · fs synced
  4. on stop

    Your work syncs back

    Changed files are pushed to storage and the pod's CPU and memory go back to the cluster. Nothing runs while you are away.

    diff → s3 put → resources released

05Your stack

whatever your stack needs

  • Node.js
  • TypeScript
  • Next.js
  • Bun
  • Go
  • Rust
  • Python
  • FastAPI
  • Django
  • PostgreSQL

Start from the Node.js or Python template. It is a real Linux container, so the rest is one install away.

06Open source

Yours to run, and your agent’s to use.

Self-host

Run it on your own cluster

MIT-licensed and provider-agnostic. A Kubernetes cluster with one public node, an S3-compatible bucket and Redis is enough — no cloud load balancer.

~/devex
git clone github.com/parthkapoor-dev/devex. helm install traefik traefik/traefik \. -f infra/k8s/traefik-values.yaml. kubectl apply -f infra/k8s/cert-issuer-production.yaml
Self-hosting guide

MCP

Give an AI agent a real machine

Point Claude Code, Cursor, or any MCP client at a running workspace and it reads the files you have open — the real ones, on the container's disk. read_file ships today; writes and run_command are next.

mcp · /mcp/<repl-id>
tools/call read_file {"path": "src/index.ts"}. import { serve } from "./server". const port = 3000
MCP server docs

07Pricing

Start free. Scale when you do.

Every plan runs the same containers on the same cluster. What changes is how many you get at once, and how much you can ask of each.

Free

Enough to keep a side project alive.

$0

forever, no card

Start coding
Workspaces
2
CPU each
125m
Memory each
256Mi
Persisted
200MB
  • Every base template
  • Public port forwarding
  • Community support
ProfessionalMost popular

A workspace per branch, warm and waiting.

$15/ month

billed monthly

Go professional
Workspaces
25
CPU each
1250m
Memory each
2.5Gi
Persisted
15GB
  • Premium template library
  • GitHub Actions integration
  • Usage analytics
  • Priority support
Enterprise

Our sandboxes, running inside your product.

$99/ month

billed monthly

Talk to us
Workspaces
Unlimited
CPU each
Custom
Memory each
Custom
Persisted
Unlimited
  • Sandbox SDK access
  • 10k API requests/hour
  • Custom integrations
  • SLA and a named contact

Self-hosting is free and always will be — bring your own cluster and none of the above applies.

08Questions

The ones worth asking first.

Everything below is answered in more depth in the documentation. These are the short versions.

What is DevEx?

DevEx is an open-source cloud development environment. It schedules a container on Kubernetes and gives you a browser tab with a code editor, a terminal attached to that container's shell, and a file tree backed by persistent storage.

Is DevEx free?

The Free plan costs nothing and needs no card: two workspaces, 125m CPU and 256Mi memory each, 200MB persisted. Self-hosting is free without limits — the source is MIT-licensed and the deployment is documented.

Do my files survive a restart?

Yes. A workspace's filesystem is synced to S3-compatible object storage and restored when the workspace starts again, so stopping one does not lose work.

Can I reach a server running inside a workspace?

Yes. Ports opened inside the container are forwarded to a public URL, so a dev server or an API you started in the terminal is reachable from anywhere without a tunnel.

Can an AI agent use a DevEx workspace?

Partly, today. An optional MCP server can run beside a workspace, so an assistant reads the same files you are editing over the Model Context Protocol. It exposes read_file now; writing files and running commands are planned.

Can I self-host DevEx?

Yes. DevEx needs a Kubernetes cluster, a Redis instance and an S3-compatible bucket. The self-hosting guide covers the manifests, the environment variables and the runner image.