Lovable made "type a sentence, get an app" mainstream, and it also made a set of trade-offs that send a steady stream of people searching for an open source Lovable alternative: you rent the builder per message, you cannot host it, you cannot change it, and you certainly cannot offer it to your own customers under your own name. In September 2026 we published Creable, an MIT-licensed open source Lovable alternative that closes exactly those gaps. This article is a deep look at what it is, what it is not, how it compares to the other open source builders, and how to turn it into a product of your own.
Quick Answer
- An open source Lovable alternative is an AI app builder whose builder interface is source code you can read, host, modify and in most cases resell, instead of a hosted product you rent.
- Creable is the one we maintain: MIT licensed, self-hostable anywhere Next.js runs, and available at github.com/totalumlabs/lovable-alternative.
- Its distinguishing property is that hosting, databases, auth, sandboxes, deploys, custom domains and GitHub sync come from a single API key, so there is no second vendor to wire up before the first app runs.
- Apps it generates are server-rendered full-stack Next.js projects with an integrated database, not client-rendered React bundles, which matters if what you build has to be found in search.
- dyad and bolt.diy are the strongest alternatives if you want a local tool with your own model keys. Creable is the option when you want the hosted product experience delivered as code you control.
Why people look for an open source Lovable alternative
The searches that lead here are specific, and they are almost never about the quality of Lovable's output. Pulling the live Google results for this topic in September 2026, the related searches attached to "lovable alternative" include "Lovable alternatives open-source" and "Lovable alternative github". People are not asking whether prompt-to-app works. They have decided it works, and now they want to know who owns the thing that does it.
Four motivations come up again and again.
Cost shape, not cost level. Per-message pricing is fine while you are exploring and uncomfortable once a tool is load-bearing. The objection is rarely "this is expensive" and usually "I cannot predict this, and I cannot cap it."
Control of the interface. Once a team uses a builder daily, they want to remove features, add their own, change the defaults, and wire it into an internal system. A hosted product cannot be edited.
Data and deployment location. Regulated industries, EU-only requirements and enterprise procurement all eventually ask where the thing runs. "In someone else's SaaS" is sometimes an acceptable answer and sometimes the end of the conversation.
The chance to resell. This is the motivation that grew fastest in 2026. Agencies and SaaS companies looked at Lovable and asked a reasonable question: why is this a product I buy rather than a feature I offer? An open source builder makes that question answerable.
What Creable actually is
Creable is an open source AI app builder in the style of Lovable. You chat, an AI coding agent writes the application, you watch it run in a live preview, refine it with follow-up prompts or by clicking directly on elements in the page, and publish it with one click.
The architectural fact that explains everything else about it: this repository is only the builder interface. Everything heavy, meaning the coding agent, the sandboxes, hosting, databases, deploys, custom domains, GitHub sync, Figma import and logs, is provided by the Totalum API behind one key.
That single design decision is why the quick start is four commands and why the whole thing is resellable. You are not being handed an orchestration problem with a UI on top. You are being handed a UI, and the orchestration problem is already solved behind an HTTP API.
git clone https://github.com/totalumlabs/lovable-alternative.git
cd lovable-alternative
npm install
cp .env.example .env.local # set TOTALUM_VCAAS_API_KEY=tlm_sk_...
npm run dev # http://localhost:3000There is exactly one required environment variable. No Supabase project, no Vercel account, no model provider keys, no vector database, no queue.
What ships in the box
| Area | What it does |
|---|---|
| Prompt to app | Describe the app in plain language. The agent writes a complete Next.js project and keeps iterating from follow-up messages. |
| Live preview | The running app updates in the right-hand panel while the agent works. Desktop and phone viewports, route picker, refresh, open in a new tab. |
| Visual editing | Click any element in the preview and change its text, size, colors or image. Edits are written back to the exact file and line. Desktop browsers only. |
| Code editor | A Monaco editor over every generated file. Save, rebuild, done. |
| Integrated database | Each app gets a managed database with no setup. Browse tables, filter, edit records, upload files, follow linked records, all from the builder. |
| Auth and storage | Generated apps can use accounts, roles, sessions and file uploads without provisioning anything. |
| Publish | One click puts the app on a public HTTPS URL in about three minutes. |
| Custom domains | Attach your own domain with guided DNS steps and live status. |
| GitHub sync | Connect a repository and push or pull in both directions. |
| Figma | Paste a Figma frame link and the agent builds from the design. |
| Version history | Every agent run is a restorable checkpoint with a diff viewer. |
| Logs | Development and production logs with search. |
| Multi-tenant | Each project is isolated. Create one per user or per customer and put your own login in front. |
The honest caveat
Creable ships with no authentication, by design. Every route is public and the app acts on one API key, so anyone who can reach the URL can spend that key's credits.
This is deliberate: the repository is meant to be the base of a product, and the auth you bolt on should be the auth your stack already uses, not one we picked for you. But it means the deployment story has a hard prerequisite. Before it goes online for real users, the guards in src/app/api/vcaas/_shared.ts have to be made real and the pages listed in src/proxy.ts have to be protected. Running it locally or on a private network without a login is fine.
Any open source builder that tells you it is production ready the moment you clone it is skipping this conversation. We would rather have it up front.
How the open source Lovable alternatives compare
There are several genuinely good open source options now, and they are not competing for the same job. The useful question is not "which is best" but "which one matches the shape of what you are doing".
| 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 plus 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 fork in the road rather than a scoreboard.
dyad is the most popular open source Lovable alternative by a wide margin, and deservedly so. It runs on your machine, uses your own model keys, and the code never leaves your laptop. If your priority is privacy and zero platform dependency, dyad is the correct answer and Creable is not.
bolt.diy is the community fork of Bolt and occupies similar ground: local, bring your own keys, bring your own hosting.
open-lovable is a website-cloning demo rather than a general builder. Useful, but a different tool.
Creable is the option when what you actually liked about Lovable was the hosted product experience: an app that is live on a URL minutes after you describe it, with a database and a domain, without you running any infrastructure. It delivers that experience as open source you control and can sell. The trade-off is explicit and worth stating plainly: it depends on the Totalum API, so it does not run offline and it does not use your own model keys.
If that dependency is unacceptable to you, dyad is a better fit, and we would rather you found that out in paragraph twelve than after an afternoon of setup.
Why the generated apps are server-rendered, and why it matters
Most AI app builders, Lovable included, generate a client-rendered single-page React app: an empty HTML shell plus a JavaScript bundle that draws the page in the browser. For an internal dashboard that is completely fine. For anything that has to be found, it is a handicap.
Creable generates full-stack Next.js projects instead, which changes four concrete things.
- Server-rendered pages. Google, Bing and AI crawlers receive complete HTML with the content already in it, not a blank shell waiting for JavaScript to execute.
- Real metadata per page. Titles, descriptions, Open Graph and Twitter cards, canonical URLs, sitemaps and robots rules are first-class in Next.js, and the agent uses them.
- Fast by default. Streaming, code splitting, image optimization and caching are built in, which is what Core Web Vitals reward.
- A database that is part of the app. Data-driven pages such as listings, profiles, blog posts and product pages render on the server from the integrated database, so every record can be its own indexable URL.
If you are building a directory, a marketplace, a content site or a store, this is not a detail. It is the difference between a site that can rank and one that structurally cannot. We wrote more about the underlying trade-off in the guide to AI app builders that generate real code.
Turning the repo into your own product
This is the part that makes an open source Lovable alternative commercially interesting rather than merely convenient. Because the builder is a thin client in front of one API, converting the repository into a branded product is a checklist, not a rewrite.
Rebrand it. src/lib/brand.ts holds the product name, tagline, prompt placeholder, meta title and description and outbound links. No component hardcodes the product name, so a rebrand is that one file plus src/components/brand/Logo.tsx, src/app/icon.svg and the theme tokens in src/app/globals.css.
Add authentication. Bring Supabase, Clerk, Better Auth or your own. Then make the two guards in src/app/api/vcaas/_shared.ts real: return 401 when there is no user, and 403 when the requested project does not belong to that user.
Add tenancy. Store a projects(project_id, user_id) row when a project is created, check it on every proxied /projects// path, and filter the home listing to the caller's own rows. Projects are already isolated on the platform side, so this is the whole of the tenancy work.
Add billing. Stripe Checkout, credit the balance on checkout.session.completed and invoice.paid, idempotent on the event id, then gate the spend-shaped paths with a 402 when the balance is empty. The agent status response reports the credits each run actually spent, so you can meter per prompt and price above your cost.
Deploy it. It is a standard Next.js application. On Vercel, import the repository, add the API key as an environment variable, deploy. On any Node host, npm run build && npm start.
The full step-by-step version of this lives on our open source Lovable alternative page, and the commercial terms are on the white-label program page. If you would rather skip the UI entirely and call the API from your own stack, embedding an AI app builder via API covers that route.
Who this is and is not for
A good fit if you want a self-hosted builder without running sandboxes and databases yourself; you are an agency that wants to ship client work under your own brand; you are a SaaS company that wants to add an app-builder feature without building the infrastructure behind it; or the apps you generate need to rank in search.
A poor fit if you need the builder to work offline; you specifically want to bring your own model keys; or you object on principle to any hosted dependency. Those are legitimate requirements, and dyad or bolt.diy serve them better.
FAQ
Is there an open source Lovable?
Lovable itself is closed source and there is no official open source edition or self-hosted release. What exists is a set of independent open source alternatives that reproduce the workflow, including Creable, dyad, bolt.diy and open-lovable. Creable is MIT licensed, so you can read, modify, host and resell every line of the builder.
What is the best open source Lovable alternative?
It depends on the constraint that matters most to you. For a local tool with your own model keys and no platform dependency, dyad is the strongest option. For the hosted product experience of Lovable, meaning apps that arrive with hosting, a database, auth and domains, delivered as open source you can self-host, embed and sell, Creable is built for exactly that case.
Can I self-host a Lovable alternative?
Yes. Creable runs anywhere Next.js runs: Vercel, Docker, Railway, Render, Fly.io or a plain VM. Clone it, set one API key, then npm run build && npm start. The generated apps are hosted by the platform, so you do not run sandboxes or databases yourself.
Is it actually free?
The code is free and MIT licensed, including for commercial use and reselling. Running it needs a Totalum API key, which starts with 50 free credits and then charges for usage. There are no per-seat fees for the builder itself.
Can I sell a product built on this repository?
Yes, that is the intended path and the MIT license permits it explicitly. Add an auth provider and billing, make the two ownership guards real, put your brand in brand.ts, and you have your own AI app builder. The reseller terms are on the white-label page.
Does it use my own AI model keys?
No. Prompts are routed by the Totalum API to the best available coding model, and the composer's run options let you choose the model, the effort level and fast mode per prompt. If bringing your own keys is a requirement, dyad or bolt.diy are the better fit.
How is this different from ai-app-builder-open?
Same engine, different edition. ai-app-builder-open is the neutral white-label starter. Creable is themed after the Lovable layout and palette, with defaults and documentation aimed at people making that specific switch. Fixes flow between the two repositories.
Ready to build with Totalum?
If you want to try the builder without cloning anything first, the fastest path is to start free at totalum.app, describe an app, and see what a server-rendered Next.js project with its own database looks like when it comes out the other side. The first 50 credits are free.
If you are an agency or a SaaS company and the interesting part of this article was the reselling section, book a 30 minute call and we will walk through the white-label terms and what the integration looks like in your stack.
The repository is at github.com/totalumlabs/lovable-alternative. Issues and pull requests are welcome, and a star helps the next person find it.
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.