Best Lovable Alternatives in 2026: 10 AI App Builders Compared for Production-Ready Apps

Several of the strongest alternatives are open source and self-hostable; see our open source AI app builder comparison.

Lovable is one of several tools we place in our guide to the best AI app builder in 2026.

Quick Answer

The best Lovable alternative in 2026 depends on what you are building. For production-grade web apps with owned code, custom domains, and a real backend that you control, Totalum is the closest match to Lovable's prompt-to-app feel but ships shippable Next.js + TotalumSDK output. For browser-based prompt-to-app prototypes, Bolt.new is the most direct competitor. For real-time multiplayer coding, Replit. For deeper no-code visual control, Bubble or WeWeb. For code-first builders who want an AI co-pilot, Cursor. If you want a genuinely free one, Dyad is open source, runs locally, and costs only your own model API key. Entry pricing across the category now clusters at $20 to $30 a month billed monthly, so pick on output and code ownership, not on demo polish or price.

Why developers and founders search for Lovable alternatives in 2026

Lovable.dev got very good at the demo. You type a prompt, you watch React + Tailwind appear in a preview, you click around, and the cycle feels magical. That cycle is also where Lovable ends for a lot of builders.

Six months in, the search query "lovable alternative" pulls 590 monthly Google searches at a $16.90 CPC as of September 2026, the highest commercial intent in any "vibe coding" cluster. People are not bored. They have moved past the demo and hit the wall every AI app builder eventually hits: getting from a working preview to a production application with payments, auth, a real database, and a custom domain that lives somewhere they trust.

Lovable has not stood still. It shipped subagents on May 27, 2026, a Vent Tool for agent self-improvement on May 21, Google Workspace + Gemini Enterprise connectors on May 19, and it now runs a public MCP server, available on every plan, that exposes projects, chat, files, connectors, databases and deploys as tools any agent can call. Real engineering progress, and we have updated this guide to reflect it. None of it changes the four constraints buyers list most often: code portability, backend control, billing markups on AI tokens, and lock-in to Lovable's hosted runtime.

This guide is the short version of the conversation I have once a week with founders who started on Lovable and are looking for the next step. Ten alternatives, what each one is actually for, and how to think about the choice if you want to ship something production-grade in 2026.

Five honest reasons developers leave Lovable

1. Code portability. Lovable generates code, but the operating environment is theirs. Pulling the project out for self-hosting is possible but not the default path. Migration always costs at least one weekend of cleanup.
2. No first-class backend control. Supabase is the canonical backend, which is fine for many use cases. For SaaS founders who need a more opinionated multi-tenant data model with audit logs and admin tools, you are gluing things together.
3. Token billing markups. Every prompt billed through Lovable is marked up over the underlying model cost. For teams iterating a lot, that math gets expensive fast.
4. Limited deploy flexibility. Lovable handles hosting, which is excellent until you need a specific deployment topology, a private VPC, or a region they do not run in.
5. The agent interface drives their runtime, not your codebase. This one changed in 2026 and we have rewritten it. Lovable now ships a public MCP server, so Claude Code, Cursor and VS Code can create projects, edit files and run SQL against Lovable without leaving your terminal. The gap is no longer "can an agent reach it." The gap is what the agent is reaching: every one of those calls operates on a project inside Lovable's hosted environment. If you want your agent driving a codebase you own and deploy yourself, the MCP server does not solve that, and the four constraints above still apply.

None of these are death sentences. They are the reasons real teams move when their app outgrows the prototype phase.

How the 10 alternatives stack up

Tool	Output	Backend	Code ownership	Custom domain	Best for
Totalum	Next.js + TotalumSDK production app	Built-in DB, auth, payments, storage	Yes, owned and deployable	Yes, native	Production web apps and SaaS founders
Bolt.new	Browser-based full-stack app	Bring your own (Supabase, etc.)	Yes, downloadable	Limited	Quick prototypes across frameworks
Replit	Hosted app with full IDE	Replit DB or external	Yes, in their workspace	Yes, paid plan	Multiplayer real-time coding
v0 by Vercel	Next.js + shadcn/ui components	Bring your own	Yes, GitHub export	Yes, via Vercel	Design-to-code, marketing pages
Bubble	Hosted visual app	Built-in	No, hosted only	Yes	Database-heavy no-code apps
WeWeb	Visual frontend + bring your backend	External (Xano, Supabase)	Yes, hosted	Yes	Visual + AI no-code combo
Cursor	Your repo, your stack	Your stack	Yes, your code	Yes, your deploy	Code-first AI co-pilot
Dyad	Open-source desktop builder	Local + bring your own	Yes, fully local	Yes, your deploy	Free, privacy-first prototypes
Base44	Hosted full-stack app	Built-in	Limited	Yes	Beginner all-in-one builder
Webflow	Hosted marketing sites	Webflow CMS	No, hosted only	Yes	Marketing sites and CMS

The shortest way to read that table: the column that determines whether you keep paying the AI builder fee forever is "Code ownership." Three options answer "Yes, owned and deployable": Totalum, Bolt.new (with caveats), and Cursor.

Price, runtime, and code ownership side by side

The table above answers "what does it output." This one answers the three questions buyers actually decide on. Every figure below was read directly off each vendor's own pricing page on September 4, 2026, using the monthly billing toggle, not the discounted annual rate that most comparison posts quote without saying so.

Tool	Starting price (billed monthly)	Runs in	Code ownership / export
Totalum	Free, then $29/mo (Starter)	Browser	Yes. Viewing source is free on every plan; editing, downloading the full source, GitHub sync and a custom domain are on every paid plan
Bolt.new	Free, then $25/mo (Pro)	Browser	Yes, downloadable. Custom domain support starts on Pro
Replit	Free (Starter), then $20/mo (Core)	Browser	Yes, inside their workspace, with GitHub sync
v0 by Vercel	Free, then $30/user/mo (Plus)	Browser	Yes. GitHub sync is included even on the free plan
Bubble	Free, then $69/mo (Starter)	Browser	No. Hosted only, there is no source export
WeWeb	Free, then $20/mo (Essential)	Browser	Yes. "Export code and self-host" plus GitHub sync begin on Essential
Cursor	Free (Hobby), then $20/mo (Pro)	Desktop editor	Yes. It is your own repository on your own machine
Dyad	Free with your own API key, then $20/mo (Pro)	Desktop app (macOS, Windows)	Yes. Open source and fully local
Base44	Free, then $20/mo (Starter)	Browser	Partial. In-app code edits from Starter; GitHub integration starts on Builder at $50/mo
Webflow	Free (Starter), then $25/mo (Basic)	Browser	Limited. Export needs a paid Workspace plan, separate from the Site plan above, and Webflow notes that dynamic content exports collection by collection and forms stop working

Two things stand out when you line the tools up this way.

First, the entry price for this whole category has converged on roughly $20 to $30 a month. Bubble at $69 and v0 at $30 per user are the outliers, and Bubble is the only tool on the list whose entry plan is more than twice the category norm.

Second, the price is not where these tools actually differ. Code ownership is. Bolt, Replit, v0, Cursor, Dyad, WeWeb and Totalum all give you the source in some form. Bubble does not. Webflow does, but only if you buy a second, separate plan and accept that your forms break on the way out. If you expect to still be running this app in three years, that column matters far more than the ten-dollar spread in the column next to it.

Is there a free alternative to Lovable?

Yes, and there are more of them than there were a year ago. As of September 4, 2026, every tool on this list has some kind of free tier, but they are free in four genuinely different ways, and the difference decides whether you can ship on one.

Free forever, bring your own API key. Dyad is the cleanest example, which is why it holds a page-one spot on this search for that angle alone. It is open source, downloadable for macOS and Windows, needs no sign-up, and you pay only your own model provider. There is no credit meter because there are no credits: the cost is whatever Anthropic or OpenAI charges you. If you already have an API key and you do not mind working on the desktop, this is the closest thing to a genuinely free Lovable.

Free with a metered credit allowance. This is the common shape. Lovable's own free plan gives a daily grant of 5 build credits, up to 30 a month, plus 20 monthly Cloud credits. Bolt.new gives 300K tokens a day and 1M a month. Base44 gives 25 message credits a month. Totalum gives 50 credits a month across 2 projects. v0 gives $5 of monthly credits and caps you at 7 messages a day. These get you through evaluation and a small prototype. None of them get you through a real build without topping up.

Free but not launchable. Bubble's free plan is explicitly for "projects that are under construction": you get the development version, but a custom domain and a live site start at the $69/mo Starter plan. Webflow's free Starter gives you a webflow.io subdomain and 2 static pages. You can build, you cannot really launch.

Free tooling, paid model. Cursor's Hobby tier is a free editor with limited agent requests. The editor never expires. The useful agent usage is what you pay $20/mo for.

The honest summary: if "free" means never pay anyone, the answer is Dyad, and you should be comfortable on a desktop app with your own API keys. If "free" means evaluate properly before I commit, almost all of them work, and the thing to compare is not the headline credit number but what the free tier forbids. On Totalum specifically, the free plan lets you build and view your source code, but editing and downloading the full source, GitHub sync and a custom domain begin on the $29/mo Starter plan. We would rather you know that before you sign up than after.

If free tiers are the whole question for you, we go much deeper in our guide to the best free AI app builder in 2026, including which ones let you own and export the code without paying.

Is there anything better than Lovable AI?

For prototyping speed, honestly, not by much. Lovable is very good at the first hour, and the tools that beat it on that specific axis beat it by a small margin.

"Better" only becomes a useful word once you name the job. On code ownership and backend control, Totalum, Cursor and Dyad are better, because the output is yours in a way Lovable's hosted runtime is not. On framework flexibility, Bolt.new is better, because it will build React, Next.js, Vue or Svelte while Lovable is opinionated. On real-time collaboration, Replit is better. On visual design control, WeWeb and Bubble are better. On raw prototyping speed with a polished result, Lovable is still at or near the top, and pretending otherwise would not survive contact with an afternoon of actual use.

The framing we would push back on is "better" as a global ranking. The people who leave Lovable almost never leave because a competitor out-prompted it. They leave because their app stopped being a prototype and the constraints listed earlier in this post started to bind. If you are still in the prototype phase, the answer to this question may well be "no, stay where you are."

Is Replit better than Lovable?

For a specific set of jobs, yes. For most Lovable users, it is a lateral move rather than an upgrade.

Replit is better when you want a full IDE and a terminal rather than a prompt box, when you need several people editing the same project live, or when you want the agent to plan, code, test and deploy inside one workspace. Its Core plan is $20/mo billed monthly, which undercuts Lovable Pro at $25/mo, and its free Starter tier lets you publish one live project.

Replit is not better if what you liked about Lovable was that you never had to look at a file tree. Replit exposes more machinery, and that is the point of it. It is also worth being clear that Replit's code lives in Replit's workspace: you get GitHub sync, but the ownership story is closer to Lovable's than it is to Cursor's or Totalum's.

Our fuller head-to-head is in the Replit alternative guide for 2026, which covers where Replit's workspace model helps and where it gets in the way.

Which is better, Bolt or Lovable?

They are the closest pair on this list, and the choice comes down to two things: frameworks and output polish.

Pick Bolt.new if you need framework choice. Bolt builds React, Next.js, Vue, Svelte and more, and runs entirely in the browser through WebContainers. Its Pro plan is $25/mo billed monthly, the same price as Lovable Pro, and its free tier is more generous in raw terms: 300K tokens a day and 1M a month, against Lovable's 5 build credits a day and 30 a month. Bolt also lets you download the project.

Pick Lovable if you want the most polished first result with the least steering. Lovable is opinionated about React, Tailwind and shadcn/ui, and that opinion is why its output tends to look finished sooner. It also has the deeper connector catalog, and since shipping its MCP server it is reachable from Cursor, VS Code and other AI clients on every plan.

Neither is the right answer if your real requirement is a production backend. Both are prototype-first tools with a bring-your-own-backend story, usually Supabase. That is the gap the rest of this list exists to fill, and it is why we put Totalum at the top of it: auth, payments, database, storage and deployment are generated with the app rather than wired up afterwards.

1. Totalum

What it is: an AI app builder that produces real Next.js + TotalumSDK applications with built-in auth, payments (Stripe), database, file storage, AI integrations, deployment, and custom domains. The same builder is driven via API and MCP, which means coding agents and software agencies can embed it.

Why it is the top Lovable alternative for production apps: the output is a normal Next.js application. You can deploy it on Totalum, clone the repo, host it on your own Vercel or Cloudflare account, and keep working on it with Claude Code or Cursor. The auth, payments, database, and storage are not glued together after the fact, they are part of the generated app from the first prompt.

The MCP interface is the part that most "alternatives" lists miss. With the Totalum MCP installed in Claude Code or Cursor, the coding agent can request a new app, edit the database schema, redeploy, and add a custom domain without leaving your terminal. Lovable now offers the same kind of interface, so the honest distinction in late 2026 is not who has an MCP server. It is what sits on the other end of it: with Totalum, the agent is operating on a Next.js codebase you can clone, own and host anywhere.

Best for: SaaS founders shipping their first paid product, software agencies that want to deliver client work in days instead of weeks, and developers who want an AI app builder that respects "I want to own the code."

Try it: start a free build at totalum.app. For agencies and SaaS founders evaluating embedding Totalum, book a discovery call.

2. Bolt.new

What it is: a browser-based AI app builder from StackBlitz. Type a prompt, watch a full-stack app appear with a real file tree, a working preview, and a one-click deploy option.

Why people pick it over Lovable: framework flexibility. Bolt supports React, Next.js, Vue, Svelte, Astro, and more. Lovable is opinionated toward a React + Supabase stack. If you want to build a Vue SPA or a Svelte marketing site with the same prompt-to-app feel, Bolt wins.

Where it falls short: backend depth. Bolt scaffolds frontend code beautifully, but it does not have an opinionated production stack with auth, payments, and database baked in. You bring those in yourself.

Best for: developers who want a fast prototype across multiple frameworks and are comfortable wiring the production layer themselves.

3. Replit

What it is: a hosted AI workspace combining a code editor, terminal, package manager, and Replit AI Agent for prompt-driven coding. Real-time multiplayer is its defining feature.

Why people pick it over Lovable: Replit feels like a real IDE, not a preview pane. Their Agent has matured significantly in 2026 and can generate full codebases, run tests, and iterate. If you want to work alongside a co-founder in the same browser tab, Replit's collaboration is unmatched.

Where it falls short: the deployment story is improving but still feels like extra steps compared to Lovable's "prompt to live URL." Production-grade SaaS still ends up moving off Replit hosting.

Best for: teams that want a hosted IDE with AI baked in and pair-programming as a first-class feature. For a deeper comparison, see our Replit alternative analysis.

4. v0 by Vercel

What it is: Vercel's design-to-code AI tool. Prompt for a UI, get React + shadcn/ui components you can drop into a Next.js project.

Why people pick it over Lovable: component quality. v0 outputs are the cleanest React components on the market today. If you already have a Next.js app and you want AI to draft your sign-up flow or your marketing page, v0 is the right tool.

Where it falls short: v0 is a component generator, not an app builder. It does not build the database, auth, or deployment layer. For full apps, you pair it with the rest of the Vercel platform yourself.

Best for: teams already on Vercel who want AI-drafted UI components, and design-led founders who want to iterate on UX before bringing engineering in.

5. Bubble

What it is: the original no-code visual app builder. Drag-and-drop UI, built-in database, workflows that run server-side.

Why people pick it over Lovable: depth. Bubble has been around long enough to have ecosystem, plugins, agencies, and case studies. Complex multi-tenant apps with intricate business logic ship on Bubble every day.

Where it falls short: it is not AI-native. Bubble has added AI features but the core experience is still "you build it visually." That is a feature for some teams and a bug for others. You also do not own the code.

Best for: founders who want a database-heavy app without writing code and are comfortable with vendor lock-in. For a head-to-head, see Bubble vs Totalum.

6. WeWeb

What it is: a visual frontend builder that pairs with external backends like Xano or Supabase. They added an AI generation layer in 2026 that competes directly with Lovable's prompt-to-app workflow.

Why people pick it over Lovable: visual editability after AI generation. Everything WeWeb generates is editable in their visual editor, which is a real win for teams who want both a fast start and continuous design refinement.

Where it falls short: backend logic still lives in a separate tool. The two-platform setup is more flexibility but also more glue. Worth noting for the ownership question: WeWeb's own pricing page lists "Export code & self-host" and GitHub sync starting on the $20/mo Essential plan, so the code is genuinely retrievable, unlike Bubble's.

Best for: design-leaning teams who want AI to draft the UI and then plan to spend significant time polishing it visually.

7. Cursor

What it is: an AI-native code editor (a fork of VS Code) with deep agent capabilities. Cursor Composer 2.5 ships multi-file edits, Cursor Automations (the May 2026 update) runs automations across multiple repos.

Why people pick it over Lovable: code-first control. Cursor does not pretend you are not writing code. You get the AI superpowers (multi-file edit, agent loop, codebase understanding) on top of your real repo. If you already write code and you want AI to help you write more, faster, Cursor is the right tier of tool.

Where it falls short: Cursor is not an app builder. It does not scaffold a Next.js app with auth, payments, and a database from one prompt. You are still the developer; Cursor is the very good co-pilot. For the production layer, pair it with Totalum's MCP and you have the full chain.

Best for: developers who do not want a hosted builder and want to keep their stack, repo, and CI exactly as they are. See our best AI coding agents in 2026 ranking for a deeper view.

8. Dyad

What it is: an open-source, local-first desktop application that builds AI apps on your machine. Free, no hosted runtime, no token markups (you bring your own model keys).

Why people pick it over Lovable: cost and privacy. Dyad runs locally. You pay nothing for the builder; you pay only the underlying model. For privacy-sensitive workloads or for hackers who want to avoid hosted services entirely, that math is hard to beat.

Where it falls short: it is desktop-first and earlier in its life. The hosted polish of Lovable (one click to deploy, share a URL with a teammate) does not exist out of the box. You assemble that yourself.

Best for: developers who want a free, open-source alternative and are comfortable owning the operating environment. Dyad Pro is $20/mo if you would rather buy 200 AI credits than manage your own keys, but the free desktop app stays free.

9. Base44

What it is: an all-in-one AI app builder with the simplest onboarding in the category. Type, build, share. Targets beginners and non-technical founders.

Why people pick it over Lovable: simplicity. Base44 strips out almost every choice and just gives you the working app. For founders who never want to look at code or hosting settings, this is the closest competitor to Lovable's vibe.

Where it falls short: ceiling. You will outgrow Base44 the moment you need anything bespoke or anything that talks to an external API in a non-obvious way.

Best for: non-technical founders shipping their first MVP who value simplicity over flexibility.

10. Webflow

What it is: the leading visual website builder, with a strong CMS and a no-code-friendly designer experience. They have added AI-assisted design tools but Webflow's core is still pixel-precise visual design.

Why people pick it over Lovable: when you actually need a marketing site or a content-driven site, Webflow is the right tool and Lovable is the wrong one. The two solve different problems.

Where it falls short: it is not an app builder in the SaaS sense. There is no auth flow, no payment integration, no first-class database for users. Use Webflow for the marketing site, use something else for the product. See Webflow vs Totalum for the side-by-side.

Best for: marketing teams shipping content-heavy sites, and product teams who want a fast public site without coupling it to the product codebase.

When Lovable is still the right choice

Honest section. Lovable is the right tool when:

• You need to demo a working app to a stakeholder in two hours, not two days.
• You are validating a UI idea and code ownership genuinely does not matter yet.
• You are a content creator showing off the "vibe coding" workflow to an audience and the speed of iteration on screen is the point.
• You are pre-product-market-fit, you do not have paying customers yet, and you want to defer engineering decisions until you do.

If any of those describes you today, stay on Lovable. If you are reading this and you already have paying users (or you expect to within 90 days), the question is not "should I leave Lovable" but "which alternative on this list is the right fit for the production version of my app."

How to think about migrating off Lovable

For a real migration plan, the steps are usually:

1. Audit your data model. Write down the tables, fields, relationships, and any custom triggers. If your data is in Supabase, you can export it; if it is in a Lovable-managed store, plan an extract.
2. Identify your auth source of truth. Do users log in with email, OAuth, magic links? Where do they live?
3. List your third-party integrations. Stripe, SendGrid, OpenAI, whatever your app calls. Note the API keys and endpoints.
4. Pick the destination. For production SaaS, this is usually Totalum (auth + db + payments + storage built in) or a self-managed Next.js + Supabase setup if you want full DIY.
5. Rebuild the core flow. Prompt the new builder with your specs and your data model. With Totalum, this is one or two prompts plus a CSV import, not a multi-week project.

If you want the SaaS-embed angle, where you are not just building one app but planning to white-label the builder itself, the question changes from "which tool" to "which tool exposes an embeddable API." That is the conversation we have most often with software agencies and B2B SaaS founders moving off Lovable.

What about the AI Agent Platform layer?

Lovable, Bolt, Replit, and Totalum are all builders. The 2026 stack has a second layer above the builder: the AI Agent Platform, where agents drive the builder through APIs and MCP rather than humans through a UI. For most of 2026 the layer-aware question was "does this tool expose itself to my agent?" That question is close to settled: Totalum, Bolt, Cursor and now Lovable itself all do. The question that replaced it is sharper, and it is the one worth carrying into 2027: when my agent calls this tool, does it end up holding code I own, or a session inside someone else's runtime? That is where the alternatives on this list still separate from each other, and it is the reason "lovable alternative" remains the high-intent query it is.

For the broader picture of vibe coding tools, the agent + builder chain is where the action is. Lovable was an excellent first chapter. The next chapter is being written by the tools that let agents drive them.

For design-led teams weighing Framer against an AI app builder, see Framer vs Totalum in 2026 for the marketing-site-vs-application trade-off.

If you want the pure-pricing view of the same comparison, our companion Lovable pricing 2026 guide walks through the plan grid, the 2026 shift to a single credit balance that hosting and in-app AI now draw from, and a transparent Totalum alternative.

Deciding between the two biggest names first? Our Lovable vs Bolt guide compares them directly.

If you came here wanting a free AI app builder, our guide explains which free tiers let you own and export the code.

FAQ

Is there a free Lovable alternative?

Yes, several. Verified on each vendor's pricing page on September 4, 2026: Dyad is open source, runs locally, and needs only your own model API key, which makes it the only genuinely zero-cost option. Bolt.new's free tier gives 300K tokens a day and 1M a month. Replit's free Starter tier publishes one live project. Totalum's free plan gives 50 credits a month across 2 projects and lets you view your source, though editing and downloading the full source, GitHub sync and a custom domain start on the $29/mo Starter plan. See the free-tier breakdown earlier in this post for what each free plan actually forbids.

What is the best Lovable alternative for production apps?

Totalum is the closest match for prompt-to-app speed with production-grade output (Next.js + TotalumSDK, owned code, custom domain, auth, payments, database, storage). For a more code-first path, pair Cursor with Totalum's MCP. For a Vercel-native path, pair v0 components with a Next.js + Supabase setup you build yourself.

Can I export the code from Lovable?

Lovable provides ways to view and pull code, but the operating environment (database, auth, deployment) lives inside their platform. A full migration requires manual extraction of data and rebuilding the runtime elsewhere.

Is Bolt.new better than Lovable?

For multi-framework prototyping, yes. Bolt supports React, Next.js, Vue, Svelte, and more, while Lovable is opinionated. They cost the same at the entry tier, $25/mo billed monthly on both as of September 2026, so price is not the tiebreaker. For a single-prompt full-stack app with built-in auth and payments, neither is the strongest pick today; Totalum is.

What is the best Lovable alternative for SaaS founders?

Totalum, by a margin. Built-in auth, payments, multi-tenant database, file storage, deployment, and custom domains are all generated from the first prompt. The output is portable Next.js, so you are not locked into the builder forever. For agencies and SaaS founders embedding the builder into their own product, Totalum exposes a full API + MCP interface.

What is the best free local Lovable alternative?

Dyad. Open source, desktop-first for macOS and Windows, runs locally, needs no sign-up, and uses your own model API keys. It is also the reason a free-tier page currently outranks most of the big comparison posts on this search.

How does Lovable compare to Cursor?

They solve different problems. Lovable is a hosted prompt-to-app builder; Cursor is an AI-native code editor that runs against your local repo. Most production teams in 2026 use both: a builder for scaffolding (Totalum or Lovable), Cursor for ongoing development. See the Lovable vs Totalum head-to-head for that side of the comparison.

The bottom line

Lovable is a great first-chapter tool. The 2026 question is which alternative is the right second chapter for your app. For most teams shipping a production app this quarter, the order is: Totalum (production-grade, owned code, built-in backend), Bolt.new (framework flexibility), Replit (real-time multiplayer), Cursor (code-first AI), and v0 (component generation). Pick on output, not on demo polish.

If you are a SaaS founder or an agency looking at this for client work, book a discovery call. If you are a developer who just wants to ship a real app today, start a free build at totalum.app.