Alternative

Lovable mobile app alternative with no signup: the difference is whether the first interaction is a form or a prompt.

Lovable's own documentation is explicit: "a Lovable account is necessary to begin building." You pick from email, Google, GitHub, or Apple, then the system provisions a workspace and gives you 5 daily credits. The first interaction is a form. mk0r is the alternative whose first interaction is a prompt: the auth provider signs you in anonymously through Firebase before any UI loads, and you get six chat turns before sign-in is requested. Below is the side-by-side, plus the exact file and line numbers that prove the no-signup behavior.

Direct answer, verified 2026-05-11

mk0r is the alternative. Lovable's docs at docs.lovable.dev/introduction/create-an-account require an email, Google, GitHub, or Apple account before the first build. mk0r calls signInAnonymously(auth) inside onAuthStateChanged at src/components/auth-provider.tsx:71 on first load, no UI shown, no form filled. The anonymous user gets ANON_TURN_LIMIT = 6 chat turns before sign-in is requested (src/app/api/chat/route.ts:23).

The first 30 seconds, on each side

The shape of the difference is sharpest in the first half-minute. Either you are filling in a form to gain entry, or you are typing the prompt that becomes the app. Toggle below.

Lovable vs mk0r, first 30 seconds for a non-technical maker

Land on lovable.dev. The hero shows a prompt box but clicking Build redirects to /signup. Pick email and password, Google, GitHub, or Apple. Fill the form, verify your email, choose a workspace name, accept terms. Land in the dashboard. Now you can type the prompt.

Signup form is the first interaction, not the prompt
Account, workspace, and credit budget exist before the first idea
Email verification adds a real-world wait if mail is slow
5 daily credits, 30 monthly cap, on the free tier

Where the no-signup claim lives in code

Most pages comparing AI app builders treat "no signup" as a marketing line. On mk0r it's a small piece of code you can read. The relevant pieces are three files in github.com/m13v/appmaker.

src/components/auth-provider.tsx:65 to 80. The auth provider mounts once at the root. Inside its effect, onAuthStateChanged(auth, ...) fires; when the Firebase user is null, signInAnonymously(auth) is awaited on line 71. The promise resolves with an anonymous Firebase user that has a real uid, no email, and isAnonymous: true.
src/app/api/chat/route.ts:23. The hard cap on the server side: const ANON_TURN_LIMIT = 6. Same file at lines 191 to 213, the gate reads users/{uid}.anonTurnsCompleted and returns a 403 with { error: "sign_in_required" } once the counter is at or above six.
src/lib/auth-server.ts:78 to 100. migrateSessionOwnership(fromUid, toUid, toEmail) is the function that runs when an anonymous user upgrades to Google and Firebase has to issue a new uid. It rewrites the userId on every app_sessions doc and the ownerUid on every projectsdoc the old uid owned. This is the "no orphaned work after sign-in" property.

Three small files. One constant, one function call, one migration helper. The whole no-signup behavior is that small because it doesn't try to be more than that: skip the form, count six turns, upgrade cleanly when the user is ready.

What happens on each side, drawn out

Two boot sequences. Same user with the same idea ("a budget tracker for couples on a phone"). On Lovable, the form sits between the idea and the build. On mk0r, the anonymous user is provisioned inside the auth provider before the prompt input renders. Five actors on each side, very different orderings.

Lovable: first build for a new visitor

Ten messages before the first prompt. The form is the gatekeeper. None of these steps are wrong (they enable persistence, workspaces, billing), they are just there before the user has decided whether they like the product.

mk0r: first build for a new visitor

Three of those nine messages (mount, onAuthStateChanged, signInAnonymously, response) happen invisibly inside the browser before the user even sees the page. From the user's point of view there are exactly two events: open the URL, type a prompt. The anonymous auth is plumbing.

6 turns

“ANON_TURN_LIMIT = 6 in src/app/api/chat/route.ts:23. The gate reads users/{uid}.anonTurnsCompleted from Firestore and returns 403 sign_in_required once the counter is at or above six. The number was raised from 2 to 6 on May 8, 2026 after staging telemetry showed users were hitting the gate before finishing their first iteration cycle.”

github.com/m13v/appmaker, src/app/api/chat/route.ts (verified 2026-05-11)

Where the comparison stops being symmetric

Lovable and mk0r are not feature-for-feature replacements, and a comparison page that pretends otherwise is lying. After the no-signup advantage, the two products diverge in real ways. Worth naming, because the right answer for some readers is "both, in sequence."

Lovable hosts a persistent workspace per account, integrates with Supabase for a real database, ships Stripe-ready deploy paths, and has a template marketplace. Once you are committed to a project (and the friction of signup is moot because you have made the decision), those are real wins. The platform was built for the second hour onward.

mk0r is built for the first hour. The E2B sandbox is alive while you are chatting; the dev server is real (Vite on port 5173, with HMR); the preview URL is shareable. There is a published project lane (the /api/projects route and a Firestore projects collection) for when an anonymous user upgrades and wants their work to persist across browsers. But the optimization is for the moment of the idea, not for the long tail of running a real product.

If you want to ship a real SaaS with auth, payments, and a database, Lovable is closer to the right shape. If you want to text a friend a link to the app you just imagined, mk0r is. Many people end up using mk0r to test the idea and then port the parts they like into a Lovable workspace once they are sure.

How to verify the no-signup claim yourself

Three small experiments. Each takes under a minute. Together they prove that the behavior described above is what the live product does, not what the marketing page says.

Incognito-window load. Open mk0r.com in a private window with devtools open on the network tab. You should see a POST to identitytoolkit.googleapis.com/v1/accounts:signUp within a second of the page rendering. The response body has a localId and an idToken. You did not type anything. That is the anonymous user being created.
Read the source. Open src/components/auth-provider.tsx at line 71. The line reads await signInAnonymously(auth); inside the onAuthStateChanged callback. That is the only thing standing between a visitor and a Firebase uid.
Try seven turns. In your incognito window, send seven prompts. The seventh request returns HTTP 403 with {"error":"sign_in_required","turnsUsed":6,"turnsAllowed":6}. That is the gate at src/app/api/chat/route.ts:197 firing exactly as described.

The honest limits

Three places where the no-signup model fails or feels worse than Lovable's account-first model, written here so you can decide before you spend the first thirty seconds.

Cross-device continuity. An anonymous Firebase uid lives in the browser's storage. If you start on a laptop and want to continue on a phone, you must sign in on the laptop first so the project is associated with a permanent uid. Otherwise the phone gets a fresh anonymous uid and your laptop work isn't there.
Six turns is six turns. If your first idea takes more than six prompts to land, you'll hit the gate. The gate is not a hard wall (signing in unlocks it), but it is a wall. Lovable's 5 daily credits with a 30 monthly cap is a different shape (per-day, not per-session) and may be friendlier for someone who likes to iterate over a week.
Generated output is web-mobile, not native. The artifact is HTML, CSS, JS, runnable on any mobile browser. It is not an iOS or Android binary. If your final intent is the App Store or Play Store, you'll need to wrap it (Capacitor, Expo, a WebView shell) or rebuild in a different tool. mk0r's sweet spot is "something you can text someone a link to," not "something the App Store will accept."

Open the site. Type one sentence. The Firebase anonymous sign-in happens before your finger leaves the Enter key.

Try mk0r without signing up

Six turns, anonymous. Sign-in is optional and only requested at the seventh.

What to read next on the site

ai-app-builder-no-signup: the wider "no signup" framing across the category, not just Lovable.
ai-app-maker-no-signup: adjacent maker-centric angle, with the same code-path proofs.
ai-code-generator-vs-full-app-builder: the architectural line between tools that return text and tools that return a URL.
prompt-to-app-releases-may-2026: the release notes that include the day the anonymous turn cap moved from 2 to 6.

Want to see the no-signup boot live?

Twenty minutes with the team. We open an incognito window, watch the Firebase anonymous sign-in fire in devtools, then walk through src/components/auth-provider.tsx and the chat-route gate line by line.

Frequently asked questions

Does Lovable actually require signup before building?

Yes. Lovable's documentation page on creating an account is unambiguous: 'a Lovable account is necessary to begin building.' The signup form accepts email and password, Google, GitHub, or Apple. After signing up, the system provisions a personal workspace on the free tier with 5 daily credits (capped at 30 monthly). There is no anonymous trial. The signup is the first interaction, before you can type a prompt. Source: docs.lovable.dev/introduction/create-an-account, verified 2026-05-11.

How does mk0r let me skip signup, exactly?

When you load mk0r.com, the auth provider runs onAuthStateChanged, sees no user, and calls signInAnonymously(auth) from the Firebase Web SDK. That hands you a Firebase anonymous user (a real uid, no email) without showing any UI. The exact line is src/components/auth-provider.tsx:71 in github.com/m13v/appmaker. Your chat turns count against that anonymous uid until you decide to sign in. You can verify this with the browser devtools: open mk0r.com in an incognito window, watch the network panel, and you'll see a request to identitytoolkit.googleapis.com:signUp returning a localId you never typed an email for.

If mk0r still uses Firebase auth under the hood, is that really 'no signup'?

The promise of 'no signup' is that you, the human, do not fill in a form, do not pick a password, do not verify an email, and do not authorize OAuth before you can build. Anonymous Firebase auth satisfies all four. There is no friction surface between landing on the page and typing a prompt. Most users who arrive looking for a 'no signup' alternative to Lovable mean exactly that human-friction definition, and the page meets it.

How many prompts do I get before mk0r asks for sign-in?

Six. The constant ANON_TURN_LIMIT in src/app/api/chat/route.ts:23 is set to 6. The counter lives on the user's Firestore doc (users/{uid}.anonTurnsCompleted) and increments on each completed turn. The seventh prompt from an anonymous user returns 403 with error 'sign_in_required' so the UI can pop a Google sign-in. The number changed once during launch week (started at 2 on May 7, raised to 6 on May 8 because telemetry showed users were hitting the gate before the first iteration cycle finished). Six is the current value as of this page's publish date.

Why does this matter for mobile apps specifically?

The output of an mk0r session is a mobile-first HTML/CSS/JS app with a working preview URL you can open on a phone. The first thing a non-technical maker wants to do is text a friend the URL and see the app on their phone. If the maker had to sign up first, decide on a workspace name, verify an email, and only then build, the loop slows to minutes per iteration. With no signup, the loop is: prompt, watch it stream, share the URL. Mobile is the natural target because most non-coders are sharing screenshots of phone screens anyway.

What if I do want to sign in (save projects, sync across devices)?

Sign in any time. The button is in the top-right; it pops Google OAuth, and on success Firebase upgrades the anonymous account to a permanent one with the same uid (or migrates session ownership if the credential is already in use). All your prior anonymous turns, projects, and sessions carry forward. The migrateSessionOwnership function in src/lib/auth-server.ts handles the edge case where the Google account already exists. Net effect: the anonymous-then-upgrade path leaves no orphan work.

Does mk0r generate native iOS or Android apps?

No. The generator output is HTML, CSS, and JS, optimized for mobile browser viewports. That is the right shape for the keyword 'mobile app' in the no-signup audience because the artifact is shareable as a URL with one click; a native binary would not be. If you specifically need a native binary, Expo with EAS Build is the standard path, but it requires a signup and a build pipeline that is fundamentally not zero-friction. mk0r's tradeoff is honest: web-mobile output in exchange for instant access.

Is there a credit cap on the anonymous turns, like Lovable's 5 daily?

Not a credit cap, a turn cap. Six successful chat turns total against the anonymous user, then the gate fires. The check is in src/app/api/chat/route.ts:191 to 213: it reads users/{uid}.anonTurnsCompleted from Firestore and returns a 403 with 'sign_in_required' once the counter is at or above 6. Each turn can involve many tool calls inside the sandbox (file writes, npm installs, page screenshots) but the human-side prompt is what counts. After signing in, you have your own Claude OAuth tokens or the shared API key, and the gate is gone.

What's the open-source proof?

The repository is at github.com/m13v/appmaker (MIT license shown in the LICENSE file). The auth-provider component, the chat route, and the anonymous turn gate are all in main. You can grep for ANON_TURN_LIMIT (one constant, one usage site), signInAnonymously (one call site, in auth-provider.tsx), and migrateSessionOwnership (one definition, used in the credential-already-in-use fallback). The behavior described on this page is exactly what the code on disk does on 2026-05-11.

Is mk0r trying to replace Lovable?

No. Lovable's full free tier (5 daily credits, up to 30 monthly) plus its template marketplace, Supabase integration, and Stripe-ready deploys cover a different audience: someone who has committed to the platform and wants persistent workspaces, integrations, and a database from day one. mk0r is the right tool for the first hour of an idea, when the friction of signup would kill the experiment. Many users probably end up using both for different stages of the same project.

Still here? The fastest way to feel the difference is to try it.

Open mk0r