The open source Lovable alternative you can self-host, rebrand and resell
Last updated
Creable is a free, MIT-licensed open source Lovable alternative. Describe an app in a chat box, watch an AI agent build a real full-stack Next.js application with its own database in a live preview, then publish it to a public URL with hosting, auth, file storage and a custom domain.
Free to start. The first 50 AI credits are on us.
git clone https://github.com/totalumlabs/lovable-alternative.git
cd lovable-alternative
npm install
cp .env.example .env.local # then set TOTALUM_VCAAS_API_KEY=tlm_sk_...
npm run dev # http://localhost:3000Quick answer: what is the best open source Lovable alternative?
The best free and open source Lovable alternative is Creable, an MIT-licensed AI app builder you can self-host, rebrand and resell, with hosting, a database, auth and custom domains included through a single API key. It reproduces the Lovable workflow of prompt, preview, iterate and publish, but the builder itself is source code you can host on your own servers, restyle, put your own brand on and sell to your own customers.
- Free and MIT licensed, so you can use it commercially and resell it.
- Self-hostable anywhere Next.js runs: Vercel, Docker, Railway, Render, Fly.io or a plain VM.
- Generated apps are server-rendered full-stack Next.js with an integrated database, not client-side React bundles.
- Hosting, database, auth, deploys, custom domains and GitHub sync come from one Totalum API key, so there is no second vendor to wire up.
- Designed to be white-labelled and embedded, so an agency or a SaaS can offer the whole builder under its own brand.
- The main alternatives are Creable, dyad and bolt.diy for open source, and Bolt.new, Replit, v0 and Base44 for hosted closed-source builders.
Why people look for a Lovable alternative
Almost nobody leaves because the prompting is bad. They leave when the thing they want to do next, own it, change it, or sell it, turns out not to be on the menu.
| The Lovable trade-off | What Creable does instead |
|---|---|
| You rent the builder, priced per message, inside someone else's product. | The builder is MIT code on your own server. Usage is billed by the API, with 50 free credits to start and no per-seat fee. |
| No self-hosted Lovable exists. | Runs anywhere Next.js runs: Vercel, Docker, a VM, Railway, Render, Fly.io. |
| You cannot change the chat, the editor or the publish flow. | Every screen is source code you can edit. Rename it, restyle it, remove features, add your own. |
| You cannot offer Lovable to your customers under your brand. | White-label and multi-tenant by design. Sell it, or embed it inside your SaaS. |
| Generated apps are client-rendered React by default. | Generated apps are server-rendered Next.js with a real database, better for SEO and for AI search. |
None of this makes Lovable a bad product. It is a hosted tool that is very good at getting a polished interface out of a sentence, and if that is the job, it does it. The trade-off only starts to hurt when the app has to keep growing after the demo: when it needs a backend you control, a deployment story you own, or a second customer who wants the same thing under a different name. That is the point at which an open source Lovable alternative stops being a philosophical preference and starts being the cheaper option.
The best Lovable alternatives in 2026, compared
Lovable alternatives fall into three groups: hosted builders that work like Lovable, local open source tools that you run yourself with your own model keys, and builders you can self-host and resell. The table below sorts the main options by what they actually give you after the app is built.
| Tool | Type | Open source | Hosting and database included | You can resell it | Best for |
|---|---|---|---|---|---|
| Creable (this repo) | Self-hostable builder | MIT | Yes, one key | Yes | Running or reselling your own AI app builder |
| Lovable | Hosted, closed | No | Yes | No | Fast prototypes inside a hosted product |
| Bolt.new | Hosted, closed | No | Partial | No | Quick browser-based full-stack prototyping |
| Replit | Hosted, closed | No | Yes | No | An all-in-one collaborative workspace with an agent |
| v0 by Vercel | Hosted, closed | No | Bring your own | No | Design-forward React and Next.js interfaces |
| Base44 | Hosted, closed | No | Yes | No | Non-technical users shipping internal apps |
| dyad | Local desktop app | Apache 2.0 with FSL terms | Bring your own | No | Privacy and using your own model keys |
| bolt.diy | Local, self-hosted | MIT | Bring your own | Possible | Maximum model flexibility |
| open-lovable | Local tool | MIT | Bring your own | Possible | Cloning an existing website into React |
dyad is the most popular open source option in this list, and it is the right pick when you want everything local: it runs as a desktop app against your own model keys, nothing leaves your machine that you did not send, and you host whatever you build yourself. bolt.diy sits close to it with the widest model choice of any of them. If privacy or model flexibility is the deciding factor, start there rather than here. The same three projects are the ones that come up whenever Lovable alternatives are discussed on Reddit, and all nine tools are compared in detail with current prices in our full round-up.
The other thing the table shows is that most Lovable dev alternatives are a hosted product you rent. Lovable, Bolt.new, Replit, v0 and Base44 are all good at what they do, and for a solo prototype the rented model is often the sensible trade. What separates Creable is the column on the right of it: you can host it, rebrand it and sell it, because the builder is MIT code rather than a subscription.
What you get in the open source Lovable alternative
Every capability below works out of the box on one API key. There is no Supabase project to create, no Vercel account to connect and no model keys to hold.
Prompt to app
Describe the product in a chat box and an AI coding agent writes a complete full-stack Next.js application, interface, server routes and data model included.
Live preview
Watch the app run while it is being built, in a desktop or phone viewport, with a route picker for jumping straight to the page you care about.
Visual click-to-edit
Click an element in the preview and the edit is written back to the exact file and line that produced it. Desktop browsers only.
Code editor
A Monaco editor over every generated file, so you can read the code, change it by hand, save and rebuild without leaving the builder.
Integrated database
Every project gets a managed database with a browsable, editable table UI: filters, linked records and file uploads included.
Auth and storage
Generated apps get authentication, file storage and secrets of their own, so a real product does not stall at the login screen.
One click publish
Publish to a public HTTPS URL in about three minutes. There is no hosting account to open and no build pipeline to configure.
Custom domains
Attach your own domain from the builder, with guided DNS steps and a live status readout while the records propagate.
GitHub two-way sync
Connect a repository and move code in both directions, so a generated project can live in your own version control from day one.
Figma import
Import a Figma frame and have the agent build from the design rather than from a written description.
Version history with diffs
Every agent run is a restorable checkpoint, with a diff viewer showing exactly which files that run touched.
Logs
Development and production logs with search, so a failing request inside a generated app is something you can actually read.
Secrets
Per project secrets are stored for you and made available to the generated app at runtime rather than being pasted into its source.
Export, import and duplicate
Export a project, import it back, or duplicate it as the starting point for the next one. This is what turns a good build into a template.
Prompt attachments
Attach images, PDFs and SVGs up to 8 MB each, or paste a screenshot straight into the composer with Cmd or Ctrl and V.
Multi-tenant projects
One isolated project per user or per customer, which is what makes reselling the builder practical rather than theoretical.
How to build your own Lovable from this repo
The builder is a thin client. All the heavy machinery, the coding agent, the sandboxes that run generated apps, the hosting, the databases, the deploys, the custom domains, the GitHub sync and the logs, lives behind one API and arrives with one key. The repository is the interface and the proxy in front of it, which is roughly six thousand lines you can read in an afternoon.
That is why turning this into a commercial product of your own is a checklist rather than a rewrite. Seven steps, in order, with the exact files each one touches.
- 01
Clone it and run it
Start with the repository running on your own machine, before you decide anything about branding or billing. You need Node 20 or newer and nothing else installed globally.
Open http://localhost:3000, type what you want to build, and watch the agent work. Five minutes in you will know whether the workflow is the one you want to sell.
git clone https://github.com/totalumlabs/lovable-alternative.git cd lovable-alternative npm install cp .env.example .env.local # then set TOTALUM_VCAAS_API_KEY=tlm_sk_... npm run dev # http://localhost:3000Build me a client portal with invoices
CreableProject createdDatabase readyBuilding screensAsk for a change - 02
Get one API key
Create an account on the Totalum API page and choose "Use the Totalum API" during onboarding, then copy the key. The first 50 AI credits are free, so the first apps cost nothing to build.
Put it in .env.local as TOTALUM_VCAAS_API_KEY. That single key covers the coding agent, the sandboxes, hosting, the databases, deploys, custom domains and GitHub sync for every app anyone builds with your copy of the builder.
The key is read in exactly one server-only file, src/lib/vcaas-server.ts, and never reaches the browser.
.env.localsrc/lib/vcaas-server.tsThe key is created on the Totalum API page, and the quickstart walks the same path from the API side.
Platform readyCoding agentSandbox and previewHosting and databaseenvTOTALUM_VCAAS_API_KEY=tlm_sk_ - 03
Put your brand on it
No component hardcodes the product name. Everything reads from src/lib/brand.ts, which holds the name, the tagline, the prompt placeholder, the meta title and description and the links.
Swap the mark and the wordmark in src/components/brand/Logo.tsx, replace src/app/icon.svg for the favicon, and set your palette in the theme tokens in src/app/globals.css.
That is the whole rebrand: one file plus two assets. It is deliberately the shortest step on this list.
src/lib/brand.tssrc/components/brand/Logo.tsxsrc/app/icon.svgsrc/app/globals.css - 04
Add sign-up and login
The repo ships with no authentication on purpose, so nothing gets in the way of the first run. Add the provider you already use, Supabase, Clerk, Better Auth or your own, then make the two guards real.
In src/app/api/vcaas/_shared.ts, resolveVcaasContext() should return 401 when there is no user, and enforceProjectScope() should return 403 when the requested project does not belong to that user. Both are stubs today.
Then protect the pages listed in src/proxy.ts. Until you do this, every route is public and the app acts on one API key.
src/app/api/vcaas/_shared.tssrc/proxy.tsUntil this step is done, the app has no login, every route is public and the whole thing acts on one API key. Running it locally or on a private network like that is fine. Putting it on the open internet for real users is not.
resolveVcaasContext() 401 with no userenforceProjectScope() 403 off-scopesrc/proxy.ts protected pages - 05
Tie every project to a user
Store a projects(project_id, user_id) row whenever a project is created, and check it on every proxied /projects/:id path. Filter the home page listing to the caller's own rows so nobody sees anyone else's work.
Each project is already isolated on the platform side, with its own database, its own sandbox and its own deploy. This mapping is the only tenancy work you have to do yourself.
projects project_id text primary key user_id text indexed created_at timestamptzprojects project_id, user_idGET /projects caller rows onlyPlatform side one database per project - 06
Add billing and meter credits
Add Stripe Checkout, then credit the user's balance on checkout.session.completed and invoice.paid, keyed idempotently on the event id so a replayed webhook cannot double-credit an account.
Gate the spend-shaped paths with a 402 when the balance is empty: agent/start, projects/launch, deployments/deploy, rebuild, domain and files/*. Everything else can stay open to a signed-in user.
The agent status response reports the credits a run actually spent, so you can meter per prompt and price above your cost rather than guessing at a flat monthly number.
POST /projects/launch 402 when balance = 0 POST /projects/:id/agent/start 402 when balance = 0 POST /projects/:id/deployments/deploy POST /projects/:id/rebuild POST /projects/:id/domain POST /projects/:id/files/*POST/projects/:id/agent/startbalance 0 creditsstripe checkout.session.completed402 top up to continue - 07
Deploy it
It is a standard Next.js app with no special build step. On Vercel, import the repository, add TOTALUM_VCAAS_API_KEY as an environment variable and deploy.
On any Node host, npm run build and npm start is the whole story. Docker, Railway, Render, Fly.io and a plain VM all work the same way.
npm run build npm startWorth repeating at the moment it matters most: do not deploy this publicly before step 4 is real. The guards in
src/app/api/vcaas/_shared.tsand the protected pages insrc/proxy.tsare what stand between your API key and the open internet.builder.yourbrand.comYour builderServicesTeamBlogContactYour brandDescribe your appPrompt, preview, publish. On your domain.Get startedBook a demo
Covered by the one key, for every app your users build
Doing this for an agency or an existing SaaS?
We run a white-label program with reseller pricing, so the platform cost behind every app your customers build is priced for someone selling it on.
How it works under the hood
Four boxes and one key. The request path is short enough to hold in your head, which is the reason the customisation checklist above is short too.
One file on each side
Every Totalum call leaves the browser through src/lib/vcaas.ts and enters the platform through /api/vcaas/*. Two files to read, two files to change if you want to intercept, log or meter anything.
Long work is asynchronous
Agent runs and deploys do not block. You start them, then the interface polls status every 10 to 15 seconds and streams the result into the preview as it lands.
The preview is same-origin
The visual editor needs same-origin access to the running app, so while a project is open it is served through /api/preview/{projectId} rather than straight from its public URL.
The whole API surface is published: the full API reference as one Markdown file is written to be pasted into a coding agent, and the documentation covers the same endpoints with worked examples. If you would rather start from a neutral, unbranded edition of the same builder, the sister repository ai-app-builder-open is the white-label twin of this one.
Better SEO than Lovable: server-rendered Next.js with the database built in
Most AI app builders, Lovable included, generate a client-rendered single page React app. What actually ships is an empty HTML shell and a JavaScript bundle: the content only exists after the browser has downloaded, parsed and executed that bundle. Crawlers can render JavaScript, but they do it on a second pass, on a budget, and AI search engines summarising your page are often working from the first response alone. An empty shell is a bad first response.
Creable generates full-stack Next.js instead, and the difference shows up in four places.
Complete HTML in the first response
Pages are server-rendered, so a crawler or an assistant receives the finished markup, headings and copy included, without executing anything.
Real metadata per page
Per-page titles and descriptions, Open Graph tags, canonicals and a sitemap, generated as part of the app rather than bolted on afterwards.
Fast by default
Streaming, code splitting and image optimization come with the framework, and those are precisely the things Core Web Vitals rewards.
The database is part of the app
Listings, profiles and product pages render on the server from real records, so every record can be its own indexable URL instead of a query-string view.
If what you are building is an internal tool behind a login, none of this matters and you should pick on other criteria. If it lives or dies by search traffic, a directory, a marketplace, a content product, a local services site, this is the difference that decides it, and it is a difference of architecture that no amount of prompting fixes later.
Creable vs Lovable vs other open source AI app builders
The same nine questions asked of every project in this category. Scroll sideways on a phone.
| Capability | Creable | Lovable | dyad | bolt.diy | open-lovable |
|---|---|---|---|---|---|
| License | MIT | Proprietary | Apache 2.0 + FSL | MIT | MIT |
| Self-hostable builder UI | Yes | No | Runs locally | Yes | Yes |
| Hosting, database and auth for generated apps included | Yes, one key | Yes | Bring your own | Bring your own | Bring your own |
| Generated app output | Server-rendered full-stack Next.js | Client-rendered React + Supabase | Depends on template | Depends on template | React front end |
| Integrated database browser in the builder | Yes | Via Supabase | No | No | No |
| Visual click-to-edit | Yes | Yes | Partial | No | No |
| Custom domains from the builder | Yes | Yes | No | No | No |
| GitHub two-way sync | Yes | Yes | Manual | Manual | Manual |
| Resell under your brand, embed in your SaaS | Yes | No | No | Possible | Possible |
Read that table as a description of what each project ships, not as a league table. dyad and bolt.diy are excellent local tools if you want to bring your own model keys and host what you build yourself, and for a developer who enjoys owning that stack they are the better answer. open-lovable is a website-cloning demo and was never meant to be a product. Creable is the option when you want the hosted product experience of Lovable delivered as open source you control and can sell.
Migrating from Lovable
There is no import button, and any tool that promises one is glossing over the fact that the two stacks are different. There are two honest routes, and both are quick.
Bring the source
Lovable can push each project to GitHub. In Creable, create a project, open the GitHub panel, connect that repository, and ask the agent to port the app to this project's Next.js setup. It reads the existing code and rebuilds it against the integrated database.
Or bring the brief
Often faster for smaller apps. Paste your original prompts, attach screenshots of the screens you liked, and describe what has to stay the same. The agent rebuilds it as a Next.js app with its own database rather than translating someone else's output.
Point the domain
Publish the new version, check it on its public URL, then attach your custom domain from the Domain panel and follow the guided DNS steps. The status readout tells you when the records have propagated and the certificate is live.
One thing to do before you start: if the Lovable project stored its data in Supabase, export the tables you need as CSV first. Every new project here gets a fresh managed database, so the data has to come across deliberately rather than by connection string.
Embed the builder inside the product you already sell
Three shapes this takes in practice, all of them running on the same repository and the same single key.
Launch your own Lovable-style product
Clone, rebrand, add login and billing, deploy. You are selling a builder with hosting, databases, deploys and custom domains behind it, and your cost per app is a metered API call rather than a platform you have to run.
Add an AI app builder to your existing SaaS
Let your customers describe the tool they need and have it appear inside your product, on your domain, scoped to their account. One isolated project per customer is the default, so tenancy is a mapping table rather than an architecture.
Ship client work faster as an agency
Turn a kickoff brief into a working application in the same meeting, iterate live, then publish to the client's own domain. Duplicate the finished project as the template for the next engagement.
- 01Stand up a server proxy that holds the API key. Nothing else in your stack ever sees it.
- 02POST /projects/launch with the prompt to create the project and start the first build.
- 03Poll GET /projects/:id/agent/status every 10 to 15 seconds until the run reports done.
- 04GET /projects/:id and show the preview URL in an iframe inside your own interface.
- 05Send follow-ups with POST /projects/:id/agent/start, polling the same status endpoint.
- 06POST /projects/:id/deployments/deploy to publish, then poll deployments/status until it is live.
What the platform handles
Isolated projects per tenant, hosting and SSL, databases and backups, the coding agent and its sandboxes, deploys, custom domains, GitHub and Figma, logs and usage metering.
What you own
The interface, the brand, the pricing and the customer relationship. Your users never see a second vendor, and nothing in the license asks you to mention one.
Frequently asked questions about open source Lovable alternatives
The five questions Google shows for this search, then the ten people ask before they clone the repository.
01Is there anything better than Lovable AI?
Better depends on the job. Lovable is strong at fast hosted prototyping, and if a polished front end in an afternoon is the goal it is hard to beat. If you need to own, host or resell the builder itself, or you need generated apps that are server-rendered so search engines and AI answers can read them, a different tool wins. The two open source routes people take are Creable, which you self-host and can rebrand and resell, and dyad, which runs locally on your own model keys.
02Is there a free alternative to Lovable?
Yes. Creable is MIT licensed and free to run, and you pay only for API usage, starting with 50 free credits. dyad and bolt.diy are also free and use your own model keys. Be precise about what free means here: the builder code costs nothing in all three cases, but the AI generation itself is paid somewhere, either through the Totalum API or through your own provider account, and that is true of every option on this page including Lovable's free plan.
03Is Replit better than Lovable?
They are built for different habits. Replit is an all-in-one collaborative workspace with a real editor, an autonomous agent and its own hosting, so it suits people who want to stay close to the code and work with others in the same environment. Lovable is narrower and faster for front-end-first prototypes. Both are hosted and closed, so neither can be self-hosted or resold, which is the line where an open source builder like Creable is a different kind of answer rather than a better version of the same one.
04Which is better, Bolt or Lovable?
Bolt.new runs the full stack in the browser and is strong for quick prototyping when you want to see a backend working immediately. Lovable is stronger on polished UI generation and its Supabase integration is smoother for a database-backed front end. Both are rented: you use the builder inside their product and you cannot host or modify it. Creable differs on exactly that point, because the builder is MIT code you run yourself.
05Is Lovable really worth it?
For fast validation and prototypes, yes, provided the per-message pricing fits your volume and you do not need to own the builder. Three situations are where people outgrow it: per-message cost that gets unpredictable at scale, no way to modify or self-host the builder, and client-rendered output that is weak for SEO. If none of those apply to you, Lovable is a reasonable place to stay.
06Is there an open source Lovable?
Lovable itself is proprietary and has no self-hosted edition. Creable is an open source builder that follows the same workflow of prompt, live preview, iterate and publish, published under the MIT license at github.com/totalumlabs/lovable-alternative. You can read every line of the builder, run it on your own infrastructure and change anything in it.
07What is the best open source Lovable alternative?
The best free and open source Lovable alternative is Creable, an MIT-licensed AI app builder you can self-host, rebrand and resell, with hosting, a database, auth and custom domains included through a single API key. It reproduces the Lovable workflow of prompt, preview, iterate and publish, but the builder itself is source code you can host on your own servers, restyle, put your own brand on and sell to your own customers.
08Can I self-host a Lovable alternative?
Yes. Creable is a standard Next.js 16 application, so it runs anywhere Next.js runs: Vercel, Docker, Railway, Render, Fly.io or a plain virtual machine with Node 20 or newer. Clone it, set one environment variable and run npm run build and npm start. The generated apps are hosted by the Totalum API, so your server only ever runs the builder itself.
09Is it really free?
The builder is free and MIT licensed, with no seat fees and no commercial-use restriction, so you can sell what you build on top of it. The platform work behind it, the coding agent, the sandboxes, hosting, databases and deploys, is billed through the Totalum API, and the first 50 AI credits are free. There is no second vendor to pay: one key covers all of it.
10Can I add sign-up and login and sell this as my own product?
Yes, and the MIT license is explicit about it. The repo ships with no login by design, so you add your own provider, make the two guards in src/app/api/vcaas/_shared.ts real, map every project to a user, then add Stripe and meter credits per run. The agent status response reports the credits each run spent, which is what lets you price above your cost.
11Can I add an AI app builder to my existing SaaS?
Yes. The whole builder is a thin client in front of one API, so you can either embed this UI inside your product or call the same endpoints from your own interface. The minimum flow is a key-holding server proxy, POST /projects/launch, polling the agent status, then a deploy call. Isolated projects per tenant, hosting, databases and domains are handled on the platform side.
12Does it build full-stack apps with a database?
Yes. Each generated app is a server-rendered Next.js project with its own managed database, and the builder includes a table UI for browsing and editing that data, with filters, linked records and file uploads. Authentication, file storage and per project secrets are available to generated apps as well, so the output is a working product rather than a front end waiting for a backend.
13Is the SEO of the generated apps really better than Lovable's?
The difference is architectural rather than a matter of degree. A client-rendered single page app sends an empty HTML shell plus a JavaScript bundle, so a crawler or an AI search engine has to execute scripts before it sees any content. Creable generates server-rendered Next.js, so complete HTML, per-page metadata, canonicals and sitemaps arrive in the first response, and database-backed pages can each be their own indexable URL.
14Which AI models does it use?
The Totalum API routes each prompt to the best available coding model by default, so you do not have to choose one or hold model keys of your own. The composer's run options let you pick the model, the effort level and fast mode per prompt when you do want to steer it.
15Does it work offline or with local models?
No. Creable is a thin client in front of the Totalum API, and the agent, the sandboxes and the hosting all run on the platform side, so it needs a network connection and a key. If what you want is a local-first tool that runs against your own model keys, dyad or bolt.diy are the better fit and we would point you there.
Try the Lovable alternative that gives you the code
Build something first and read the source afterwards, in whichever order convinces you. The first 50 AI credits are free, and the repository is one clone away.
Running an agency or a SaaS and want the builder under your own brand? Book a 30 minute call.
Keep reading
The longer write-ups behind each part of this page.
Creable is an independent open source project. It is not affiliated with, endorsed by or connected to Lovable Labs Incorporated. “Lovable” is a trademark of its owner, used here only to describe what this project is an alternative to.