Clone Wars: 100+ Open-Source Clones of Popular Sites

The fastest way to learn full-stack development is to rebuild something you already use every day. Clone Wars, a catalog maintained by Gourav Goyal since December 2020, organizes that exercise at scale: more than a hundred open-source clones of the apps already installed on your phone, each entry listing source code, a live demo where one survives, a tech stack, and a star count that tells you at a glance whether you are looking at a weekend study project or a production system.

View Clone Wars on GitHub

Two tables, two different intents

Clone Wars is essentially two Markdown tables, and the split is the smartest thing about it. The first table, Clones with Tutorials, holds eleven entries where a full-stack clone is paired with a free course that walks through building it. An Airbnb build on Sanity and Next.js taught by Ania Kubow, an Instagram clone in React Native with Firebase and Redux from freeCodeCamp, a Django-powered Moodle, a Netflix clone built on Apollo GraphQL and DataStax, a Vue and Quasar Twitter client, an Android WhatsApp built in Android Studio, a Django Discord called StudyBud, and three separate YouTube builds covering React, Yii2 PHP, and Kotlin. Every row answers the coldest of cold-start problems: not just here is code, but here is a person explaining every decision that produced the code.

The second table, Clones and Alternatives, is the big one: a hundred-plus rows across five columns, clone-of, demo, repository, tech stack, and star count. This table mixes two species of project, and the README says so plainly. Clones are UI lookalikes made for learning, often impressive but rarely complete. Alternatives are fully functional open-source replacements for commercial software, and some of them are businesses now. The star column is the honest signal separating them: a 90-star Airbnb lookalike rendered in React with Firebase is a study artifact, while the 40,000-star entry in the Dropbox row is Nextcloud, software that governments and universities run in production. Reading the table with that lens turns a flat list into a maturity map, and it takes about five minutes to internalize which rows deserve which kind of your attention.

The alternatives table is where it gets serious

The word clone undersells half of this repository, because the alternatives column reads like an index of the self-hosting movement. Supabase appears as a Firebase alternative, an Elixir and PostgreSQL platform that has since become the default backend recommendation across indie hacking. Appwrite and Nhost sit in the same Firebase row, attacking the same problem from PHP and Go respectively. Bitwarden shows up as a 1Password and LastPass alternative written in C#, and it is now arguably the most recommended password manager in any developer survey. Nextcloud occupies the Dropbox row, PhotoPrism the Google Photos row with a Go and TensorFlow stack, Plausible and Matomo split the Google Analytics row between an Elixir newcomer and a PHP veteran, and Meilisearch covers Algolia in Rust.

The pattern continues down the table. Cal.com began its recorded life here as Calendso, a Calendly clone in Next.js, and has since become a scheduling platform with its own venture funding. Joplin stands in for Evernote, LibreTranslate for Google Translate, Baserow and Rowy for Airtable, and a full family of Shlink, Kutt, and Polr entries cover Bit.ly from PHP and TypeScript. When Clone Wars went viral in early 2021, most of these were promising projects; four years later they are the established answers whenever someone asks how to exit a subscription. The catalog accidentally captured a cohort at the moment before breakout, which makes browsing the alternatives table less like reading a list of clones and more like reading a founders notebook from 2021 that kept being right.

What building a clone actually teaches

Clone-first pedagogy works because a familiar product specification removes the design debate and leaves only engineering decisions. You already know what the Instagram feed is supposed to do, so the entire learning budget goes to how: how authentication flows through Firebase, how Redux holds state the feed depends on, how Expo ships the result to a real phone. The WhatsApp and Discord entries teach realtime messaging over sockets, the architecture topic tutorials most often skip because it is awkward to demo. The Netflix build teaches GraphQL in anger, with Apollo on the client and DataStax underneath. The Todoist build demonstrates BEM naming and SCSS organization on a codebase small enough to read in one sitting.

The stack diversity across the two tables is itself the lesson. In one catalog you can compare how React, Vue, Django, Rails, Flutter, Kotlin, Yii2, and Elixir each solve the same problems, because they are all solving the same problems: lists, forms, auth, media, and realtime updates. Reading three implementations of a feed teaches pattern recognition that no single-framework course can, and it teaches repository navigation as a side effect. Clone repos are small enough to finish understanding, which makes them the ideal place to practice the reading habit: scan the README, map the top-level directories, check the commit history to see what the author struggled with, and only then run anything. That habit transfers directly to every large codebase you will ever inherit.

Clones in the agent era

Something changed in what a clone is worth, and it happened after this catalog was frozen. Building a quick clone of a famous product is now the standard demonstration for every AI coding agent, and the pattern is so common that a Netflix or Airbnb rebuild in under ten minutes has become the genre’s opening move. That shift turns Clone Wars into something its author never planned: a prompt bank. Each row is a scoped, familiar, verifiable build assignment, the exact shape a coding agent works best with, and the tutorials column doubles as the specification you paste alongside it. Hand an agent the YouTube row with its tutorial link and stack notes, and your job moves from typing to reviewing architecture decisions you already understand from reading the table.

One caution keeps this honest. An agent-assembled clone teaches you review, not construction, and review without ever having built the thing by hand is a skill balanced on nothing. The catalog supports both orders deliberately: run the one-evening manual build from the section below first, then reproduce it with an agent and compare the decisions. The difference between the two codebases is the most compressed lesson in this entire review, because it shows you precisely what the model does well, what it fakes, and what it forgets, on a project small enough that you already know every correct answer.

Read it with fresh eyes: the staleness problem

Honesty requires a timestamp on everything above. The repository has 36,909 stars and 3,343 forks, but its last commit landed on August 6, 2024, adding a Mastodon clone called echoloop. The README itself carries a request for help keeping the list current, and issue 209 is an open call for a maintainer to merge new clone submissions. Forty-one issues sit open, most of them pull requests waiting on exactly that maintainer. Nobody is curating this table in 2026, and pretending otherwise would be the one dishonest thing a review of it could do.

The visible damage is concentrated in demo links. Heroku terminated its free tier in November 2022, and a large share of the table was built on herokuapp.com demos, which now serve error pages or Heroku marketing. The Clubhouse-era entries, jam.systems and Dogehouse among them, are frozen at a moment in social audio history that closed. What survives is the part that matters: source code does not expire, and the repositories behind the entries mostly live their own lives regardless of the table. The tutorials table aged best of all, because freeCodeCamp courses and YouTube walkthroughs keep working long after demo servers die. The practical rule when reading any row: judge the entry by the pulse of the linked repository, its last commit and its issue responsiveness, not by the table row itself. The table is a 2021 snapshot with a 2024 patch, and for what it is, a catalog of starting points, that remains entirely usable.

How to mine it in 2026

Used deliberately, Clone Wars still delivers a return on one evening. The workflow that works: first, pick the app you actually use daily, because motivation compounds and rebuilding your own messenger outranks rebuilding one you have never opened. Second, shortlist two or three rows for that app and open every demo link, spending ten seconds each; dead demos are information too, since they mark entries nobody has touched in years. Third, open the surviving repositories and check the pulse: last commit date, whether issues get answers, whether the README documents setup. Fourth, read before you run, because ten minutes with the directory structure tells you the architecture and saves an hour of confused npm installs. Fifth, run one clone locally, break one feature on purpose, and rebuild it.

Two calibrations make the difference between mining Clone Wars and merely browsing it. Stars in this table are a vanity proxy: a 40-star WhatsApp clone that genuinely demonstrates socket handling will teach you more than a 4,000-star Netflix page that renders a homepage skeleton and stops. And the gourav.io/clone-wars companion site renders the same tables with better formatting and working filters, so prefer it for browsing and keep the GitHub repository for the README context and the issue history. Between the two surfaces, the catalog remains one of the densest free maps of how consumer web products are actually built.

Try it: one evening, one clone

The highest-yield single evening in the tutorials table is the React YouTube clone by JavaScript Mastery, built with Material UI 5 and the RapidAPI YouTube endpoint. Clone the repository, install, and run it, which takes fifteen minutes and gives you a working video search and player. Then do the part that turns a demo into a lesson: delete the video player component and rebuild it yourself from the API response, consulting the tutorial only when stuck. If frontend is your strength and backend the gap, invert the choice and take the Django StudyBud build instead, because rooms, messages, and membership model the same problems a real product faces with a stack that fits in one folder.

Define done before you start, or the evening dissolves into passive video watching. Done means one feature you broke and rebuilt without the tutorial open, one commit on your own fork, and one paragraph in your notes describing what the original author did that surprised you. That is a complete rep with the same muscle every senior engineer uses when they inherit a codebase: run it, break it, understand it, and move on. Clone Wars exists so the running part never costs more than a git clone.

Is Clone Wars still maintained in 2026?

Not actively. The final commit arrived in August 2024, the README asks for help keeping the list current, and issue 209 explicitly seeks a maintainer to merge new submissions, with 41 open issues largely consisting of exactly those submissions. This matters less than it appears, because Clone Wars is a pointer layer rather than software: the value lives in the linked projects, most of which are maintained independently. Treat the table the way you treat a good outdated textbook, as a map of territory that has not moved as much as the copyright page suggests, and verify any row you plan to depend on by visiting the linked repository directly.

Is building a clone of a popular site legal?

Rebuilding the interaction patterns of a well-known product for learning is standard, accepted practice in software education, and this catalog exists inside that tradition. The line is branding and distribution: shipping your rebuild with someone else’s logo, name, or assets is trademark trouble regardless of intent, so keep the layout lessons and drop the identity. Licensing is per repository, not inherited from the list. Clone Wars itself is AGPL-3.0, which governs the catalog text, while each linked project carries its own license, ranging from permissive MIT and Apache to strong copyleft. Read the license of anything before you deploy it, and read it twice before anything commercial.

Which entries are worth running today, not just reading?

The alternatives column, almost exclusively. Bitwarden, Supabase, Nextcloud, Plausible, Meilisearch, and PhotoPrism are all actively developed, self-hostable, and proven in production by organizations well beyond hobby scale, and each replaces a subscription with something you control. Cal.com and Joplin belong on the same list. The clones column is a different category of value: worth running as code to study rather than software to depend on, with the honest exceptions being a handful of tutorial repos that thousands of learners still stand up every month. A simple heuristic separates them, if the row’s project has a company or foundation behind it, run it; if it has a single author and a study purpose in the README, read it.

How is this different from a typical awesome list?

Structure, mostly. Awesome lists are freeform bullet collections where curation lives in the author’s head, while this catalog enforces fixed columns, clone-of, demo, repository, tech stack, and stars, which makes entries comparable and gaps visible. The two-table split encodes intent directly into the structure instead of burying it in prose, and inline star counts expose project maturity without a click. The tutorials pairing is the real differentiator, because it converts the list from a discovery surface into a curriculum. The tradeoff is maintenance cost, and the repository’s current state demonstrates it: rigid, opinionated structure is expensive to keep current, which is why the freeform awesome format dominates despite being weaker per entry.

Clone Wars rewards a specific kind of reader: one who picks a single row, runs the code, and treats the catalog as a syllabus rather than a bookmark. Thirty-six thousand stars agree it pointed somewhere useful, and the tutorials table is still the shortest path from watching an app to understanding it. Pick the clone of the app you opened first this morning, and give it one evening.