GitHub Codespaces vs Modal VM Sandboxes
GitHub Codespaces gives a developer a ready VS Code environment for a GitHub repository. It keeps files between stops and stops after 12 hours at most. Modal VM Sandboxes give your code VMs with their own kernel and Docker, for up to 24 hours per run. Your code carries work forward with a filesystem snapshot or a Volume.
The companies and products
GitHub Codespaces
GitHub Codespaces is GitHub's cloud development environment: a ready-to-code Linux machine for a repository, opened in the browser, VS Code or the GitHub CLI.
Codespaces is a different kind of product from boat: a dev environment for people who work on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config. It runs on its own newly built VM on Azure, with 2 to 32 cores. It is built for developers and teams who want every contributor to start from the same setup, with prebuilds, port forwarding and GitHub billing.
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026. It suits teams that want many agent machines next to Modal's inference and training.
- Funding
- Over $1.2B raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Compliance
- SOC 2 on every plan; HIPAA on Enterprise
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “290th cheapest of 365” means 289 of the other 364 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | GitHub Codespaces: price rank | Modal VM Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A codespace stops at 12 hours and documents no /dev/kvm. Modal VM runs Docker in a VM; you set up a desktop from its computer-use example and carry files forward with filesystem snapshots. This preset costs $633 a month on Modal VM against $634 on boat, which has the desktop built in and saves its disk with no code. | 290th of 365, with limits $4,618 a month | 27th cheapest of 365 $633 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB A codespace stops after 12 hours at most. A Modal VM run stops at 24 hours; your code snapshots the filesystem and boots a new sandbox, and running programs start again. On boat, turn auto-stop off on a paid plan (default 1 hour). | 320th of 361, with limits $6,970 a month | Not ranked: misses a requirement | 6th cheapest of 361 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs suit Modal's fast starts and per-second billing better than a codespace, which builds a dev container on a new VM each time. On boat each start counts against the plan's start cap. | 283rd of 336, with limits $619 a month | Not ranked: misses a requirement | 189th of 336, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Modal Team runs up to 5,000 containers at once. GitHub does not publish how many codespaces can run at once, so 300 user sandboxes are not confirmed there. boat runs 100 to 2,000 at once by plan. | 276th of 349, with limits $1,964 a month | Not ranked: misses a requirement | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 276th of 349, with limits $9,489 a month | 163rd of 349, with limits $11,982 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 295th of 359, with limits $1,519 a month | Not ranked: misses a requirement | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month All three run Docker builds. Android emulators need /dev/kvm: Codespaces does not document it, Modal offers it on the Enterprise plan only as an experimental option, and boat has it on every sandbox. | 317th of 374, with limits $909 a month | 170th of 374, with limits $655 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Codespaces is the closer fit for a human dev box, with VS Code per repo and a disk kept across stops, but it stops after 12 hours. A boat sandbox runs all month once auto-stop is off. | 144th of 371, with limits $270 a month | Not ranked: misses a requirement | 19th cheapest of 371 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month A codespace can add a basic noVNC desktop through the desktop-lite add-on. Modal's runnable example installs Xvfb, x11vnc, noVNC, Chromium and a Browser Use agent. boat streams a built-in 60 fps desktop with computer tools. | 297th of 367, with limits $1,367 a month | Not ranked: misses a requirement | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 306th of 356, with limits $678 a month | Not ranked: misses a requirement | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 324th of 343, with limits $922 a month | Not ranked: misses a requirement | 6th cheapest of 343 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 279th of 327, with limits $18,637 a month | Not ranked: misses a requirement | 73rd of 327, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Modal boots many copies from one filesystem snapshot. Codespaces creates every copy again from the repository. boat forks a running sandbox from its disk, and each fork counts as a start. | 284th of 351, with limits $445 a month | 27th cheapest of 351 $464 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | GitHub Codespaces | Modal VM Sandboxes | boat |
|---|---|---|---|
| Isolation | A Docker container on its own newly built VM, with its own virtual network | VM with its own Linux kernel on Cloud Hypervisor | Full VM with its own kernel, on boat's own AMD Ryzen 7 9700X and Ryzen 9 9950X hosts; shared vCPUs |
| How you use it | Opened from a repo, branch or pull request in VS Code, the browser, JupyterLab or the GitHub CLI | Created from Python, TypeScript or Go code with runtime="vm" | API, SDK and CLI to create, fork, stop and run commands, plus a desktop stream |
| CPU benchmark (V8 Web Tooling, 4 vCPU / 8 GB, StarSling run of 3 October 2026) | Not in the public benchmarks we use | 15.48 runs/s (VM runtime, measured with cpu=4), rank 7 of 15 (shared) | 28.06 runs/s, rank 2 of 15 (shared), on a Ryzen 9 9950X host |
| Longest session | 12 hours at most, even while in use; stops after 30 idle minutes by default | 24 hours (default 5 minutes); continue in a new sandbox from a filesystem snapshot | No cap once auto-stop is off on a paid plan; auto-stop defaults to 1 hour, up to 30 days |
| Files after a stop | Kept, with storage billed; processes end; stopped codespaces are deleted after 30 days by default | No paused state. Your code takes a filesystem snapshot (kept 30 days by default, or with no expiry) and boots a new sandbox from it, or keeps files in a Volume | Disk saved every minute and at each stop with no code; resume is like a reboot; kept at least 14 days, longer with a saved snapshot |
| Docker, root, systemd | Docker and sudo inside the dev container | Docker, systemd and root; you start dockerd yourself as the entrypoint | Docker, root and systemd in every sandbox |
| Nested virtualization | /dev/kvm is not documented | Enterprise plan only, as an experimental option | /dev/kvm on every sandbox |
| Copies and snapshots | No copy or snapshot endpoint; new codespaces start from a repo or a prebuild | Snapshot a running sandbox's filesystem and boot any number of new sandboxes from it; memory snapshots are alpha | Fork a running sandbox from its last 1-minute disk snapshot; saved snapshots as templates; no memory snapshots |
| Desktop and computer use | VS Code, JupyterLab and a terminal; a noVNC desktop through the desktop-lite add-on, which you configure | Not built in. You set it up: Modal's runnable example installs Xvfb, x11vnc, noVNC, Chromium and a Browser Use agent | Built-in desktop and Chrome at 1920x1080 and 60 fps, with computer tools for agents |
| Disk | 32 GB to 128 GB by machine type; storage billed per GB-month | Fixed 512 GiB root filesystem on VMs | 51 GB on 2 and 4 vCPU sizes, up to 251 GB; fixed per size |
| Coding agents and API keys | GitHub Copilot as a VS Code extension; secrets copied in as environment variables | You install the harness in the image (official examples); a credential-injecting proxy in a Sidecar (experimental), from an official example | Seven harnesses installed with a prompt, steer and events API; optional key proxy ($1 a day while on, plus $1 per 1,000 requests) |
| Reaching the machine | A URL per forwarded port, plus SSH and CLI tunnels; no public IP | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | Up to 50 HTTPS URLs per sandbox, token-protected by default; SSH; raw ports over IPv6 on sandboxes with no IPv4 of their own |
| Outbound network rules | Open internet; GitHub says there is no way to restrict it | Block all, IP-range allowlist, domain allowlist (beta) | Open internet; no provider-side allowlist |
| Regions | US East, US West, Europe West and Southeast Asia, same price in each | US, EU and Asia-Pacific plus narrower regions; pinning costs 1.15x to 1.75x | Germany, Finland and France; you cannot pick one; no US or Asia region |
Every feature Battleships tracks (43)
| Feature | GitHub Codespaces | Modal VM Sandboxes | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Not published | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Yes | Yes |
| Desktop GUI | With your own setup | With your own setup | Yes |
| Browser | No documented way | With your own setup | Yes |
| Computer-use API | No documented way | With your own setup | Yes |
| SSH | Yes | With your own setup | Yes |
| Persistent disk | Yes | With your own setup | Yes |
| Pause/resume | Yes | No documented way | Yes |
| Automatic snapshots | No documented way | No documented way | Yes |
| Fork/clone | No documented way | Yes | Yes |
| Live fork (no pause) | No documented way | Not published | Yes |
| Memory fork | No documented way | Yes | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | No documented way | Yes | Yes |
| Idle auto-stop | Yes | Yes | No documented way |
| Wake on request | No documented way | No documented way | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No documented way | Yes | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | No documented way | Yes | No documented way |
| Secret proxy | No documented way | With your own setup | Yes |
| Secret proxy for any API | No documented way | No documented way | Yes |
| Preinstalled agents | No documented way | With your own setup | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | No documented way | No documented way | No documented way |
| GPU | No documented way | No documented way | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | No documented way | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | No documented way | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No documented way | Not published | Yes |
| Audit logs | Yes | Yes | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | No documented way | Yes | No documented way |
| EU data residency | Yes | Yes | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's run of 3 October 2026 (run 37073680030), the V8 Web Tooling Benchmark at 4 vCPU / 8 GB did 28.06 runs/s on boat (second of 15) and 15.48 on Modal's VM runtime (rank 7, shared). That is about 1.8x. On the Better-Auth repo in the same run, boat took 135.8 s and Modal VM 180.8 s. StarSling ran Modal with cpu=4, and the sandbox saw 4 CPUs (PR #121); sized that way, Modal bills 4 cores, $0.76/h, not the 2-core $0.476/h list price used on this page. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Providers ran on different hardware in different regions. GitHub Codespaces is not in the public benchmarks we use, so we cannot say how it compares.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Modal VM Sandboxes measured on: VM Sandbox, request = size. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. GitHub Codespaces is not in the public benchmarks we use, so we cannot say which is faster.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario. Start limits, per-start fees and plan minimums are in the price, boat's included.
| Scenario | GitHub Codespaces, a month | Modal VM Sandboxes, a month | boat, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $51 · Personal account: GitHub Free | $0 · Starter | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $270 · Personal account: GitHub Free · with limits | $109 · Starter · with limits | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $3,019 · Personal account: GitHub Free | $1,480 · Starter | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $850 · Personal account: GitHub Free · with limits | $579 · Team | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $1,889 · Personal account: GitHub Free · with limits | $1,911 · Team · with limits | $8,800 · $2000/mo · with limits |
GitHub Codespaces: Codespaces bills $0.09 per core-hour while a codespace is active, used or not, plus $0.07 per GB-month of storage while it exists, stopped too. There is no 4-core machine with 8 GB, so 4 vCPU / 8 GB jobs are priced on the 4-core 16 GB machine. Personal accounts get a free monthly quota, and organizations do not.
Modal VM Sandboxes: Modal bills VM Sandboxes per second, for the larger of the CPU and memory you request and what you use, until the sandbox ends. Modal prices CPU per physical core, and one core equals 2 vCPU, so 4 vCPU / 8 GiB is $0.476 an hour when the request equals the size. Starter costs $0 with $30 of credit a month, and Team $250 a month with $100 of credit. Pinning a region multiplies the price by 1.15x to 1.75x. The scenario bills use Modal's lowest documented setup, a minimal request that bursts on use; that burst CPU is not guaranteed.
Modal VM Sandboxes: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. Unused time does not carry over. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs, busy or idle. A stopped sandbox has no compute charge, and boat keeps its disk for at least 14 days. Saved snapshots above the included count and the optional AI credentials proxy still charge while sandboxes are stopped. The $20 plan includes 12 starts a minute, 60 an hour and 200 a day; create, fork and resume each count as one start, and an extra start costs $0.03 to $0.07. A card is required, also for the 7-day trial.
Limits in those scenarios
Neither fits the always-on scenario as-is: a codespace stops after 12 hours, and a Modal VM run stops at 24 hours and needs a filesystem snapshot and a new sandbox each day. GitHub does not publish how many codespaces can run at once, so 300 user sandboxes and 1,000 short jobs are not confirmed there. Modal fits the workday and 50-agent scenarios when your code snapshots the filesystem or uses a Volume between sessions. For 1,000 short jobs at once, Modal's Team bill assumes shared burst CPU that is not guaranteed. boat's limits: auto-stop defaults to 1 hour, and each plan caps starts. For that burst, even the $2,000 plan needs paid extra starts and refuses starts above 270 a minute, so boat does not fit. boat has no US or Asia region.
| Scenario | GitHub Codespaces | Modal VM Sandboxes | boat |
|---|---|---|---|
| One coding agent, workdays | None for this scenario | None for this scenario | None for this scenario |
| One agent that never stops |
|
| None for this scenario |
| 50 agents in parallel |
| None for this scenario | None for this scenario |
| Sandboxes for your users |
| None for this scenario | None for this scenario |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use GitHub Codespaces when
your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, that keeps their files between work sessions.
- Built into GitHub. Useful if your team lives on GitHub: open a codespace from any repo, branch or pull request, with the dev container set up.
- A disk that survives stops with no code. Useful for people who come back each day: a stopped codespace keeps its files and installed packages until you restart it.
- Free hours for personal accounts. Useful for occasional personal work: a GitHub Free account includes 120 core-hours and 15 GB-month of storage each month.
Use Modal VM Sandboxes when
your code launches huge bursts of jobs that finish within a day, needs raw TCP, a big disk, strict outbound rules or regions outside Europe, or already runs models on Modal.
- Very large bursts. Useful for huge bursts of short jobs: Modal runs 5,000 containers at once on Team, with fast starts and per-second billing.
- Network features and a big disk. Modal VMs offer raw TCP tunnels, an inbound IP allowlist, outbound domain rules and a 512 GiB root filesystem.
- One platform with inference and training. Useful if you already serve or train models on Modal: sandboxes and models sit on one account and one bill.
Where boat fits
A codespace stops at 12 hours, and a Modal VM run stops at 24 hours. If your agents work for hours or days on a machine they come back to, with Docker, emulators and a desktop, boat gives them a full VM that saves its disk with no code. It has no session cap once auto-stop is off on a paid plan (default 1 hour).
Disk saved with no code
A codespace stops at 12 hours even while in use, and its processes end. On Modal your code takes a filesystem snapshot and boots a new sandbox, or uses a Volume. boat saves the disk every minute and at each stop. A boat resume is like a reboot.
/dev/kvm and a built-in desktop
Codespaces documents no /dev/kvm, and Modal offers it on the Enterprise plan only, as an experimental option. On both you set up a desktop yourself, from a dev container add-on or Modal's example. boat has /dev/kvm and a 60 fps desktop on every sandbox.
Agents driven from outside
On both, you install the agent harness and script it yourself. Secrets sit in environment variables, or on Modal you run a proxy in a Sidecar. boat ships seven agents with a prompt API, and an optional paid proxy that keeps supported providers' keys outside.
Use boat when your agents work for hours or days in a machine they come back to: installs, builds, tests, Docker, emulators and a desktop, on a VM that saves its disk with no code. Turn auto-stop off on a paid plan for long work (default 1 hour). Compare it one to one: boat vs GitHub Codespaces and boat vs Modal VM Sandboxes.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
Questions people ask
Is GitHub Codespaces cheaper than Modal VM Sandboxes?
Mostly no. One agent on workdays is $0 on Modal Starter (inside its $30 credit) against $51 on Codespaces. 50 agents in parallel are $1,480 against $3,019, and 300 user sandboxes $579 against $850. For 1,000 short jobs, Codespaces costs $1,889 and Modal Team $1,911 on shared burst CPU; neither is confirmed to fit. boat costs $20, $317 and $200 for the first three, and does not fit the 1,000-job burst because of its start limits.
Which is faster, GitHub Codespaces or Modal VM Sandboxes?
Codespaces is not in the public benchmarks we use, so we cannot say. In StarSling's run of 3 October 2026, at 4 vCPU / 8 GB, Modal's VM runtime did 15.48 V8 Web Tooling runs/s and boat did 28.06 on a Ryzen 9 9950X host. boat does not promise a CPU model.
How long can each one run?
A codespace stops after 12 hours at most, even while in use, and after 30 idle minutes by default, but keeps its files. A Modal VM run lasts 24 hours at most, with a 5-minute default; a filesystem snapshot carries it into a new sandbox. boat has no session cap once auto-stop is off on a paid plan (default 1 hour).
Can Modal VM Sandboxes keep files between sessions?
Yes, when your code does it. A filesystem snapshot saves the whole root disk and is kept 30 days by default or with no expiry, and a Volume keeps one folder. A codespace keeps its files on stop with no code. boat saves the disk every minute and at each stop with no code, and keeps it at least 14 days, or longer with a saved snapshot.
Can I run Docker and Android emulators in each?
Both run Docker. Codespaces does not document /dev/kvm, and Modal offers nested virtualization on the Enterprise plan only, as an experimental option. Every boat sandbox has Docker, systemd and /dev/kvm.
Where do they run?
Codespaces runs in US East, US West, Europe West and Southeast Asia. Modal runs in the US, the EU and Asia-Pacific, and pinning a region costs 1.15x to 1.75x. boat runs on machines in Germany, Finland and France, and you cannot pick a region.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs GitHub Codespaces
- boat vs Modal VM Sandboxes
- E2B vs GitHub Codespaces
- Daytona vs GitHub Codespaces
- Modal vs GitHub Codespaces
- Vercel Sandbox vs GitHub Codespaces
- Cloudflare Sandbox vs GitHub Codespaces
- Blaxel vs GitHub Codespaces
- Runloop vs GitHub Codespaces
- Tensorlake vs GitHub Codespaces
- Morph Cloud vs GitHub Codespaces
- CodeSandbox SDK vs GitHub Codespaces