Open Source Shopify Alternatives

Medusa is a commerce platform with a built-in framework for customization, aimed at teams who need to ship a store without rewriting order, cart and pricing logic from scratch.

The project ships its core commerce logic as commerce modules published on npm, alongside a framework that lets you extend or replace behavior rather than fork it. Because the primitives are separated from the application built on top of them, one foundation carries very different shapes of business.

The README describes the ground it is meant to cover.

• B2B and DTC stores: advanced storefronts built directly on Medusa's commerce primitives.
• Marketplaces: multi seller platforms and distributor systems sharing a single commerce core.
• Point of sale: PoS systems and service businesses that need the same order and pricing model.
• Integrations: a published catalog of integrations, plus release notes for keeping a project current.

For deployment, Medusa Cloud offers a managed environment with automated deployments, scaling and maintenance, while the documentation covers setting up an application locally. Licensing follows an open core model: the core is MIT, and the RBAC based Enterprise Edition materials identified in the repository require a commercial agreement.

The core team answers questions in GitHub Discussions, where the roadmap is discussed in the open, and a Discord server hosts more than 14,000 community members.

Bagisto is an open source eCommerce and multi-vendor marketplace platform for teams that would rather extend a Laravel application than work around a closed storefront. Built with Laravel and Vue.js, it sets out to cut the time and cost of launching an online store while leaving the code open to change.

The same core stretches across several commerce shapes. A single-vendor store, a B2B platform with company-based purchasing, multi-user access, quote negotiation and procurement management, a multi-vendor marketplace, a multi-tenant deployment or a point of sale all grow from it.

Around that core the project maintains companion pieces for other channels.

• Headless storefronts: A Next.js commerce project builds decoupled storefronts against the platform.
• Mobile: An open source mobile app pairs Flutter with the Laravel backend.
• AI features: LLM APIs plug in for chatbots, generated product descriptions, support, search and recommendations.
• Decentralized commerce: Smart contracts on Ethereum or Solana back marketplaces, NFT trading and e-signing.
• Extensions: A prebuilt extension library and a starter pack shorten the initial setup.

Deployment runs from a documented Docker installation to a pre-configured Amazon Machine Image on the AWS Marketplace, or fully managed cloud hosting from the maintainers. A live demo, developer documentation, video tutorials and community forums cover the learning curve for teams arriving without Laravel experience.

A plugin architecture eventually ties a store to one language and one runtime. Saleor avoids that by making a GraphQL API the only way into the commerce backend, configuration and extension included.

Extensibility runs through webhooks, attributes, metadata, apps, subscription queries and dashboard iframes rather than in-process plugins. Apps deploy independently of the core, so upgrades stop colliding with extensions and custom logic can be scaled or debugged on its own. The tradeoff is acknowledged, since a solo developer running a low traffic shop may find a service oriented setup heavier than a traditional framework.

The commerce model itself covers the parts most catalogs need.

• Native multichannel: pricing, currencies, stock and product availability are controlled per channel.
• Product management: a rich content model aimed at large and complex catalogs.
• Orders: split payments, multi-warehouse fulfilment, returns and a flexible order model.
• Promotions: sales, vouchers, cart rules and gift cards in a single engine.
• Payment orchestration: multi-gateway support and an extensible payment API for any method.
• Translations and SEO: a fully translatable catalog with headless freedom over markup.

Version 3.x is the production line, with the dashboard and the storefront kept in their own repositories. Docker Compose instructions cover self-hosting, and Saleor Cloud offers developer accounts plus a CLI that bootstraps a storefront against your GraphQL endpoint.

WooCommerce is the ecommerce plugin for WordPress, and this repository is the monorepo where it is developed together with the packages, tools and extensions around it. It is where you read the source, follow open issues and track ongoing work, not where shop owners download a release.

Every plugin, package and tool in the tree carries its own manifest and scripts, and most carry their own setup notes. PNPM manages the JavaScript side and pins the Node version that each script runs under, while Composer handles dependencies for the PHP packages and plugins.

A few things are worth knowing before cloning it.

• Prerequisites: Node.js, PNPM, PHP 7.4 or newer and Composer all need to be present first.
• Two commands: an install with a frozen lockfile followed by a build prepares every output for development.
• Repository layout: plugins, packages and tools sit in separate directories, with internal packages marked by a prefix.
• Operating system: a POSIX system is assumed, and Windows work is expected to go through WSL.
• Issue tracker: reserved for core bugs, since support runs through the forums, the community Slack and the self-help guides.

Security issues are disclosed through a HackerOne program rather than public issues. Contributions are welcome through the contributing guide, and the development blog is the recommended way to follow where the project is going.

Teams that outgrow a hosted store usually face a rebuild. Spree is an open source commerce backend for the ones who would rather own the platform than rent it, with a REST API, a TypeScript SDK and a production-ready Next.js storefront under a BSD 3-Clause license, so code, data and infrastructure stay in your hands.

One command scaffolds the backend, the Admin Dashboard and the storefront into a single project, which needs Node.js 22 or newer and a running Docker. The storefront is built with Next.js, React, Tailwind CSS and TypeScript, while the Spree CLI boots the stack, runs generators and migrations, and calls the Admin API straight from the terminal.

The platform covers the commerce cases that usually force a rewrite later.

• Cross-border selling: Markets bundle currency, language, payment methods and shipping rules per country, with a Translations Center for bulk localization.
• B2B and wholesale: price lists, customer groups, buyer companies and gated storefronts serve different segments at different prices.
• Sales channels: several storefronts, points of sale and mobile apps run off one backend, each with its own products and rules.
• Payments: provider-agnostic payment sessions with Stripe, Adyen and PayPal plugins, plus an SDK for adding others.
• Extensibility: an event bus, webhooks, metafields and a MeiliSearch integration for typo-tolerant product search.

Official Docker images let the backend run on cloud, on premises or a plain VPS, and the storefront deploys to any Node host. A hosted sandbox exists for evaluation, and published agent skills teach AI coding tools the project's conventions.

This repository holds the source of the Gumroad web application itself, not a trimmed-down sample of it. Gumroad is an e-commerce platform for creators who sell straight to consumers, and what runs the storefront is what you are reading.

It is a Ruby on Rails application with a JavaScript build step and a Sidekiq worker, developed against Docker services for MySQL 8.0, Redis and Elasticsearch. Seller subdomains and the API host resolve under localhost, so no edits to your hosts file are needed.

Getting an instance running locally means installing a real production toolchain.

• Media processing: ImageMagick handles preview editing and libvips covers newer image formats through ActiveStorage.
• Video metadata: ffprobe, shipped with FFmpeg, reads metadata out of uploaded video files.
• PDF handling: pdftk stamps files with the logo and the buyer's email, and wkhtmltopdf renders invoices.
• Search: Elasticsearch indices must be rebuilt explicitly after setup or the app raises index errors.
• Credentials: the app boots without any, and an environment file adds S3, Stripe or Resend when you need them.

Tests run under RSpec, with integration specs driving Chrome through Capybara and Selenium. Contribution works unusually here: there is no inbound review queue, so you fork, open the pull request against your own fork and email support with a link. The bar is the same one the team applies internally, meaning visual evidence for user-facing changes, QA steps, test results and a disclosure naming any model used.

Alokai is a set of developer tools for composable commerce, meant for teams that build, deploy, and monitor ecommerce frontends. Rather than an empty starter, it delivers a working storefront already integrated with a commerce stack.

The architecture keeps the frontend separate from the commerce platform. A middleware server sits between them and connects the storefront to the ecommerce backend and to other integrations, which is what allows the same frontend to run on any backend with an API.

What arrives out of the box is the set of pieces a storefront project usually has to select and wire itself.

• Nuxt.js and Next.js: the application can be built on the Vue framework or the React one.
• Alokai Theme: a fully functional ecommerce theme rather than a blank page.
• Storefront UI: a component library designed for commerce, usable as delivered or replaced by a theme of your own.
• Alokai Middleware: the Express.js server that talks to the commerce platform and the integrations around it.
• Backend agnostic: any backend with an API can be connected, and many are already integrated.

The project reports more than 3500 live stores running on it. Development happens in the open, with contribution guidelines and a community channel for questions, and the team publishes integrations rather than expecting each store to write its own connector.

Vendure gives commerce teams a backend they can change at the core, modeling catalog, orders, pricing, promotions and customers in one place. It exists so a team does not have to choose between a rigid suite and a composable stack assembled from scratch.

The stack is TypeScript end to end, with Node.js, NestJS and GraphQL on the server and a React and TanStack admin dashboard. There is no proprietary query language, and the introspectable GraphQL schema makes it straightforward to wire up LLM tool calling, MCP servers and agent frameworks.

Commerce building blocks arrive on day one, with an extension model sitting over all of them.

• Plugin contracts: extend or override any part of the system without forking or patching core code.
• Custom entities and workflows: add pricing logic and business specific behavior next to the built-in model.
• One GraphQL API: serves any frontend across D2C, B2B, marketplace and omnichannel from a single core.
• Built-in domains: cover catalog, orders, customers, promotions, channels, tax, shipping, payments and stock.
• Scaffolding command: creates a project with server, admin dashboard and API ready to run.

Vendure needs Node.js 20.19 or 22.12 upward and a SQL database, whether PostgreSQL, MySQL, MariaDB or SQLite. The license is GPLv3, with an exception letting you publish your own plugins under any license you choose, and building against the GraphQL API does not pull your storefront in. It runs anywhere Node runs, self-hosted, in Docker, on Kubernetes or on any cloud.

Built with Ruby on Rails and forked from Spree, Solidus is a free, open source e-commerce platform run since then as a community project. It is aimed at merchants who want complete control of a store rather than the boundaries a hosted service draws for them.

The platform is not one monolith but a set of gems installed together. Requiring the top-level gem pulls in core models, mailers and classes, the admin backend, the RESTful API and sample data. A store can just as easily take only the core and pair it with a custom storefront, admin interface and API of its own.

A local install follows an ordinary Rails workflow.

• Prerequisites: ImageMagick has to be present for Paperclip before anything else is installed.
• Generator: the install generator runs migrations and loads seed and sample data, each of which can be turned off with a flag.
• Running: the Rails server serves the storefront on port 3000, with the admin area under its own path.
• Databases: PostgreSQL, MySQL and MariaDB are supported by exporting a database variable before setup.
• Docker: a compose file brings up a development environment, with the Ruby and Rails versions configurable.

Repository advice includes turning off asset debugging so development mode stops loading every stylesheet separately, and a caution that Turbolinks in the admin can break extensions. The BSD licensed code is directed by Nebulab, its main contributor, with funding from partners and backers on Open Collective. A live demo is available for anyone who wants to click around before installing.

Your Next Store is an open source storefront template for Next.js, powered directly by Stripe. It removes the weeks usually spent assembling products, variants, carts and checkout, and it is written on purpose so that coding agents can extend it without inventing their own conventions.

The stack is Next.js 16 with the App Router, React Server Components and the React Compiler, Bun as runtime and package manager, Tailwind CSS v4, Shadcn UI, TypeScript and Biome. A Commerce Kit SDK exposes typed methods such as productBrowse and cartUpsert, so the contracts an assistant needs are already defined.

Several choices exist mainly to make automated edits land correctly.

• AGENTS.md: project context, SDK examples, lint rules and a validation checklist agents read before writing a line.
• Stripe-native: checkout, billing and subscriptions go straight through the Stripe API.
• Theme branches: 149 ready-made themes live on their own branches, each a redesigned homepage over the same core.
• CLI scripts: trigger a production publish or call any Store API endpoint using only the store API key.
• Baseline defaults: prerendered chrome, optimizer-served icons and WCAG-AA color tokens, checked by the build and test commands.

Getting started is a clone, a Bun install and an API key in a local environment file. Node 24 and Bun 1.0 are the prerequisites, and the result deploys to Vercel in one click or self-hosts wherever you like.

Shopware 6 answers two needs at once, a shopping cart that works out of the box and an ecommerce framework you build on when the requirements stop being standard. It is used by thousands of shops and supported by a worldwide community of developers, agencies and merchants.

The platform is primarily based on Symfony 7 and Vue.js 3, and it is API-first, so a custom storefront can talk to it without touching the default one. Installed as a vendor dependency in a Flex project, it behaves like any other Symfony package, which keeps the tooling and upgrade path familiar to a PHP team.

Building on top of it is well-trodden ground.

• Plugins: Symfony bundles loaded as part of the application, with the whole framework available to them.
• Apps: a lighter, modern way to add functionality, requiring very little Shopware-specific knowledge.
• Community store: more than 3,100 extensions are already published for shops that would rather install than build.
• Headless mode: the storefront is optional, so the platform can sit behind whatever front end a project needs.

For production, the recommended on-premise route is the Flex template, backed by a web-based installer, written instructions and a course, plus hosting partners who hand over a preinstalled shop. A managed cloud plan exists for anyone who wants none of that, and commercial plans add functionality to on-premise installs. The platform itself is free under the MIT license, and code contributions require signing a contributor license agreement.

Vvveb CMS puts a visual page builder in front of a PHP site, so pages get laid out by dragging blocks rather than by editing templates. It stretches from a personal blog to a store with subscriptions and digital downloads, which removes the usual step of bolting an ecommerce plugin onto a general purpose CMS.

It runs on PHP 7.4 or newer, with 8.3 recommended, and stores content in MySQL, MariaDB, PostgreSQL, or SQLite. Install by uploading a build to your server and opening it in a browser, or run the bundled CLI installer with database credentials on one line. The page builder itself, VvvebJs, lives in its own repository, as do the admin and frontend themes.

The feature list leans toward publishing teams and shop owners rather than developers alone.

• Editorial workflow: revisions, media management, multiple users, and role permissions.
• Ecommerce: one page checkout, subscriptions, digital assets, vouchers, product options, variants, and reviews.
• Hybrid headless: serve pages traditionally or pull content through the GraphQL and REST APIs.
• Extensibility: custom fields, custom posts, custom products, and plugins hooked into an event system.
• Security: brute force and SQL injection protection, a hidden admin login page, and only one PHP file exposed publicly.
• Marketplace: themes and plugins install in one click from the admin dashboard.

With caching on, served pages behave like static files, and the project reports hundreds of requests per second on free shared hosting. Backups run manually or automatically, import and export cover migration, and licensing is AGPLv3 or later.