A free AI app builder without coding that starts your VM before you type
Every free AI app builder promises no signup and no credit card. Most still make you wait thirty seconds for a sandbox to cold boot after you hit build. mk0r starts warming a real cloud VM the moment this page loads, so when you finish typing your idea, a sandbox is already waiting in a pool with your name on it.
The part nobody else is honest about
“No code” and “no signup” are cheap promises. Every builder in this category makes them. The part that matters for a non-coder is what happens in the fifteen seconds after you click Build. If you are staring at a spinner, the promise is empty.
A sandbox VM is not free to boot. A fresh E2B micro-VM takes roughly 2 to 6 seconds for the guest kernel, plus another 5 to 15 seconds to initialize the ACP agent bridge, spawn a Vite dev server, install npm dependencies from the base image, and expose a public preview URL. You can hide some of that with a loading screen. You cannot hide all of it.
mk0r's answer is to not boot it when you ask. We boot it before you ask.
The anchor fact
There is a Firestore collection in mk0r's production database called vm_pool. Each document represents either a VM that is currently booting (status: "warming") or one that is finished booting and ready to hand out (status: "ready"). When you open mk0r.com, the landing page fires a POST to /api/vm/prewarm before you have even moved your cursor.
The ping that happens before you type
This is the line in the landing page source that makes the whole thing work. It runs inside a useEffect with an empty dependency array, so it fires exactly once on mount and never blocks rendering. The response is ignored. The side effect is what matters.
The endpoint on the other end counts how many ready and warming entries exist for the current sandbox spec hash, subtracts from the target pool size, and spawns fresh sandboxes for the deficit. Nothing waits. The HTTP response returns immediately with a status snapshot.
The claim, as your browser sees it
When you finish typing and hit build, mk0r does not boot a sandbox. It tries to claim one. Here is the actual order of operations.
Claim flow
The Firestore transaction is the trick. Two tabs cannot claim the same sandbox: the transaction reads a ready doc and deletes it in one atomic step. The loser falls through to a cold boot; the winner gets a URL that is already serving Vite hot-module replacement.
Watch the pool live
The prewarm endpoint also accepts GET requests and returns the live pool state. Here is what a healthy pool looks like a few seconds after the landing page loads for a new visitor.
Why this matters for a non-coder
If you have never written software, the difference between a builder that feels alive and one that feels broken is entirely about the first twenty seconds. A spinner during a cold boot reads as “this is slow” or “this is not working,” and the idea you were going to type evaporates.
what stays out of your way
- No account creation. No email. No password reset.
- No credit card, no free-trial timer, no paywall mid-build.
- No onboarding tour. No drag-and-drop palette to learn.
- No cold-boot spinner, because the VM is already warm.
- No vendor lock-in: you get real HTML or a real React project.
From landing to running app
Everything the user does is on the left. Everything mk0r is doing on your behalf is on the right. Notice that steps 1 and 2 happen in parallel: mk0r is already working before you have finished thinking.
1. You open mk0r.com
Your browser fires POST /api/vm/prewarm on mount. A session UUID is written to localStorage so you can come back later without signing in.
2. The pool starts warming (while you read the page)
prewarmSession() boots an E2B sandbox, runs ACP initialize with the shared Anthropic key, calls session/new, sets the model, and writes a doc to the vm_pool Firestore collection with status=ready.
3. You type your app idea
Plain English. One sentence. No syntax. No palette. mk0r figures out whether Quick mode (single HTML) or VM mode (full React project) fits the request.
4. A Firestore transaction pops a ready doc
claimPrewarmedSession reads one doc matching the current spec hash and deletes it atomically. You win the race with any other tab. The loser cold-boots; you do not wait.
5. ACP reinitializes with your credentials
The sandbox was booted with mk0r's shared key. On claim, /acp/initialize is called again with whatever key or OAuth token belongs to you. The ACP bridge detects the fingerprint change and respawns the Claude agent inside the VM.
6. Your preview URL streams into the page
You see the app take shape in an iframe as Vite hot-reloads. Edit with follow-up prompts in the same chat window. No deploy step; the preview URL is already public on the mk0r wildcard subdomain.
7. The pool refills for the next visitor
void topupPool() fires after your claim succeeds (e2b.ts:1047). The next person to land on mk0r.com gets the same head start you got.
How mk0r compares to the usual free AI app builder
| Feature | Typical free builder | mk0r |
|---|---|---|
| Account required | Yes, email + verify | No, anonymous session UUID in localStorage |
| Credit card | Often required for the free trial | Never, not even for VM mode |
| Time to first build | 20 to 60 seconds of cold boot after build | Pre-warmed claim, near-instant after prompt |
| Infrastructure for “instant” | Loading screen + retries | Firestore-backed pool of ready sandboxes |
| Collision handling | N/A (one VM per session on demand) | Firestore transaction; only one visitor wins each ready doc |
| Output format | Proprietary editor JSON | Plain HTML or a real Vite + React + TypeScript project |
| Browser testing | Manual, in your own browser | Playwright agent inside the sandbox (VM mode) |
Pool math in one glance
The four numbers that govern the whole system. All four are configurable via environment variables on the Cloud Run service, and all four are verifiable in src/core/e2b.ts.
A 15 minute gap between pool expiry and sandbox death is deliberate. If we let a pool doc live the full hour, a visitor could claim a sandbox with only seconds of life left. Expiring at 45 minutes guarantees anyone who claims from the pool has at least a quarter hour of runway on their E2B VM.
What kinds of apps this unlocks
A free no-code AI app builder with instant start is not just faster; it is a different product. Here is what starts to make sense when there is zero boot wait and zero account.
Classroom demos
A teacher opens mk0r on the projector and a student types “a multiplication drill that uses my name.” No school-district IT approval for new accounts. No cold boot killing attention.
Idea tests over coffee
You describe an app to a friend. Instead of “I could see that working,” you build it right there on your phone while they watch. The pool makes it feel native, not hosted.
Onboarding a non-technical teammate
Share the link. No seat to buy, no workspace to create, no invite email. They land, they build, they send back a preview URL.
Throwaway internal tools
A form, a calculator, a spreadsheet visualizer. The kind of thing nobody wants to justify a Bubble account for. Quick mode emits a single HTML file you can drop anywhere.
Frequently asked questions
Is mk0r actually free, with no credit card?
Yes. You open mk0r.com, type your idea, and the app starts building. No email, no password, no card, no trial timer. An anonymous session UUID is written to your browser's localStorage so you can return to the same sandbox later. Paid plans exist if you want more generations, project persistence, or longer-running VMs, but the full build flow is reachable without signing up.
How is a real cloud VM ready so quickly without coding?
mk0r keeps a Firestore-backed pool of already-booted E2B sandboxes. The landing page sends a POST to /api/vm/prewarm on mount, which tops the pool up to its target size. When you claim a sandbox by typing a prompt, a Firestore transaction atomically pops one ready doc and hands you the hot URL. The pool then refills for the next visitor. No code on your end.
Which AI model writes the code?
Quick mode streams a single self-contained HTML/CSS/JS file from Claude Haiku and renders it in a live iframe as it is written. VM mode puts a Claude agent inside the E2B sandbox with Vite, React, TypeScript, and Playwright available; the agent writes files, runs the dev server, and drives a real browser for tests. You pick neither. You type, mk0r decides.
How long do pre-warmed sandboxes last?
Pool entries are valid for 45 minutes from creation (POOL_MAX_AGE_MS = 45 * 60 * 1000 in src/core/e2b.ts). The underlying E2B sandbox lives for 1 hour, so mk0r expires pool docs 15 minutes early to leave headroom for your session. Stale entries are killed and swept from Firestore on the next topup.
What happens if two visitors try to claim the same sandbox?
They cannot. claimPrewarmedSession runs inside a Firestore transaction that reads a ready doc and deletes it in one atomic step (src/core/e2b.ts:1957). Whoever wins the transaction gets the sandbox. The loser falls through to a fresh cold boot, and the pool is refilled for the next visitor.
Do I own the code my app generates?
Yes. Quick mode emits plain HTML, CSS, and JavaScript. VM mode produces a real Vite + React + TypeScript project on disk in the sandbox, which you can download. No proprietary format, no runtime lock-in, no Bubble-style vendor layer on top of your data.
What kinds of apps does a pre-warmed VM unlock that a cold one would not?
Anything where the wait kills the idea. Quick throwaway tools (dice rollers, tip splitters, unit converters) are fine on a cold boot, but an AI app builder for non-coders lives or dies on first-impression latency. Pre-warming takes VM mode from a 20 to 40 second cold boot down to a near-instant claim plus ACP re-init. Good for demos, classroom settings, and any 'watch me build this live' moment.
Type a sentence. Claim a ready sandbox.
A VM is probably warming right now for the next visitor. Be that visitor.
Or skip the animation and start typing now
No account, no card, no boot wait.