What Lovable, Bolt, v0, Base44 Use Under the Hood

Picking an AI app builder is half about the chat experience and half about what you'll be holding when the chat ends. The second half tends to get glossed over in launch posts. So when someone searches "what does Lovable actually use under the hood?" and lands on a comparison piece that won't actually tell them, that's a small failure of the internet I'd like to fix.

Here's what each of the popular ones actually runs, in plain terms. No "powered by AI" handwaving, no "modern web technologies." If a builder hands you a codebase, what's in it. If it doesn't, what's running on the other side instead.

Quick read (one line each)

• Lovable: Vite + React and modern CSS in the browser, Supabase as the default backend, GitHub sync if you want the code.
• Bolt.new: StackBlitz WebContainers, which is actual Node.js running in your browser tab. Framework is whatever you ask for; it'll do Vite, Astro, SvelteKit, a full React framework, anything.
• v0: Vercel's own React framework + React Server Components + shadcn/ui. Output is component code you paste into your own project.
• Base44: closed runtime. Your app lives inside their platform; you don't get a web project, you get an app that runs on Base44.
• WebTwizz: a standard React and TypeScript web app with server rendering, full source export, runs on isolated VMs while you build, and ships to Vercel when you publish.

The headline difference: Lovable, Bolt, v0 and WebTwizz all hand you real React/real code at some point. Base44 doesn't. That's not a value judgment, it's a category difference, and it changes everything about migration, lock-in, and what happens if the builder shuts down tomorrow.

Lovable

Framework: Vite + React + TypeScript, with no server rendering framework on top. The app you generate runs as a single-page React app served by Vite.

Backend: Supabase, by default. Database, auth, storage, and edge functions all roll through the Supabase project Lovable provisions. You can connect your own Supabase later, but the happy path is the one they wire up.

Where the app actually runs while you're building it: Lovable hosts a live preview at a Lovable subdomain. The iframe you see in the editor is rendering against a real deployed instance of your app, not a sandbox. That's why the preview loads in seconds and reflects real database state.

Code ownership: Connect a GitHub repo and Lovable pushes commits as you go. The repo is a normal Vite + React and modern CSS project, so anyone with React experience can clone it and keep building. Lovable's deploy pipeline gets bypassed at that point; you're just running a Vite app.

What this means in practice: if you're used to a server-rendered React framework you'll notice missing pieces. No SSR. No file-based page routing. SEO needs more work. For interactive apps that don't need server-rendered SEO (dashboards, internal tools, login-gated SaaS), Vite is fine. For marketing sites and content-heavy apps, the lack of SSR shows up. The longer take on Lovable's editing model lives in the WebTwizz vs Lovable comparison.

Bolt.new

Framework: whatever you ask for. The default new project tends to be Vite + React and modern CSS, but Bolt will scaffold Astro, SvelteKit, Remix, full server-rendered React frameworks, even Bun servers, basically anything the WebContainer runtime can boot.

Where the app runs while you're building: this is the unique one. StackBlitz built WebContainers, a way to run Node.js inside the browser tab using WebAssembly. When you scaffold a web project in Bolt, you're not running it on a Bolt server. Your laptop is running the dev server, in your tab, locally. That's how the preview is instant and why Bolt can let you mess with literally any package on npm.

Backend: there isn't a default. You wire whatever you want: Supabase, Firebase, your own backend, mock data, an in-memory store. Bolt's flexibility cuts both ways: you can do anything, but the AI doesn't have a strong opinion, so you have to.

Code ownership: the project lives in a StackBlitz container that you can fork to your own account, export as a zip, or push to GitHub. The output is just standard files for whichever framework you picked.

The catch: WebContainers are a wonderful trick, but they're not the same as a real cloud machine. Some npm packages with native bindings won't install. Long-running processes get killed when the tab closes. Memory ceilings exist. For prototyping the answer is "doesn't matter, it works." For shipping production-grade apps you'll move out of the in-browser environment before launch. There's a head-to-head on Bolt's editing model in the WebTwizz vs Bolt writeup.

v0

Framework: Vercel's own React framework + React Server Components + shadcn/ui. v0 is by Vercel; the bias is intentional and tight.

What it actually outputs: components. v0 isn't a full app builder despite the marketing inching that direction. You describe a UI ("a pricing page with three tiers, monthly/annual toggle, a feature comparison table"), v0 generates a self-contained React component, and you copy-paste it into your existing web project. There's no project scaffolding, no database integration, no auth flow you can run as-is.

Why this matters: v0's output is shockingly good if you already have a codebase. The generated components use shadcn/ui primitives (which means they look professional out of the box), they're proper React Server Components where appropriate, and they drop into a modern React app on that framework cleanly. v0 isn't competing with Lovable or Bolt; it's competing with "you opening Figma, then translating Figma to code by hand."

Where it falls down: if you're starting from zero and you want a full SaaS with auth and database, v0 alone can't do that. You'd need to bring your own project scaffolding, Supabase or Auth.js, your own Stripe wiring, and use v0 to fill in the UI surface. That's a real workflow if you're a developer; it's a non-starter if you don't already write code. Non-coders should look at the non-coder roundup instead.

Base44

Framework: proprietary. Base44 doesn't generate a Vite project or any other code project you'd recognize. Your app runs on Base44's runtime, served from Base44's domain (or a custom domain you point at them). Internally there's a React-shaped UI layer and a managed backend, but you don't see it as a project tree the way you do with the others.

Backend: built into the platform. Tables, auth, file storage, and external integrations are all configured through Base44's interface, not by editing code. There's no "the Supabase part" or "the Stripe part" you can swap; it's all part of the same product.

Code ownership: this is the part to be honest about. As of writing, Base44 doesn't hand you a web project on a USB stick. Your app exists as a Base44 app. If Base44 changes course, raises prices, or shuts down, migrating is more involved than running git clone and pointing it at Vercel. You'd be re-implementing the app on a different platform.

Why people pick it anyway: the abstraction is the point. For a non-technical founder shipping an internal tool or a niche SaaS, "I never have to think about frameworks, deployment, auth setup, or DNS" is genuinely valuable. The same closed runtime that worries developers is what makes Base44 feel approachable to people who don't want to learn what an env var is. Side-by-side detail on the trade-off lives in the WebTwizz vs Base44 page.

WebTwizz

Framework: a standard React and TypeScript web app with server rendering. The generated project is the same starter a developer would set up by hand, plus the components and pages the AI built for you.

Where the app runs while you're building: each project gets a dedicated isolated VM running three processes: a preview proxy, a sync server, and the app's dev server. The preview iframe in the builder is rendering against that real running app, with hot reload over WebSockets. Edits in the visual editor sync to a virtual filesystem that the VM reads from.

Backend: bring your own. Supabase is a one-click integration (OAuth, no key copying), Stripe ditto, Resend for email. The AI knows about these and wires the right env vars in when you ask for, say, "add Stripe checkout." If you'd rather use Firebase or your own API, that works too.

Code ownership: full source export, any time. WebTwizz hands you a complete web project zip, the same files you'd get if a human dev built it. Drop it in any Vercel/Netlify/self-host setup and it runs.

Where this puts it: closer to v0 in terms of stack opinion (React with server rendering, Tailwind, shadcn-flavored components) but closer to Lovable in terms of "the AI builds the whole app, not just components." The visual editor on top of the same source tree is the bit that's harder to replicate elsewhere. The full head-to-head against the rest of the field lives in the Lovable vs Bolt vs v0 vs WebTwizz comparison.

The matrix