Sylius 2.1.8: PHP 8.5 und Symfony 7.4 Support

Die Open-Source E-Commerce Alternative für 2025

Die E-Commerce-Landschaft für kleine und mittelständische Agenturen steht vor einer interessanten Entwicklung: Während Shopware seine Community Edition mit der Fair Usage Policy ab 1 Million Euro GMV faktisch limitiert, positioniert sich Sylius 2.1.8 als vollständig freie Alternative mit modernster Technologie. Das November-Release bringt offizielle PHP-8.5-Unterstützung, Symfony-7.4-Kompatibilität und wichtige Bugfixes für Admin-API, Bildverwaltung und Channel-Validierung. Für Agenturen stellt sich die Frage: Welche Plattform bietet das beste Preis-Leistungs-Verhältnis für kundenspezifische E-Commerce-Projekte?

Sylius 2.1.8: Technische Neuerungen im Detail

Das Release 2.1.8 vom 27. November 2025 festigt Sylius' Position als technologischer Vorreiter im E-Commerce-Bereich. Die PHP 8.5 Unterstützung erfolgt bereits 7 Tage nach dem offiziellen PHP-Release am 20. November 2025 – ein bemerkenswerter Geschwindigkeitsrekord. Zum Vergleich: Sylius 1.10 erhielt PHP 8.0 Support erst 7 Monate nach dessen Veröffentlichung. Die nahezu zeitgleiche Integration von PHP 8.5 demonstriert die deutlich verbesserte Release-Reife der Plattform.

Die Symfony 7.4 Kompatibilität ist besonders relevant, da Symfony 7.4 als Long-Term-Support Version bis November 2027 Support erhält. Sylius nutzt dabei gezielt neue Symfony-Features:

1. Attribute-based Configuration: Routing und Dependency Injection können komplett über PHP-Attributes konfiguriert werden, XML-Konfigurationen sind deprecated
2. Performance-Optimierungen: Container Compilation ist 15% schneller, Cache-Performance verbessert sich um 39%
3. HTML5 Parser: Native Unterstützung für modernes HTML-Parsing ohne externe Dependencies
4. Message Signing: HMAC-SHA256 basierte Signierung für sichere Message-Queue-Kommunikation

Kritische Bugfixes in 2.1.8

Die Update-Notes listen mehrere wichtige Korrekturen:

1. Admin API Produkterstellung (#18563): Behebt Fehler beim Anlegen von Produkten über die Admin-API, die bei komplexen Produktvarianten auftraten
2. Bildänderungen (#18557): UX Icons werden jetzt lokal gebundelt statt über Iconify API geladen – reduziert externe Dependencies und verbessert DSGVO-Compliance
3. Channel-Validierung bei Checkout (#18586): Verfeinerte .env Konfigurationen für Symfony 7.4 Kompatibilität verhindern Channel-bezogene Fehler beim Bestellabschluss
4. State Machine Callbacks (#18580): Dokumentation für disabled callbacks bei sylius_product_review State Machine

Technologie-Stack Vergleich: Sylius vs. Shopware vs. CS-Cart

Für Agenturen ist die technische Basis entscheidend. Hier zeigen sich fundamentale Unterschiede:

Sylius: Modern und flexibel

Core-Technologie: PHP 8.2-8.5, Symfony 6.4/7.3/7.4, Doctrine ORM 3, API Platform 4.1

Sylius basiert vollständig auf Symfony-Komponenten und folgt Symfony Best Practices konsequent. Das bedeutet für Entwickler:

// Sylius Controller mit Symfony-Standards
namespace App\Controller;

use Sylius\Bundle\ResourceBundle\Controller\ResourceController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

#[Route('/admin/products')]
class ProductController extends ResourceController
{
    #[Route('/create', name: 'product_create', methods: ['GET', 'POST'])]
    public function createAction(Request $request): Response
    {
        // Standard Symfony Controller-Logik
        // Volle IDE-Unterstützung durch Attributes
        return $this->render('admin/product/create.html.twig');
    }
}

Die API Platform 4.1 Integration ermöglicht automatische REST-API-Generierung aus Doctrine-Entities:

use ApiPlatform\Metadata\ApiResource;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ApiResource]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;
    
    #[ORM\Column(length: 255)]
    private string $name;
    
    // Automatisch verfügbar über /api/products
}

Vorteile: Symfony-Entwickler sind sofort produktiv, keine Shop-spezifischen Patterns nötig. Testbarkeit durch Symfony Testing-Framework. Moderne Entwicklung mit PHP 8.x Features (Property Promotion, Named Arguments, Enums).

Nachteile: Steile Lernkurve für Entwickler ohne Symfony-Erfahrung. Weniger fertige Admin-Templates als Shopware.

Shopware 6: Vollständige Lösung mit Einschränkungen

Core-Technologie: PHP 8.1-8.3, Symfony 6.4, Vue.js 3, Twig

Shopware 6 nutzt Symfony als Basis, ergänzt dies aber durch eigene Abstraktionsschichten:

// Shopware Controller mit Framework-Abstraktion
namespace Shopware\Core\Checkout\Cart\Controller;

use Shopware\Core\Framework\Routing\Annotation\RouteScope;
use Symfony\Component\Routing\Annotation\Route;

#[Route(defaults: ['_routeScope' => ['storefront']])]
class CartController extends StorefrontController
{
    #[Route('/checkout/cart', name: 'frontend.checkout.cart.page')]
    public function cart(Request $request): Response
    {
        // Shopware-spezifische Context-Handling
        $page = $this->cartPageLoader->load($request, 
            $this->context->getSalesChannelContext());
        
        return $this->renderStorefront('@Storefront/cart/index.html.twig', [
            'page' => $page
        ]);
    }
}

Vorteile: Vollständiges Admin-Interface out-of-the-box. Shopping Experiences (Page Builder) für Content-Management. Umfangreiches Plugin-Ökosystem mit über 5.000 Extensions.

Nachteile: Community Edition limitiert durch Fair Usage Policy (1M€ GMV Grenze). Komplexere Architektur durch Shopware-Abstraktionen. Plugin-Kosten können erheblich sein (10-500€ pro Plugin).

CS-Cart Multi-Vendor: Proprietäre Lösung

Core-Technologie: PHP 7.4-8.x, eigenes Framework, Smarty Templates

CS-Cart nutzt ein proprietäres Framework ohne moderne Standards:

// CS-Cart Controller-Stil (vereinfacht)
function fn_add_product_to_cart($product_data, $cart) {
    // Prozeduraler Stil, globale Funktionen
    $product_id = $product_data['product_id'];
    
    if (fn_check_amount_in_stock($product_id, $amount)) {
        $cart['products'][$product_id] = $product_data;
        fn_calculate_cart_content($cart);
    }
    
    return $cart;
}

Vorteile: Multi-Vendor Features out-of-the-box (perfekt für Marktplätze). 500+ E-Commerce Features included. Self-hosted mit vollem Code-Zugriff (bei gekaufter Lizenz).

Nachteile: Keine Open-Source Community Edition verfügbar. Lizenzkosten: Standard $1.450, Plus $3.500, Ultimate $7.500 (einmalig). Veraltete Entwicklungspatterns, schwierige Testbarkeit. Update-Kosten für Major-Releases.

Praktischer Funktionsvergleich für Agentur-Projekte

* Shopware CE ist kostenlos, ab 1M€ GMV wird ein Shopware-Plan (ab 600€/Monat) verpflichtend

Entwicklungsaufwand: Realistische Zeitschätzungen

Basierend auf eigener Projekterfahrung hier realistische Aufwandsschätzungen für einen Standard-Shop (ca. 200-500 Produkte, 3 Zahlungsarten, 2 Versandarten):

Sylius-Projekt (Symfony-erfahrene Agentur)

1. Setup & Grundkonfiguration: 8-12 Stunden (Channels, Locales, Currencies, Taxonomies)
2. Theme-Entwicklung: 24-40 Stunden (Responsive Twig-Templates auf Basis von Sylius Shop UI)
3. Payment Integration: 8-16 Stunden (Payum-Gateways konfigurieren, 3 Provider)
4. Shipping Integration: 6-10 Stunden (Standard-Methoden + DHL/DPD API)
5. Admin-Customization: 12-20 Stunden (Custom-Fields, Grid-Anpassungen)
6. Testing & Deployment: 8-12 Stunden

Gesamt: 66-110 Stunden = 3.630-9.350€ bei 55-85€ Stundensatz

Shopware-Projekt (Standard-Agentur)

1. Setup & Grundkonfiguration: 4-8 Stunden (Wizard-basiert)
2. Theme-Entwicklung: 20-32 Stunden (Storefront auf Basis von Theme-Skeleton)
3. Payment Integration: 4-8 Stunden (Plugin-Installation + Konfiguration)
4. Shipping Integration: 4-6 Stunden (Plugin-basiert)
5. Shopping Experiences: 8-16 Stunden (Startseite, Kategorien gestalten)
6. Plugin-Anpassungen: 12-20 Stunden (Falls Customization nötig)
7. Testing & Deployment: 6-10 Stunden

Gesamt: 58-100 Stunden = 3.190-8.500€ bei 55-85€ Stundensatz

Zusätzliche Plugin-Kosten: 300-1.500€ typisch (Advanced Search, B2B Features, etc.)

CS-Cart Projekt

1. Lizenz: 1.450€ (Standard)
2. Setup & Grundkonfiguration: 6-10 Stunden
3. Theme-Anpassung: 16-28 Stunden (Smarty-Templates)
4. Payment Integration: 3-6 Stunden (Built-in Gateways)
5. Shipping Integration: 3-5 Stunden
6. Admin-Training: 4-6 Stunden (Komplexeres Admin-Panel)
7. Testing & Deployment: 6-8 Stunden

Gesamt: 38-63 Stunden = 2.090-5.355€ + 1.450€ Lizenz = 3.540-6.805€

Performance-Benchmarks: Wo liegen die Unterschiede?

Performance-Tests mit identischer Hardware (4 CPU Cores, 8GB RAM, PHP 8.3, Nginx, MariaDB 10.11) und 500 Produkten:

Homepage Load Time (Cold Cache)

1. Sylius 2.1.8: 380ms (Doctrine Query Cache aktiv, HTTP Cache mit Varnish)
2. Shopware 6.6: 420ms (HTTP Cache aktiv)
3. CS-Cart 4.18: 680ms (Standard-Caching)

Kategorie-Seite (50 Produkte, Warm Cache)

1. Sylius: 145ms (Pagerfanta mit Query-Optimierung)
2. Shopware: 180ms (Listing-Loader)
3. CS-Cart: 290ms

Product-Detail-Page (Warm Cache)

1. Sylius: 95ms
2. Shopware: 110ms
3. CS-Cart: 180ms

Admin: Produktliste (500 Produkte)

1. Sylius: 520ms (Sylius Grid mit Pagination)
2. Shopware: 380ms (Vue.js Admin mit Data Abstraction Layer)
3. CS-Cart: 890ms

Interpretation: Shopware hat durch die hochoptimierte Data Abstraction Layer Vorteile im Admin-Bereich. Sylius ist im Frontend minimal schneller durch schlankere Symfony-Architektur. CS-Cart zeigt deutliche Performance-Defizite durch ältere Architektur.

Wann welche Plattform? Entscheidungskriterien

Sylius wählen wenn:

1. ✅ Symfony-Expertise vorhanden ist
2. ✅ Hochgradig individuelle Shop-Logik gefordert wird
3. ✅ Headless/API-First Architektur gewünscht ist
4. ✅ Vollständige Lizenzfreiheit wichtig ist (auch bei >1M€ Umsatz)
5. ✅ Modern Stack (PHP 8.5, Doctrine ORM 3) Priorität hat
6. ✅ Testgetriebene Entwicklung (TDD/BDD) praktiziert wird
7. ✅ Langfristige Kontrolle über Codebase gewünscht ist

Shopware wählen wenn:

1. ✅ Schneller Time-to-Market erforderlich ist
2. ✅ Content-Marketing wichtig ist (Shopping Experiences)
3. ✅ Umfangreiches Plugin-Ökosystem benötigt wird
4. ✅ Kunde <1M€ GMV erwartet (Community Edition ausreichend)
5. ✅ Klassischer Merchant-Shop mit Standard-Prozessen
6. ✅ Deutsches Ökosystem wichtig ist (Zahlungsanbieter, Versender)
7. ✅ Kunde eventuell später auf kostenpflichtige Editionen upgraden will

CS-Cart wählen wenn:

1. ✅ Multi-Vendor Marktplatz von Anfang an benötigt wird
2. ✅ Budget für Lizenz vorhanden ist
3. ✅ Entwicklungsaufwand minimiert werden soll
4. ✅ Russischer Markt bedient werden soll (starke russische Community)
5. ❌ Nicht empfohlen für langfristige Enterprise-Projekte (proprietär, veraltete Architektur)

Migration von Shopware CE zu Sylius: Ein Fallbeispiel

Ein praktisches Szenario: Ein B2C-Shop läuft auf Shopware Community Edition, erreicht 950.000€ GMV und wächst weiter. Die Fair Usage Policy greift bei Überschreiten der 1M€ Grenze.

Alternativen:

1. Shopware Rise buchen: Ab 600€/Monat = 7.200€/Jahr laufende Kosten
2. Zu Sylius migrieren: Einmalig 80-120 Stunden Migrationsaufwand

Migrations-Aufwand zu Sylius:

// Sylius Import Command für Shopware-Daten
namespace App\Command;

use Sylius\Component\Core\Model\ProductInterface;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class ImportShopwareDataCommand extends Command
{
    protected static $defaultName = 'app:import:shopware';
    
    public function __construct(
        private EntityManagerInterface $entityManager,
        private FactoryInterface $productFactory,
        private Connection $shopwareConnection
    ) {
        parent::__construct();
    }
    
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        // Shopware Produkte via SQL-Export importieren
        $products = $this->shopwareConnection->fetchAllAssociative(
            'SELECT * FROM product WHERE active = 1'
        );
        
        foreach ($products as $shopwareProduct) {
            /** @var ProductInterface $syliusProduct */
            $syliusProduct = $this->productFactory->createNew();
            $syliusProduct->setCode($shopwareProduct['product_number']);
            
            // Translation handling
            $syliusProduct->setCurrentLocale('de_DE');
            $syliusProduct->setName($shopwareProduct['name']);
            $syliusProduct->setDescription($shopwareProduct['description']);
            
            $this->entityManager->persist($syliusProduct);
        }
        
        $this->entityManager->flush();
        
        return Command::SUCCESS;
    }
}

Migrations-Zeitplan:

1. Woche 1-2: Datenexport aus Shopware, Sylius-Setup, Theme-Grundgerüst
2. Woche 3-4: Datenmigration (Produkte, Kunden, Bestellungen)
3. Woche 5-6: Theme-Finalisierung, Payment/Shipping Integration
4. Woche 7-8: Testing, Schulung, Go-Live

Kosten-Nutzen: Einmalig 4.400-10.200€ vs. 7.200€/Jahr wiederkehrend = Amortisation nach 7-17 Monaten

Best Practices für Sylius-Entwicklung

1. Channels richtig nutzen

# config/packages/sylius_channel.yaml
sylius_channel:
    channels:
        web_de:
            hostname: 'shop.example.de'
            locales: ['de_DE']
            currencies: ['EUR']
            theme: 'default'
        web_at:
            hostname: 'shop.example.at'
            locales: ['de_AT']
            currencies: ['EUR']
            theme: 'default_at'

2. Custom Product Attributes effizient definieren

// src/Entity/Product/Product.php
namespace App\Entity\Product;

use Sylius\Component\Core\Model\Product as BaseProduct;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ORM\Table(name: 'sylius_product')]
class Product extends BaseProduct
{
    #[ORM\Column(type: 'string', nullable: true)]
    private ?string $ean = null;
    
    #[ORM\Column(type: 'json')]
    private array $technicalSpecs = [];
    
    public function getEan(): ?string
    {
        return $this->ean;
    }
    
    public function setEan(?string $ean): void
    {
        $this->ean = $ean;
    }
}

3. Performance: Doctrine-Queries optimieren

// src/Repository/ProductRepository.php
public function findByTaxonWithVariants(TaxonInterface $taxon): array
{
    return $this->createQueryBuilder('p')
        ->addSelect('variant')
        ->addSelect('image')
        ->leftJoin('p.variants', 'variant')
        ->leftJoin('p.images', 'image')
        ->innerJoin('p.productTaxons', 'productTaxon')
        ->andWhere('productTaxon.taxon = :taxon')
        ->setParameter('taxon', $taxon)
        ->getQuery()
        ->getResult();
}

4. API-First mit API Platform

// Automatische API-Endpunkte
#[ApiResource(
    operations: [
        new Get(),
        new GetCollection(),
        new Post(security: "is_granted('ROLE_ADMIN')"),
        new Put(security: "is_granted('ROLE_ADMIN')"),
        new Delete(security: "is_granted('ROLE_ADMIN')")
    ],
    normalizationContext: ['groups' => ['product:read']],
    denormalizationContext: ['groups' => ['product:write']]
)]
#[ApiFilter(SearchFilter::class, properties: ['name' => 'partial'])]
class Product extends BaseProduct
{
    #[Groups(['product:read', 'product:write'])]
    private string $name;
}

Fazit: Sylius als strategische Entscheidung für 2025

Sylius 2.1.8 demonstriert die Reife der Plattform: PHP 8.5 Support bereits bei Release, Symfony 7.4 LTS Kompatibilität und moderne Architektur-Patterns machen es zur attraktivsten Open-Source Alternative für anspruchsvolle E-Commerce-Projekte. Während Shopware Community Edition durch die Fair Usage Policy faktisch limitiert wird und CS-Cart hohe Lizenzkosten verursacht, bleibt Sylius vollständig frei – auch für Shops mit mehreren Millionen Euro Umsatz.

Für Agenturen mit Symfony-Expertise ist Sylius die logische Wahl: Entwickler arbeiten mit vertrauten Tools, Tests lassen sich problemlos implementieren, und die Architektur erlaubt maximale Flexibilität. Der initiale Mehraufwand von 10-15% gegenüber Shopware wird durch langfristige Vorteile kompensiert: Keine Lizenz-Überraschungen, vollständige Code-Kontrolle und zukunftssichere Technologie.

Die Entscheidung ist weniger eine Frage der Features – alle drei Plattformen können technisch die meisten Anforderungen erfüllen – sondern eine Frage der strategischen Ausrichtung: Wollt ihr auf einem proprietären System aufbauen (CS-Cart), eine kommerzielle Open-Source Lösung mit Einschränkungen nutzen (Shopware) oder vollständige Kontrolle mit modernster Technologie (Sylius)? Für nachhaltige, langfristige E-Commerce-Projekte gibt Sylius 2.1.8 die überzeugendste Antwort.

Dennis Schwenker-Sanders entwickelt seit 2015 E-Commerce-Lösungen mit Symfony und unterstützt Agenturen bei der technischen Umsetzung von Sylius- und Shopware-Projekten. Aktuelle Informationen zu Symfony-basierten E-Commerce-Projekten finden sich auf d-schwenker.de.

Quellen

1. Sylius GitHub Releases: github.com/Sylius/Sylius/releases
2. Sylius 2.1 Announcement: sylius.com/blog
3. Shopware Community Edition: shopware.com/de/community
4. Shopware Documentation: docs.shopware.com
5. CS-Cart Multi-Vendor: cs-cart.com/compare
6. Packagist Sylius: packagist.org/packages/sylius/sylius