PagibleAI CMS is an open-source CMS for teams that want visual content management without moving their content, data, or infrastructure to a hosted platform:

• (https://pagible.com

It runs inside a Laravel 11–13 application and is installed through Composer. This lets you use the application’s existing authentication, business logic, database, storage, and deployment infrastructure instead of maintaining a separate CMS stack.

Editors get a Vue 3 administration interface with structured content, drag-and-drop page trees, reusable elements, media management, immutable revision history, previews, and scheduled publishing.

Content can be delivered through JSON:API, managed through GraphQL, or rendered as a traditional website using Blade. PagibleAI supports SQLite, MariaDB, MySQL, PostgreSQL, and SQL Server, including database-native full-text search.

The CMS is divided into Composer packages, so it does not have to be installed as an all-or-nothing platform. A project can combine the administration interface and core content model with only the APIs, search integration, payment provider, AI tools, or frontend themes it needs.

AI-assisted editing is optional and provider-independent. It supports writing, translation, transcription, image generation, and image manipulation. Compatible agents can also manage content through explicit, version-aware MCP operations.

What’s new in PagibleAI CMS 0.12

Frontend access control and private media: Pages can be public, limited to authenticated users, or protected by named access rules. Files associated with restricted content can be stored privately and delivered only after authorization. Optional Stripe, Paddle, and Mollie integrations can grant page access through subscriptions or one-time payments.

Five additional themes: Bold, Estate, Journal, Luxury, and Style provide starting points for product websites, real-estate projects, publications, fashion sites, and premium brands. Each theme includes reusable demo content and additional content blocks that can be adapted to an individual project.

Expanded administration tools: Pages, reusable elements, and files now support more individual and bulk-editing operations. The release also improves sorting, list and filter updates, drag-and-drop uploads, previews, SVG handling, and audio and video controls.

PagibleAI CMS 0.12 is now available under the permissive MIT license.

Feedback from people working with structured content, editorial workflows, multi-site installations, private content, or CMS migrations would be very welcome. Which parts of these workflows usually cause the most friction in the CMS you use today?

• PagibleAI CMS on GitHub (https://github.com/aimeos/pagible)
• PagibleAI documentation (https://pagible.com/documentation)
• Build a custom PagibleAI distribution (https://pagible.com/build-custom-pagibleai-distributions)

PagibleAI CMS is a set of open-source packages that adds content management directly to an existing Laravel application.

• https://pagible.com

It is installed through Composer and runs within your application, so you keep control of authentication, business logic, content, data, and infrastructure.

The packages combine a Vue 3 administration interface with structured content, hierarchical page trees, reusable elements, version history, previews, scheduled publishing, full-text search, GraphQL, JSON:API, and optional AI-assisted editing.

PagibleAI supports SQLite, MariaDB, MySQL, PostgreSQL, and SQL Server, including database-native full-text search. It can be used for anything from a small blog to a multi-domain or multi-tenant application.

The project is modular rather than an all-or-nothing CMS. You can build a custom distribution containing only the packages your Laravel project needs.

Laravel-native rather than a hosted platform

Editors get visual content management, drag-and-drop page trees, immutable revisions, media handling, and reusable content.

Developers can expose content through JSON:API, manage content via GraphQL API, use Blade for traditional server-rendered sites, extend the content schemas, and integrate the CMS with the rest of the Laravel application.

AI features are optional and provider-independent. They cover writing, translation, transcription, image generation, and image manipulation. The MCP integration also enables compatible agents to manage content through explicit, version-aware operations.

What’s new in PagibleAI CMS 0.12

• Frontend access control and private media: Pages can be public, restricted to authenticated users, or protected by named access rules. Stripe, Paddle, and Mollie integrations can grant access after payment. Media attached to protected content can be stored privately and delivered only after authorization.

• Five additional themes: Bold, Estate, Journal, Luxury, and Style provide starting points for product sites, real-estate projects, publications, fashion sites, and premium brands. Each includes reusable demo content and additional content blocks.

• More capable administration tools: Pages, elements, and files now support more individual and bulk-editing operations. The release also improves sorting, list and filter updates, drag-and-drop uploads, previews, SVG handling, and audio and video controls.

Feedback from Laravel developers would be very welcome, especially from those working with structured content, multi-tenancy, database portability, or AI-assisted editorial workflows.

• PagibleAI on GitHub (https://github.com/aimeos/pagible)
• PagibleAI documentation (https://pagible.com/documentation)
• Build a custom PagibleAI distribution (https://pagible.com/build-custom-pagibleai-distributions)

We've released Upscheme 1.3.0:

• https://upscheme.org

Upscheme is a framework-independent PHP package built on Doctrine DBAL. It updates database schemas and can migrate data without maintaining a table of previously executed migrations.

Each task describes the expected schema. When it runs, Upscheme inspects the database and applies the necessary changes. The same task can work on a new installation, an older database, or a partially upgraded deployment.

Install it with Composer:

composer require aimeos/upscheme:^1.3

A migration looks like this:

<?php

namespace Aimeos\Upscheme\Task;

use Aimeos\Upscheme\Schema\Table;

return new class($this) extends Base
{
    public function up()
    {
        $this->db()->table('users', function(Table $table) {
            $table->id();
            $table->string('email')->unique();
            $table->string('display_name');
            $table->bool('active')->default(true);
            $table->datetime('last_login')->null(true);
        });
    }
};

Run the migrations with a Doctrine DBAL connection configuration:

$config = [
    'driver' => 'pdo_mysql',
    'host' => getenv('DB_HOST') ?: '127.0.0.1',
    'dbname' => getenv('DB_NAME'),
    'user' => getenv('DB_USER'),
    'password' => getenv('DB_PASSWORD'),
];

\Aimeos\Upscheme\Up::use(
    $config,
    __DIR__ . '/migrations'
)->verbose()->up();

If the users table doesn't exist, it is created. If it already exists, missing columns and indexes are added and changed definitions are updated.

Suppose the application later needs a timezone. Add it to the same definition:

$table->string('timezone')->default('UTC');

Running Upscheme again updates existing installations. New installations receive the complete schema from the same task. Removing a definition won't silently delete the corresponding database object; destructive operations must be written explicitly.

Tasks can declare dependencies using before() and after(). This is useful when plugins or independently developed packages modify the same database. Migration directories from several packages can be passed to Upscheme, and the tasks are ordered by their declared dependencies instead of relying only on timestamps.

Upscheme also supports multiple database connections, data operations inside migration tasks, and generating migration files from an existing database. It uses Doctrine DBAL for MySQL, MariaDB, PostgreSQL, SQLite, SQL Server, and other relational databases.

There are no down() migrations. Once a migration has transformed or deleted data, a reverse method can't necessarily restore it. Destructive changes should be covered by backups, while corrections are applied with forward migrations.

Version 1.3.0 improves the code produced by the database-to-migration generator. The CI matrix now includes PHP 8.4 and 8.5, while PHP 7.4 remains supported. The release also contains compatibility, test, and documentation updates.

Source and documentation: https://github.com/aimeos/upscheme

Packagist: https://packagist.org/packages/aimeos/upscheme

PHP Map version 4.1 is now available, the PHP array/collection package for working with arrays and collections easily.

• https://php-map.org

The release is mostly about improving performance of edge cases in the collection internals, plus stricter behavior around malformed input.

Some benchmarks from the release commits:

Method / path	v4.0	v4.1	Improvement
isList()	857.993 ms	0.643 ms	99.93%
tree() 20k chain	8523.8 ms	47.6 ms	99.4%
diff() array fallback	376.1 ms	3.5 ms	99.1%
intersect() array fallback	390.5 ms	13.2 ms	96.6%
find() reverse	417.330 ms	47.152 ms	88.70%
findKey() reverse	416.939 ms	47.737 ms	88.55%
suffix() string	259.5 ms	93.1 ms	64.1%
flat()	338.8 ms	123.8 ms	63.5%
recursive walk()	277.0 ms	103.9 ms	62.5%
suffix() callback	318.1 ms	124.5 ms	60.9%

The release also adds broader callable support, better iterable handling, clearer null-vs-missing behavior for nested paths, stricter invalid-key validation, and a more robust tree() builder.

Why PHP Map?

Instead of:

$list = [['id' => 'one', 'value' => 'v1']];
$list[] = ['id' => 'two', 'value' => 'v2']
unset( $list[0] );
$list = array_filter( $list );
sort( $list );
$pairs = array_column( $list, 'value', 'id' );
$value = reset( $pairs ) ?: null;

Just write:

$value = map( [['id' => 'one', 'value' => 'v1']] )
    ->push( ['id' => 'two', 'value' => 'v2'] )
    ->remove( 0 )
    ->filter()
    ->sort()
    ->col( 'value', 'id' )
    ->first();

There are several implementations of collections available in PHP but the PHP Map package is feature-rich, dependency free and loved by most developers according to GitHub.

Feel free to like, comment or give a star :-)

• Documentation: https://php-map.org
• Repo:https://github.com/aimeos/map

I just tagged Aimeos Prisma 0.5. This is a PHP package for calling AI providers through one API across text, image, audio, and video:

• https://php-prisma.org

Prisma started as a sister project to Prism PHP for AI APIs outside the usual text-only path. It is now framework-independent, but it fits cleanly into Laravel apps when you want provider switching across LLMs, embeddings, image generation/editing, audio, video, or OpenAI-compatible gateways.

composer require aimeos/prisma

Basic Laravel usage looks like this:

use Aimeos\Prisma\Prisma;

$answer = Prisma::text()
    ->using('anthropic', ['api_key' => config('services.anthropic.key')])
    ->write('Summarize this customer request')
    ->text();

$image = Prisma::image()
    ->using('openai', ['api_key' => config('services.openai.key')])
    ->imagine('a product photo of a ceramic coffee cup on a white table')
    ->binary();

Most of the 0.5 work is aimed at application concerns: streaming responses, more useful schemas, text embeddings, and better visibility into provider calls.

Streaming

stream() is now part of the text API. In Laravel, you can hand the response to response()->eventStream():

use Aimeos\Prisma\Prisma;
use Illuminate\Support\Facades\Route;

Route::get('/chat', function () {
    $response = Prisma::text()
        ->using('openai', config('services.openai'))
        ->ensure('stream')
        ->stream('Explain queues in Laravel in a few paragraphs');

    return response()->eventStream(function () use ($response) {
        foreach ($response->stream() as $chunk) {
            if (is_string($chunk)) {
                yield $chunk;
            }
        }
    });
});

The same provider object still handles system prompts, models, tools, and prior messages:

$response = Prisma::text()
    ->using('anthropic', ['api_key' => config('services.anthropic.key')])
    ->withMessages([
        ['role' => 'user', 'content' => 'I need a laptop recommendation.'],
        ['role' => 'assistant', 'content' => 'What is your budget and workload?'],
    ])
    ->stream('Around 1500 EUR, mostly PHP development.');

One practical detail: usage, citations, tool steps, finish reason, and metadata are complete after the stream has been consumed.

Schemas

Structured output now has explicit modes, a more capable schema builder, and validation:

use Aimeos\Prisma\Prisma;
use Aimeos\Prisma\Schema\Schema;

$schema = Schema::for('ticket', [
    'title' => Schema::string()->required(),
    'priority' => Schema::string()->enum(['low', 'normal', 'high'])->required(),
    'tags' => Schema::array()->items(Schema::string()),
]);

$response = Prisma::text()
    ->using('openai', ['api_key' => config('services.openai.key')])
    ->structure('Extract a support ticket from: Checkout is broken for EU cards', $schema);

$ticket = $response->structured();
$errors = $schema->validate($ticket);

By default, Prisma uses a provider's native structured-output mode where available. You can also choose JSON mode for schemas that are too large or awkward for strict provider limits:

$response = Prisma::text()
    ->using('openai', ['api_key' => config('services.openai.key')])
    ->structure('Extract a support ticket', $schema, [], ['mode' => 'json']);

0.5 also adds anyOf, $defs, and $ref support in the schema builder.

Text embeddings

Text embeddings are now available through the same text provider surface:

use Aimeos\Prisma\Prisma;

$vectors = Prisma::text()
    ->using('openai', ['api_key' => config('services.openai.key')])
    ->ensure('vectorize')
    ->vectorize([
        'Laravel queues process jobs in the background.',
        'Prisma provides a common API for AI providers.',
    ], 256)
    ->vectors();

Embedding support is available across several text providers, including OpenAI, Azure, Bedrock, Cohere, Gemini, Mistral, Ollama, and Alibaba.

Observability

0.5 adds request-scoped observation for provider calls. This is useful for logging model, provider, operation, duration, errors, usage, and metadata without wrapping every call yourself:

use Aimeos\Prisma\Prisma;
use Aimeos\Prisma\Values\Observation;

$response = Prisma::text()
    ->observe(function (Observation $observation) {
        logger()->info('ai.operation', $observation->toArray());
    })
    ->using('openai', ['api_key' => config('services.openai.key')])
    ->model('gpt-4.1-mini')
    ->write('Draft a changelog entry');

usage() and meta() now return typed value objects, while still allowing raw provider fields:

$usage = $response->usage();

$usage->promptTokens();
$usage->completionTokens();
$usage->totalTokens();

$model = $response->meta()->model();

Laravel AI and Prism PHP

Prisma can reuse Laravel AI and Laravel MCP tools inside its own tool loop:

use Aimeos\Prisma\Tools;

$tool = Tools::laravel(MyLaravelTool::class);

$response = Prisma::text()
    ->using('anthropic', ['api_key' => config('services.anthropic.key')])
    ->withTools([$tool])
    ->withMaxSteps(5)
    ->write('Use the project tools to answer this request');

Prism-PHP is still the natural choice for building a Laravel-first chat. Prisma sits at a lower provider/media layer: text, embeddings, image/audio/video operations, OpenAI-compatible gateways, and framework-independent reuse.

Docs: https://php-prisma.org

GitHub: https://github.com/aimeos/prisma

I would be interested in feedback from Laravel developers, especially around the streaming API, schemas, embeddings, and observability in real Laravel apps.

Hey everyone

I'm one of the maintainers of PagibleAI CMS (aimeos/pagible), an open-source CMS built for Laravel rather than bolted on top of it. We just shipped 0.11 and it's a big one, so I wanted to share it here and get some honest feedback from the community.

• https://pagible.com

If you've ever wanted a CMS that feels like a normal Laravel package — Eloquent models, migrations, service providers, policies, Octane-ready — instead of a framework-inside-a-framework, this is built around that idea.

What's new in 0.11

• Real-time collaboration — multiple editors on the same page at once, powered by Laravel Reverb. Live presence, no "someone else saved over your changes."
• Concurrent-edit protection with three-way merge — if two people do edit the same version, changes are merged instead of clobbered.
• Themes — ships with Clean, Paper, Glass and Premium. Swap a site's entire look from a single setting. Bring your own theme with custom content-element templates.
• AI image studio — generate images and then edit them in place: isolate (transparent background), inpaint, repaint, upscale and uncrop. All from the editor.
• 33-tool MCP server — drive the whole CMS from Claude, Cursor or any MCP client: create pages, edit content, generate images, run imports.
• Five databases, one codebase — SQLite, MariaDB, MySQL, PostgreSQL and SQL Server, with a custom Laravel Scout engine doing full-text search natively on each.
• Backup & restore commands and Cashier payment integration.

What makes it outstanding

The thing I'm proudest of isn't any single feature — it's that it's genuinely a Laravel package, not a platform pretending to be one:

• Versioned, immutable content. Every save is a snapshot. Editors see the latest draft, the public sees what's published, and you can roll back any page, element or file. Drafts and published content coexist instead of fighting each other.
• Multi-tenancy is built in, not an add-on. A global scope on every model keyed by tenant_id — run many sites from one install without leaking data across them.
• Real nested-set page tree with all tree mutations wrapped in transactions and cache locks. Hierarchy that doesn't fall apart under concurrent edits.
• AI that's actually wired into the model layer — content generation, translation, transcription and image manipulation are first-class operations on your content, not a chat widget glued to the side.
• Small, auditable footprint. The whole thing is a monorepo of focused sub-packages (core, admin, ai, graphql, jsonapi, search, mcp, theme, …). Use only what you really need.

Why you should use it

• You get a CMS you can reason about: Eloquent models, policy-based permissions, and named roles (editor / publisher / viewer / admin) that expand from config.
• A read-only JSON:API and a GraphQL API (Lighthouse) for headless setups, plus a Blade theme layer for traditional server-rendered sites — same content, your choice of frontend.
• It deploys anywhere a Laravel app does and runs on whichever database you already operate.
• AI is opt-in and provider-agnostic — switch models between OpenAI, Google Gemini or Anthropic without rewriting your app.
• It's open source and PRs/issues are genuinely welcome.

If you're building a content-driven app and you've been gluing together a headless SaaS CMS, an admin panel and a search service — this is all of that, in one Laravel-native package.

Happy to answer anything about the architecture (versioning, multi-tenancy, the Scout engine, the MCP server). Honest criticism very welcome :-)

---

Links

• ⭐ GitHub: https://github.com/aimeos/pagible
• 🌐 Live demo: https://demo.pagible.com
• 🌐 Website: https://pagible.com

Prisma is a light-weight PHP package for working with 25+ AI providers across text, image, audio, and video through a single unified API. It started as a sister project to Laravel's Prism package but has since grown into a framework-independent library that goes far beyond text — and it works great alongside Laravel AI in your projects.

• https://php-prisma.org

Prisma + Laravel AI

Prisma is not a replacement for Laravel AI / Prism — it's a complement. Use Laravel AI for what it's great at (chat, agents, Laravel integration), and reach for Prisma when you need multimedia capabilities that Laravel AI doesn't cover: image and audio manipulation, translation, video description, upscaling, and more.

They work together seamlessly — Prisma has a built-in Laravel tool adapter, so your existing Laravel AI tools work out of the box:

$tool = Tools::laravel(new MyLaravelTool());

When to use Prisma alongside Laravel AI:

• You need image, audio, or video capabilities (imagine, inpaint, upscale, transcribe, speak, demix, etc.)
• You want access to multimedia providers like StabilityAI, ElevenLabs, Deepgram, RemoveBG, Black Forest Labs, Clipdrop, Ideogram, etc.
• You need structured output, tool calling, or text generation with providers not yet supported by Laravel AI
• You want a single unified API across 25+ providers for all media types

Drop it into any Laravel project:

composer require aimeos/prisma

use Aimeos\Prisma\Prisma;

// Generate images
$image = Prisma::image()
    ->using('openai', ['api_key' => config('services.openai.key')])
    ->imagine('a grumpy cat in a tuxedo')
    ->binary();

// Transcribe audio
$text = Prisma::audio()
    ->using('deepgram', ['api_key' => config('services.deepgram.key')])
    ->transcribe($audioFile)
    ->text();

// Text generation — useful for providers not yet in Laravel AI
$response = Prisma::text()
    ->using('ollama', ['url' => 'http://localhost:11434'])
    ->write('Explain quantum computing in simple terms');

What's new in 0.4

Text generation — write() and structure() across 14 providers (OpenAI, Anthropic, Gemini, Bedrock, Mistral, Groq, Cohere, Deepseek, Alibaba, xAI, Perplexity, OpenRouter, Ollama, and more). Structured output uses each provider's native API, not prompt hacking:

use Aimeos\Prisma\Schema\Schema;

$schema = Schema::for('person', [
    'name' => Schema::string(),
    'age' => Schema::integer(),
]);

$data = Prisma::text()
    ->using('openai', ['api_key' => config('services.openai.key')])
    ->structure('Extract: John is 30 years old', $schema)
    ->structured(); // ['name' => 'John', 'age' => 30]

Tool calling — Full agentic loop with auto-execution. Define tools, Prisma handles the back-and-forth. Reuse your existing Laravel tools or create new ones. Supports provider tools (web search, code execution), concurrent execution, decorators, per-tool call limits, and custom error handlers:

// Reuse an existing Laravel/Prism tool
$tool = Tools::laravel(new MyLaravelTool());

// Or create one from scratch
$weather = Tools::make('weather', 'Get weather', Schema::for('weather', [
    'city' => Schema::string()->required(),
]), fn($args) => json_encode(['temp' => '22°C', 'city' => $args['city']]));

$response = Prisma::text()
    ->using('anthropic', ['api_key' => config('services.anthropic.key')])
    ->withTools([$tool, $weather])
    ->withMaxSteps(5)
    ->write('What is the weather in Berlin?');

Also new: thinking budgets / extended reasoning, normalized citations, rate limit info, client retry with exponential backoff, finish reasons, Ollama support, Alibaba audio/image, Google Translate + DeepL, and the license changed to MIT.

The full picture

25+ providers across four domains: audio (demix, denoise, speak, transcribe...), image (imagine, inpaint, upscale, vectorize...), text (write, structure, translate + tools), and video (describe). Only dependency is Guzzle. PHP 8.2+.

composer require aimeos/prisma

• Docs: https://php-prisma.org
• GitHub: https://github.com/aimeos/prisma

Would love feedback from Laravel devs. Anyone else been looking for multimedia AI support to use alongside Laravel AI?

And if you like it, leave a star on Github :-)

Prisma is a light-weight PHP package that gives you a single, unified API for working with 25+ AI providers across text, image, audio, and video. Started as a sister project to Laravel's Prism package, Prisma is now a framework independent composer library outperforming Prism in many areas.

• https://php-prisma.org

Why Prisma?

Every AI provider has its own API, its own request format, its own response structure. If you want to use OpenAI for text generation but Anthropic for tool calling and StabilityAI for images, you end up writing three different integrations with three different error handling approaches.

Prisma abstracts all of that behind one clean interface. Switching providers is a one-line change:

use Aimeos\Prisma\Prisma;

// Using OpenAI
$response = Prisma::text()
    ->using('openai', ['api_key' => 'xxx'])
    ->write('Explain quantum computing in simple terms');

// Switch to Anthropic — same interface, same response object
$response = Prisma::text()
    ->using('anthropic', ['api_key' => 'xxx'])
    ->write('Explain quantum computing in simple terms');

echo $response->text();

This works the same way for images, audio, and video:

// Generate an image with OpenAI
$image = Prisma::image()
    ->using('openai', ['api_key' => 'xxx'])
    ->imagine('a grumpy cat in a tuxedo')
    ->binary();

// Transcribe audio with Deepgram
$text = Prisma::audio()
    ->using('deepgram', ['api_key' => 'xxx'])
    ->transcribe($audioFile)
    ->text();

No vendor lock-in. No rewriting your app when you want to try a different model. And if a provider doesn't support a method, you can check with ->has('imagine') or enforce it with ->ensure('imagine').

What's new in 0.4

Text generation — write() and structure() across 14 providers (OpenAI, Anthropic, Gemini, Bedrock, Mistral, Groq, Cohere, Deepseek, Alibaba, xAI, Perplexity, OpenRouter, Ollama, and more). Structured output uses each provider's native API, not prompt hacking:

use Aimeos\Prisma\Schema\Schema;

$schema = Schema::for('person', [
    'name' => Schema::string(),
    'age' => Schema::integer(),
]);

$data = Prisma::text()
    ->using('openai', ['api_key' => 'xxx'])
    ->structure('Extract: John is 30 years old', $schema)
    ->structured(); // ['name' => 'John', 'age' => 30]

Tool calling — Full agentic loop with auto-execution. Define tools, Prisma handles the back-and-forth. Supports provider tools (web search, code execution), Laravel/Symfony adapters, concurrent execution, decorators, per-tool call limits, and custom error handlers:

$weather = Tools::make('weather', 'Get weather', Schema::for('weather', [
    'city' => Schema::string()->required(),
]), fn($args) => json_encode(['temp' => '22°C', 'city' => $args['city']]));

$response = Prisma::text()
    ->using('anthropic', ['api_key' => 'xxx'])
    ->withTools([$weather])
    ->withMaxSteps(5)
    ->write('What is the weather in Berlin?');

Also new: thinking budgets / extended reasoning, normalized citations, rate limit info, client retry with exponential backoff, finish reasons, Ollama support, Alibaba audio/image, Google Translate + DeepL, and the license changed to MIT.

The full picture

25+ providers across four domains: audio (demix, denoise, speak, transcribe...), image (imagine, inpaint, upscale, vectorize...), text (write, structure, translate + tools), and video (describe). Only dependency is Guzzle. PHP 8.2+.

composer require aimeos/prisma

• Docs: https://php-prisma.org
• GitHub: https://github.com/aimeos/prisma

Would love feedback, especially from anyone juggling multiple AI provider SDKs. What providers or features would you want to see next?

And if you like it, leave a star on Github :-)

We just released 2026.04 of Aimeos, the Laravel e-commerce framework for custom online shops, market places, complex B2B apps and gigacommerce. Here's what's new:

• Laravel 13 support: The Aimeos Laravel integration, the stand-alone shop and the headless distribution all ship on Laravel 13 out of the box.
• Customer CSV import: Full import pipeline with address/property support, regex validation, group filtering and admin UI upload — completing CSV import for products, catalogs, suppliers and now customers.
• Product feed extension: New extension for generating Google Merchant and Idealo product feeds. Includes several configuration options to customize the exported products and details.
• Security hardening: XSS prevention via HTML sanitization in the CMS, GraphQL query depth/complexity limits, and tighter permission checks in the admin API.
• Ready for PHP 9: Minimum raised to PHP 8.1, all deprecations removed across core and 30+ extensions, fully tested on PHP 8.5. PHPStan static analysis added at level 4 with zero errors.

---

If you haven't heard of Aimeos — it's an open-source e-commerce framework (LGPLv3) that integrates directly into Laravel as a composer package. Instead of running a separate shop system, you add e-commerce to your existing Laravel app.

• Feels like Laravel: Uses your routes, middleware, auth, queues and Blade views. Aimeos plugs into your app rather than replacing it. You stay in Artisan, Eloquent and your usual workflow.
• Headless-first: Full JSON:API and GraphQL APIs included. Build your frontend in Vue, React, Livewire, Inertia — or use the included server-side rendered HTML components.
• Multi-tenant / multi-site: Run multiple shops from a single Laravel installation with separate catalogs, pricing, languages and currencies per site.
• Scales up: The same codebase powers single-product shops and marketplaces with millions of products. ElasticSearch and Solr integrations available for high-volume search.
• Extensible: 30+ extensions for payments, shipping, CMS, feeds, Redis caching, search engines and more. Custom extensions follow the same pattern without touching core code.
• No SaaS lock-in: Self-hosted, you own your data. No per-transaction fees, no vendor gatekeeping.

Simply get started with one command:

composer create-project aimeos/aimeos

• Website: https://aimeos.org/laravel-ecommerce-package
• GitHub: https://github.com/aimeos/aimeos
• Docs: https://aimeos.org/docs/laravel
• Demo: https://demo.aimeos.org

If you like Aimeos, give it a star :-)

We just released Aimeos 2026.04, the PHP e-commerce framework for custom online shops, market places, complex B2B apps and #gigacommerce:

• Ready for PHP 9: Minimum raised to PHP 8.1, all deprecations removed across core and 30+ extensions, fully tested on PHP 8.5. PHPStan static analysis added at level 4 with zero errors.
• Laravel 13 & Symfony 8: Day-one support for the latest framework versions. The stand-alone shop and headless distributions ship on Laravel 13 out of the box.
• Customer CSV import: Full import pipeline with address/property support, regex validation, group filtering and admin UI upload — rounding out CSV import for products, catalogs, suppliers and now customers.

• Product feed extension: New extension for generating Google Merchant and Idealo product feeds. Includes several configuration options to customize the exported products and details.

• Security hardening: XSS prevention via HTML sanitization in the CMS, GraphQL query depth/complexity limits, and tighter permission checks in the admin API.
• PHPUnit 12: Stricter test isolation and deprecation handling across the entire test suite.

For those who haven't come across Aimeos before — it's an open-source e-commerce framework (LGPLv3) built for PHP developers who want full control over their shop without being locked into a monolithic platform. A few things that set it apart:

• Framework-native: Integrates directly into Laravel, Symfony or TYPO3 as a composer package. You use your framework's routing, auth, middleware and tooling — Aimeos plugs into it rather than replacing it.

• Headless-first: Full JSON:API and GraphQL APIs out of the box. Use any frontend you want — Vue, React, mobile apps, or the included server-side rendered HTML client.

• Multi-tenant / multi-site: Built-in support for running multiple shops from a single installation with separate catalogs, pricing, languages and currencies per site.

• Scales from small to large: The same architecture powers single-product shops and marketplaces with millions of products. ElasticSearch and Solr integrations are available for high-volume search.

• Extensible, w/o forking: 30+ extensions for payments, shipping, CMS, feeds, caching (Redis), search engines and more. Custom extensions follow the same pattern without touching core code.

• No SaaS lock-in: You host it yourself, own your data, and can switch or extend anything.

• GitHub: https://github.com/aimeos/aimeos

• Docs: https://aimeos.org/docs

• Demo: https://demo.aimeos.org

If you like Aimeos, give it a star :-)