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 use under the hood, Next.js or Vite?" 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 + Tailwind 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 Next.js, Vite, Astro, SvelteKit, anything.
• v0: Next.js App Router + React Server Components + Tailwind + 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 Next.js project, you get an app that runs on Base44.
• Webtwizz: Next.js App Router + TypeScript + Tailwind, 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/Next.js 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 + Tailwind. Not Next.js. 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 + Tailwind 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 Next.js you'll notice missing pieces. No SSR. No App Router. No page.tsx conventions. 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 + Tailwind, but Bolt will scaffold Next.js, Astro, SvelteKit, Remix, 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 Next.js project in Bolt, you're not running it on a Bolt server. Your laptop is running Next.js, 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: Next.js App Router + React Server Components + Tailwind + 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 Next.js 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 Next.js 14+ app 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 Next.js 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 Next.js. Non-coders should look at the non-coder roundup instead.

Base44

Framework: proprietary. Base44 doesn't generate Next.js or Vite or anything 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 Next.js 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 Next.js, 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: Next.js App Router + TypeScript + Tailwind. The generated project is what you'd get from npx create-next-app, 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 Next.js dev. The preview iframe in the builder is rendering against that real Next.js instance, 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 Next.js 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 (Next.js, 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

Why "what's it use" actually matters

For a weekend project, none of this matters. Pick whichever's chat is most pleasant; you'll throw the project away in a month either way.

For anything you might keep around, three things become real:

1. Migration cost when you outgrow the builder. Lovable, Bolt, v0, and Webtwizz all give you code you can take to a regular dev team and keep building. Base44 you'd need to rebuild. There's a version of this that's fine. Small businesses on Wix don't ever migrate, and that's the bargain. But you should walk in knowing which bargain you're making.

2. SEO and SSR. Marketing sites, content sites, anything where Google needs to render your pages, want server-side rendering. That's Next.js or one of its competitors. Vite SPAs (Lovable's default) can do SSR with extra setup but it's not what you get out of the box. If you'll have a homepage that needs to rank, this matters more than the chat UX.

3. The AI's blind spots come from the stack. A builder that defaults to Vite + React isn't going to write you Next.js Server Actions. A builder that defaults to a closed runtime isn't going to teach you how middleware works. The boundaries of what the AI is good at line up with the boundaries of the stack it ships in.

Pick the stack first, then judge the AI on whether it does that stack well. Doing it the other way around is how people end up with a beautiful Lovable app that they can't make rank on Google, or a v0 component library with no app to put it in.

A note on what's not here

Cursor and Replit Agent are great tools and people sometimes lump them in with this list. They're not the same shape of product. Cursor is an editor that wraps an AI; the stack is whatever you write in. Replit Agent ships full apps but the Replit hosting environment is its own beast, more like Base44 in shape than like Lovable. Builder.io and Tempo aim at design teams. The five in this post are the ones you actually pick between when you're trying to ship "describe an app, get the code or the running thing." The wider field is covered in the 11-builder roundup and a real-world benchmark of all of them lives in the "can AI actually build a real app" test.