Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 30 ยท Getting Started

What Is Shopware 6?

Learn what Shopware 6 is, how its Symfony, Twig and Vue stack fits together, and when to build a plugin, an app or a theme for your own shop.

Shopware 6 is an open-source e-commerce platform written in PHP. It gives you the pieces every online shop needs: a product catalog, prices and taxes, a cart and checkout, customers, orders, shipping and payment methods, promotions, a content editor called Shopping Experiences, and an administration where merchants manage all of it. Agencies and in-house teams extend it to match a specific business, and that extension work is what this tutorial teaches.

The platform is built "API first". Everything the storefront does goes through the same kind of HTTP interfaces that your own mobile app or a headless front end could use. That design decides how you extend Shopware, so we start with the big picture before any code. If you are new to online shops in general, skim What Is E-commerce? first; this track assumes you know what a cart and an order are.

Everything real in this track (Shopware's classes, commands and configuration) is shown in read-only code blocks, because a full Shopware installation cannot run inside a web page. Each lesson also contains runnable PHP stand-ins that model the idea in a few lines, and the text always says which part is real and which part is the stand-in.

The stack

Shopware 6 is not a monolith written from scratch. It stands on well-known pieces:

  • PHP and Symfony. The back end is a Symfony application. Controllers, the service container, events, the console and the message queue all work the way they do in any Symfony project. If those words are unfamiliar, read What Is Symfony? first.
  • MySQL or MariaDB. Data is stored in a relational database. Shopware accesses it through Doctrine DBAL for low-level queries and through its own Data Abstraction Layer (DAL) for entities, which you will meet in the data chapter.
  • Twig. The storefront renders HTML with Twig templates that plugins can extend block by block.
  • Vue. The administration is a single-page application built with Vue. Plugins can add modules and replace or extend components.
  • Optional search and cache services. Larger shops commonly add OpenSearch or Elasticsearch for product search, and Redis for cache and sessions. They are not needed to learn plugin development.
flowchart TD
    A["Merchant<br/>Administration (Vue)"] --> API["Admin API"]
    S["Shopper<br/>Storefront (Twig)"] --> SA["Store API"]
    H["Headless app<br/>or mobile app"] --> SA
    API --> C["Core (Symfony + DAL)"]
    SA --> C
    C --> DB[("MySQL / MariaDB")]
    E["Extensions<br/>plugins, apps, themes"] -. extend .-> C

Both front ends talk to the core through APIs; extensions plug into the core.

Core, Storefront, Administration

Shopware's code is split into a few packages, and you will see their names in namespaces constantly:

Part Namespace root Job
Core Shopware\Core Business logic, DAL, Store API, Admin API, checkout, flows
Administration Shopware\Administration The Vue admin and its backing routes
Storefront Shopware\Storefront The Twig shop, its controllers and pages
Elasticsearch Shopware\Elasticsearch Optional integration for product search

The core knows nothing about Twig or HTML. A shopper adding a product to the cart in the storefront results in a request that the storefront controller passes to core services, and a headless app would call the same core logic through the Store API. That separation is why one shop can have several different front ends.

Editions and licensing

The Community Edition is the free, open-source version of the platform. It contains the whole core and the standard storefront and administration, and it is what you install for development. Shopware also sells paid plans that add features, hosting options and support. The exact bundles, names and prices change over time, so check Shopware's own pages for the current list instead of relying on a tutorial.

For plugin work, the practical points are these:

  • Develop against the open-source code. A plugin for the Community Edition normally works on paid plans too, as long as you only use documented extension points.
  • Check that a feature you rely on exists in the edition your client runs. Some functionality is only available in commercial plans, and you cannot assume it is in your local copy.
  • If you plan to sell an extension, the Shopware Store has its own review rules; the last chapter touches them.

Three kinds of extensions

Shopware offers three ways to change a shop. Choosing between them is one of the most important early decisions.

Plugins are PHP packages that run inside the Shopware process. They are installed with Composer or copied into the custom/plugins folder, and they can do almost anything: add database tables, replace core services, subscribe to any event, add admin modules and storefront templates. The price is that a plugin shares the server, the PHP version and the update cycle with the shop, and a bug in it can break the shop.

Apps are described by a manifest.xml file and talk to Shopware over HTTP. Shopware calls the app's web server with webhooks and action buttons, and the app calls the Admin API with credentials it received during registration. An app's own code runs on its own server, so it cannot crash the shop and it can work with cloud-hosted shops where merchants cannot upload PHP. The trade-off is that an app can only use the extension points apps support, and every interaction is a network call. Apps, Webhooks and Signatures covers them in detail.

Themes change the look of the storefront. A theme is delivered either as a plugin or as an app (the app flavour is limited to templates, styles and configuration). Its theme.json file describes the assets and the configuration fields a merchant can adjust. You will style the storefront in Styling and JavaScript in the Storefront.

flowchart LR
    subgraph shop["Shopware process"]
        K["Core"]
        P["Plugin<br/>PHP code, same process"]
        T["Theme<br/>templates and styles"]
    end
    subgraph remote["Your own server"]
        A["App backend<br/>any language"]
    end
    K <--> P
    K <--> T
    K <-- "HTTP, signed" --> A

Plugins and themes run inside Shopware; an app's code runs elsewhere and is reached over signed HTTP.

This track is about plugins, because they are the most powerful kind and teach you how the platform is built. The lessons on events, the DAL and routes also apply when you write the Admin API side of an app.

Where plugin code runs

A plugin is loaded as a Symfony bundle when the application boots. Its service definitions are merged into the main container, its event subscribers are registered with the event dispatcher, its templates join the Twig template inheritance chain and its migrations are discovered by the migration system. After that, a plugin's code is just more code in the same request: it can use any service the core exposes, share the same database connection and run inside the same transaction scope.

That freedom brings responsibilities that run through the whole tutorial: keep subscribers fast, never copy core code when you can extend it, prefer public extension points over private classes, and always give your plugin a clean uninstall path.

Try it: a tiny core with extensions

The stand-in below is not Shopware code. It builds a miniature kernel with an event dispatcher so you can see the shape of the system. A plugin registers a listener and receives the live kernel object, while an app is only ever called with a JSON string and answers with JSON, just like a webhook.

PHP A core, a plugin and an app

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with fgets(STDIN)), it gets the next line from this box.

Real: the idea of a core that dispatches events, extensions that react, and apps that are reached over HTTP. Stand-in: the class, the event name and the payload, which are far simpler than Shopware's.

The second stand-in turns the decision into a small checklist. It is a rule of thumb, not a Shopware API, and you should adapt it to your project.

PHP Plugin, app or theme?

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with fgets(STDIN)), it gets the next line from this box.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which framework is the Shopware 6 back end built on?

    Shopware 6 is a Symfony application, so its container, events, console and message queue follow Symfony conventions.
  2. 2. Where does the code of a Shopware plugin run?

    A plugin is loaded as a bundle when the application boots, so its code runs in the same process and shares the container and the database connection.
  3. 3. A merchant on a cloud-hosted plan cannot upload PHP files. Which extension kind fits best for a new integration?

    Apps are described by a manifest and talk to the shop over HTTP, so they work without uploading PHP into the shop.
  4. 4. Why can one Shopware shop have several different front ends?

    Both the Twig storefront and the Vue administration use API-style access to the same core, and a headless or mobile front end can use the Store API in the same way.

Summary

  • Shopware 6 is an open-source, API-first e-commerce platform built on PHP, Symfony, a relational database, Twig and Vue.
  • The code is split into Core, Administration and Storefront packages; the core holds the business logic.
  • The Community Edition is free and enough for development; paid plans add features, so confirm what your client's edition includes.
  • Plugins run in the shop's own process and are the most powerful extension; apps run on your server and talk over signed HTTP; themes change the storefront look.
  • The kernel and the decision checklist here are stand-ins, not Shopware code.

Next: Setting Up a Development Environment