Daytona vs Namespace
Daytona is a cloud for running AI-generated code: containers by default, with Linux VM, Windows and GPU classes, and no default time limit. Namespace is mainly a CI and build platform. Its Devboxes are remote Linux and macOS machines for people and coding agents, and they stop after 3, 5 or 24 hours by plan.
The companies and products
Daytona
Daytona is a cloud for running AI-generated code: you create sandboxes from code through its API and SDKs.
By default a Daytona sandbox is a Linux container with its own namespaces and reserved vCPU, memory and disk. You can also pick a Linux VM class (pause, fork, memory snapshots, /dev/kvm), a Windows VM class, a GPU class with Nvidia and AMD cards, or macOS sandboxes in early access. It is built for teams that run agent code, code interpreters and evals through Python, TypeScript, Ruby, Go or Java SDKs.
Namespace
Namespace is a dev platform for fast builds, tests and coding environments: CI runners, build caches and Devboxes, on its own hardware.
Most of Namespace is CI: a faster drop-in for GitHub Actions runners, with Docker, Bazel, Turborepo and Nix caching. Its Devboxes are remote Linux and macOS machines with persistent storage, made for people and AI coding agents. You run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions, and Namespace also hosts sessions for Claude Managed Agents, Cursor Cloud Agents, Devin and Amp. It is a different kind of product from boat, so this page compares the part where they overlap: a machine an agent works on.
- Products
- GitHub Actions runners, Docker, Bazel, Turborepo and Nix caching, Devboxes, and a compute API
- Hardware
- Its own hardware in its own racks: AMD EPYC for Linux and Windows, Apple M4 Pro or M5 Max for macOS
- Linux Devboxes
- Run a container image you choose and include Docker; the docs do not say if each one has its own kernel
- Devbox time limit
- 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you work; support can raise it to 24 hours at most
- Devbox count limit
- Per user / per workspace: 1/3 on Developer, 3/30 on Team, 5/50 on Business and Devbox Plus; stopped Devboxes count
- Free trial
- 30-day Developer trial with no card
- Compliance
- Trust center lists SOC 2 Type II
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. “19th cheapest of 365” means 18 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 | Daytona: price rank | Namespace: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 19th cheapest of 365 $4,111 a month | 74th of 365, with limits $3,745 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Daytona fits because a sandbox can run with no deadline (31st). A Namespace Devbox stops at its plan's limit even while it works, so your code restarts it (316th, compromise). boat ranks 6th, with auto-stop off on a paid plan. | 31st cheapest of 361 $6,104 a month | 316th of 361, with limits $6,645 a month | 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 Daytona fits one-minute runs well (31st), creating hundreds of sandboxes a minute with no plan fee. Namespace caps Devboxes at 50 per workspace (244th), and boat's start limits make big bursts a compromise (189th). | 31st cheapest of 336 $271 a month | 244th of 336, with limits $250 a month | 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 All need more room: 300 sandboxes of 2 vCPU need 600 vCPU, more than Daytona's Tier 4 pool of 500 (153rd), and Namespace caps Devboxes at 50 per workspace (279th). boat ranks 3rd. | 153rd of 349, with limits $2,000 a month | 279th of 349, with limits $2,068 a month | 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 | 134th of 349, with limits $8,261 a month | 345th of 349, with limits $9,012 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 | 192nd of 359, with limits $2,000 a month | 282nd of 359, with limits $1,093 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Namespace fits (87th): CI runners with Docker, Bazel and Turborepo caches are its main product. Daytona caps a sandbox at 4 vCPU by default (309th, compromise). boat ranks 2nd and runs CI jobs on full VMs, but sells no managed runner. | 309th of 374, with limits $805 a month | 87th cheapest of 374 $765 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both are a compromise here: a Namespace Devbox stops when idle and wakes when you connect but stops at its plan's limit (201st), and Daytona needs a $500 top-up for open internet (200th). boat ranks 19th and stays up once auto-stop is off. | 200th of 371, with limits $245 a month | 201st of 371, with limits $250 a month | 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 Daytona fits with a VNC desktop and a computer-use API on Linux and Windows (29th). Namespace's screenshot and click API works on macOS Devboxes; on a Linux Devbox you install a desktop and VNC in your image (108th). boat ranks 7th with a 60 fps Linux desktop. | 29th cheapest of 367 $1,198 a month | 108th of 367, with limits $1,032 a month | 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 | 114th of 356, with limits $598 a month | 191st of 356, with limits $789 a month | 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 | 42nd cheapest of 343 $404 a month | 191st of 343, with limits $332 a month | 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 | 203rd of 327, with limits $8,073 a month | 225th of 327, with limits $9,012 a month | 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 | 18th cheapest of 351 $2,000 a month | 112th of 351, with limits $339 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 Only Daytona fits (19th): it rents Nvidia and AMD GPUs by the hour. Namespace and boat are CPU only. | 19th cheapest of 102 $1,190 a month | 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 Only Namespace fits (6th): it runs macOS Devboxes and instances on Apple Silicon. boat has no macOS, and Daytona's macOS sandboxes are in early access. | Not ranked: misses a requirement | 6th cheapest of 35 $1,255 a month | Not ranked: misses a requirement |
Key features
| Feature | Daytona | Namespace | boat |
|---|---|---|---|
| Isolation | Container with its own namespaces by default; Linux VM and Windows VM classes with a hardware virtualization boundary | Linux Devboxes run a container image; the docs do not say if each has its own kernel (StarSling reports Firecracker) | Every sandbox is a full VM with its own kernel; vCPUs are shared |
| CPU speed (V8 Web Tooling Benchmark, 4 vCPU / 8 GB, StarSling run of 3 October 2026) | 21.52 runs/s on the Linux VM class (shared rank 2); the default container class has no result | 24.90 runs/s (shared rank 2) | 28.06 runs/s, second of 15 (shared rank 2), on an AMD Ryzen 9 9950X host |
| Real-repo builds (Better-Auth / Mastra / OpenClaw, same run, seconds, lower is better) | 156.6 / 1,112 / 571 on the Linux VM class | 150.5 / 1,051 / 570 | 135.8 / 980 / 428 |
| How long a session can run | No deadline by default; an optional time limit you set yourself | Devboxes stop at 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you work; support can raise it to 24 at most | No cap once auto-stop is off on a paid plan (default 1 h, up to 30 days) |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Docker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or Windows | Docker, root, systemd and /dev/kvm on every sandbox |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | Screenshot and click API and VNC on macOS Devboxes; on Linux Devboxes you install a desktop yourself; VNC and RDP for compute instances | 1920x1080, 60 fps Linux desktop and Chrome, computer tools for agents, embeddable stream |
| Files after a stop | Whole disk kept and billed while stopped; containers auto-archive after 7 days stopped (free) | A stopped Devbox keeps its storage until you delete it, billed at $0.20 per GB-month used | Disk saved every minute and at each stop; no compute charge while stopped; kept at least 14 days, longer with a saved snapshot |
| Pause and fork | Linux VM and Windows: pause, resume and fork with memory kept; containers start new sandboxes from filesystem snapshots | No fork documented; compute instances suspend and resume with RAM kept | Fork a running sandbox from its last 1-minute snapshot; resume reboots from disk |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no public IP | HTTPS URLs that need a Namespace login; TCP through a running CLI port-forward; no public IP | Up to 50 HTTPS URLs, token-gated by default; SSH; public IPv6, and raw ports over IPv4 only on sandboxes with their own IPv4 |
| Outbound internet | Tier 1 and 2 reach only package registries, git hosts and AI APIs; Tier 3 ($500 top-up) and up get open internet plus domain or CIDR allowlists | Egress policies per Devbox blueprint, runner or instance: block, advisory or allow by domain | Open internet on every plan; no provider-side allowlist (firewall rules inside the VM) |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Egress rules inject a header from Namespace Vault, resolved outside the workload | Optional AI credentials proxy ($1 a day plus $1 per 1,000 requests) for model providers and HTTPS APIs you register |
| Coding agents | You set it up: guides install agents and run them through process exec | You run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions; hosts Claude Managed Agents, Cursor, Devin and Amp sessions | Seven harnesses preinstalled, with a prompt, steer and events API |
| GPUs | Nvidia and AMD GPUs, from RTX 4090 to B300, on-demand or preemptible | None; machine shapes are CPU only | None |
| Operating systems | Linux, Windows VM sandboxes, and macOS in early access | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only; Wine for Windows apps |
| Regions | US and EU, plus dedicated regions or your own machines (BYOC) | Several regions; keeping every workload in one region needs the Enterprise plan | Germany, Finland and France; no US or Asia region, no region choice |
Every feature Battleships tracks (43)
| Feature | Daytona | Namespace | boat |
|---|---|---|---|
| Full VM (own kernel) | No documented way | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | With your own setup | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | No documented way | Yes |
| Live fork (no pause) | No documented way | No documented way | Yes |
| Memory fork | Yes | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No documented way |
| Wake on request | No documented way | Yes | 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 | Yes | Yes | No documented way |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | Yes | No documented way | No documented way |
| Windows | Yes | Yes | No documented way |
| Arm64 | No documented way | Yes | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | Yes | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No documented way | Yes |
| Audit logs | Yes | Yes | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | No documented way | 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: boat did 28.06 runs/s, Namespace 24.90 and Daytona's Linux VM class 21.52. All three share rank 2 of 15, so the run cannot separate them. On real-repo builds in the same run (Better-Auth / Mastra / OpenClaw, total seconds), boat took 135.8 / 980 / 428, Namespace 150.5 / 1,051 / 570 and Daytona VM 156.6 / 1,112 / 571. Daytona's default container class has no result. StarSling does not name the Namespace product it tested, and a Devbox's vCPU count is a ceiling it can boost to. 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.
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. Daytona measured on: Linux VM sandbox (same rates; KVM / nested virt per-org feature). Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015). 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.
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 | Daytona, a month | Namespace, 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 | $56 · Tier 3 ($500 top-up) | $300 · Devbox on Business | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $245 · Tier 3 ($500 top-up) | $426 · Devbox on Business · 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 | $2,682 · Tier 3 ($500 top-up) | $2,448 · Devbox on Business | $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 | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $1,264 · Devbox Plus · with limits | $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 | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $3,287 · Devbox Plus · with limits | $8,800 · $2000/mo · with limits |
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, including while a sandbox starts or stops, and keeps billing the disk while it is stopped. You pay from a prepaid wallet with no plan fee and $200 of free compute: open internet needs a $500 top-up (Tier 3), and the biggest pool needs $2,000 every 30 days (Tier 4).
Namespace: Devboxes are billed in Devbox Minutes at $0.004 each; a 4 vCPU / 8 GB Devbox uses one a minute ($0.24 an hour). Pay as you go, or Devbox Plus at $250 a month for 50,000 minutes. Team ($100) and Business ($250) plan minutes do not cover Devboxes, but you need those plans for longer sessions and more Devboxes. Storage costs $0.20 per GB-month used, and new sign-ups get a 30-day trial with no card.
Namespace: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs. A stopped sandbox has no compute charge, but saved snapshots above the included count and the AI credentials proxy still charge. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07.
Limits in those scenarios
Daytona limits the total vCPU and memory running at once, up to 500 vCPU on Tier 4, so 300 sandboxes for your users and 1,000 short jobs at once need a custom limit, and Tiers 1 and 2 reach only an allowlist of services. Namespace's limits are time and count: a Devbox stops at 3, 5 or 24 hours by plan, so the agent that never stops restarts at least once a day, and Devboxes are capped at 50 per workspace on Business. Neither publishes an egress price. boat limits sandbox count and starts: the $2,000 plan includes 90 starts a minute and refuses starts above 270, so the 1,000-job burst does not fit there either.
| Scenario | Daytona | Namespace | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None for this scenario |
| One agent that never stops |
|
| None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Daytona when
your agents need GPUs, Windows, memory pause and fork, or sandboxes that run with no deadline in the US or the EU.
- GPUs by the hour. Useful if your agents train or test models: Daytona rents Nvidia and AMD GPUs by the hour, and Namespace has none.
- No clock on the sandbox. Useful for agents that run for days: a Daytona sandbox has no deadline by default, while a Namespace Devbox stops after 3 to 24 hours by plan.
- Pause and fork with memory. Useful if a sandbox must come back exactly where it was: Daytona's VM classes pause and fork with memory kept.
Use Namespace when
you need macOS machines, faster GitHub Actions runners with build caches, or Devboxes for people that stop when idle.
- macOS on Apple Silicon. Useful if your agents build iOS or Mac apps: Namespace runs macOS Devboxes on Apple M4 Pro and M5 Max chips with Xcode.
- CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel and Turborepo caching.
- Idle stop and egress rules. Useful for people's dev boxes: Devboxes stop when idle, start on connect, and can be limited to chosen domains.
Where boat fits
If what you are really running is coding agents on Linux for hours or days, look at boat. It gives every agent a full VM with no session cap once auto-stop is off, Docker and /dev/kvm, a 60 fps desktop, and coding agents you drive from outside. Pick Daytona for GPUs or Windows and Namespace for macOS or CI runners.
A full VM for every agent
A Daytona sandbox is a container with its own namespaces unless you pick its VM class and get KVM turned on. Namespace's docs do not say a Devbox has its own kernel, and /dev/kvm is on compute instances, not Devboxes.
CPU work in one public run
In StarSling's run of 3 October 2026, boat did 28.06 runs/s, Namespace 24.90 and Daytona's VM class 21.52. All three share rank 2, so the run cannot separate them. On the real-repo builds in the same run, boat took the least time on all three repos. The boat sandbox ran on a Ryzen 9 9950X host, and boat does not promise a CPU model.
Agents built in, driven from outside
On Daytona you install each agent and run it as a process; on Namespace you run it in a Devbox session, or a partner runs it. boat ships seven harnesses with a prompt, steer and events API.
Use boat when your agents work on Linux for hours or days: a full VM with no session cap once auto-stop is off, Docker and /dev/kvm, a 60 fps desktop, and coding agents you drive from outside. Compare it one to one: boat vs Daytona and boat vs Namespace.
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 Daytona cheaper than Namespace?
For long sessions, usually yes, because an 8-hour Devbox session needs Namespace's Business plan. One coding agent on workdays comes to $56 a month on Daytona and $300 on Namespace Business. One agent running all month is $245 against $426, and on Namespace it restarts every 24 hours. 50 agents in parallel are $2,682 against $2,448. On boat those three come to $20, $26 and $317.
Which is faster, Daytona or Namespace?
In StarSling's run of 3 October 2026 at 4 vCPU / 8 GB, Namespace did 24.90 runs/s and Daytona's Linux VM class 21.52; boat did 28.06. All three share rank 2, so the run cannot separate them. Daytona's default container class has no result.
Can Daytona and Namespace run Docker?
Yes. Daytona runs Docker in all its classes, and Namespace includes Docker in Linux Devboxes. For /dev/kvm, Daytona needs its Linux VM class with KVM turned on for your organization, and Namespace offers it on Linux compute instances. boat has Docker, systemd and /dev/kvm on every sandbox.
Can a sandbox run 24/7 on Daytona or Namespace?
On Daytona, yes: a sandbox has no deadline by default and auto-stop can be turned off. A Namespace Devbox stops at 3, 5 or 24 hours by plan, even while you work in it, and support can raise it to 24 hours at most. On boat, auto-stop defaults to 1 hour; turn it off on a paid plan and there is no session cap.
Which one has GPUs or macOS?
Daytona rents Nvidia and AMD GPUs by the hour, runs Windows VMs, and has macOS in early access. Namespace runs macOS on Apple Silicon and Windows on Team plans and up, but has no GPUs. boat runs Linux only, with Wine for Windows apps.
Is boat SOC 2 compliant?
SOC 2 is in progress; boat has no SOC 2 report today. Daytona's Trust Center lists a SOC 2 Type II report, and Namespace's trust center lists SOC 2 Type II. Live status is at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial