Forem: toco

PagibleAI CMS: The AI-Powered CMS for Editors and Developers

toco — Wed, 08 Oct 2025 16:27:30 +0000

In the rapidly evolving world of digital content, a Content Management System (CMS) needs to be more than just a place to store text and images. It needs to be intelligent, intuitive, and immensely powerful.

Enter PagibleAI CMS – a revolutionary platform engineered to delight both content editors and developers, blending cutting-edge AI capabilities with robust, modern architecture. It's the CMS that truly understands your needs, offering the ease of use typically found in platforms like WordPress, combined with the structured power and flexibility reminiscent of Contentful.

For Editors: Unleash Your Creativity with AI

Content creation has never been easier or more intelligent. PagibleAI CMS is designed from the ground up to empower editors, putting AI support directly into their hands:

AI-Powered Content Generation: Bid farewell to writer's block. With PagibleAI, you can generate engaging, SEO-optimized content effortlessly, leveraging advanced AI to kickstart your drafts or refine existing text.
Seamless AI Image Creation: Enhance your articles and pages with stunning visuals. Our integrated AI can create suitable, high-quality images directly within the CMS, ensuring your content is always visually appealing and on-brand.
Multi-Language Translation with AI: Expand your global reach without the hassle. PagibleAI's integrated AI can translate your content into over 35 languages, making your message accessible to a wider audience and significantly streamlining localization efforts.
Intuitive WYSIWYG Editor: Experience true What You See Is What You Get editing. The full WYSIWYG editor provides an immediate, accurate preview of your content as you create it, eliminating guesswork and ensuring consistency.
Effortless Content Management: Organize your digital assets with unparalleled ease. Drag-and-drop functionality for pages and content elements simplifies reordering and restructuring, giving you complete control over your site's layout.

PagibleAI CMS streamlines the entire content lifecycle, allowing editors to focus on crafting compelling stories and rich experiences, not wrestling with complex tools.

For Developers: Power, Flexibility, and Modern APIs

While editors are enjoying the intuitive interface, developers will appreciate the deep technical capabilities that make PagibleAI CMS a joy to work with:

Robust JSON REST and GraphQL APIs: Built API-first, PagibleAI offers extremely fast JSON REST APIs for efficient content delivery and versatile GraphQL APIs for powerful, flexible content administration. Integrate with any frontend framework or application with ease.
Built on Laravel: Leveraging the robustness and elegance of the Laravel framework, PagibleAI provides a solid, extensible foundation. This means developers can easily customize, extend, and integrate the CMS into existing Laravel applications, enjoying a familiar and powerful ecosystem.
Open Source Freedom: Benefit from the transparency, community support, and customization possibilities of an open-source platform. PagibleAI CMS is available as a Laravel package, allowing you to install it seamlessly into your projects and tailor it to your exact specifications.

Cloud-Native and Scalable for Every Need

Whether you're running a personal blog or managing content for a multi-national enterprise, PagibleAI CMS scales with you. Its cloud-native architecture ensures:

Exceptional Performance: Optimized for speed and efficiency, delivering content quickly to your users worldwide.
Infinite Scalability: From lightweight SQLite databases for small blogs to distributed database clusters handling billions of requests for large corporations, PagibleAI CMS adapts to your needs without compromise.
Reliability and Flexibility: Designed to leverage the elasticity and distributed nature of modern cloud platforms, ensuring high availability and resilience.

The Future of Content Management is Here

PagibleAI CMS represents a new era in content management – one where artificial intelligence enhances human creativity, developers are empowered by modern tools, and scalability is a given. It's not just a CMS; it's a strategic asset for any organization looking to optimize its digital presence.

Ready to revolutionize your content workflow? Discover PagibleAI CMS today and experience next-level content management:

https://pagible.com/

AI revolution in eCommerce

toco — Wed, 25 Jan 2023 15:59:45 +0000

Since the availability of ChatGPT, a large language machine learning model from OpenAI, artificial intelligence seems to be on the rise. Now, editors writing texts might be seen as a dying species because tools like ChatGPT can do the same in seconds and in almost the same quality. This is similar to how DeepL, a translation tool based on machine learning, changed the translation industry before.

Especially in eCommerce, search engines like Google require a lot of relevant text before pages show up at the top of search results. This can now be automated in Aimeos, the first eCommerce framework with direct integration of ChatGPT and DeepL. This allows editors to generate any text in seconds and have it translated into 29 languages.

Generate and translate any content

Aimeos admin backend with ChatGPT and DeepL integration
Not only texts based on existing product specifications are possible, but also helpful information for customers. Depending on the prompt entered, ChatGPT also generates, for example, styling tips for fashion or health information for allergy sufferers – everything about which there are already publications on the Internet that have been incorporated into the training of the AI model.

Although ChatGPT can generate texts in different languages, the quality is better the more texts are available in the respective language on the topic. Since DeepL can translate good quality texts into less common languages, this will greatly accelerate the professionalization of online stores in these language regions.

Test yourself

You can try Aimeos and the capabilities of ChatGPT and DeepL yourself in the Aimeos admin demo:

https://admin.demo.aimeos.org/

Aimeos is the ultra-fast, cloud-native, API-first PHP eCommerce framework for building custom online shops, marketplaces and complex B2B applications. It’s available as Laravel package, Symfony bundle and TYPO3 extension.

Aimeos vs. Bagisto : Comparing differences

toco — Wed, 30 Sep 2020 08:58:12 +0000

Aimeos and Bagisto are the most popular Laravel ecommerce packages. There have been a lot of noise around ecommerce for Laravel lately and this article tries to shed some light into the discussion.

Aimeos

Aimeos strongly focuses on performance and scalability so it's suitable for small shops to setups bigger than Amazon with 1+ billion items. The flexibility and extensibility of Aimeos makes it particularly suitable for highly customized online shops, complex B2B applications and custom marketplaces.

Link: https://aimeos.org/

Bagisto

Bagisto is suitable for small to medium sized stores. It offers the most important shop features and focuses on simplicity for users so more complex requirements are not its domain. Bagisto uses Vue.js, even in the front-end, and you need to know the tool chain well if you want to customize it.

Link: https://bagisto.com/

Comparison

Both are Open Source and share some features which I have left out in this comparison to focus only on the differences. The supported features have been retrieved from their official web sites and other official sources:

	Aimeos	Bagisto
Rating	4.8/5 (18 reviews)	4.3/5 (6 reviews)
Github Stars	17,100+	5000+
Scalability	very high	medium
Extensibility	very high	medium
Configurability	2500+ options	a few
Modularity	completely modular	modular approach
Databases	MySQL, PostgreSQL, SQL Server	MySQL
Translations	30+	11
Payment gateways	100+	PayPal, 10 (paid)
Multiple currencies	yes	partially
Block/tier pricing	yes	no
Customer/group prices	extension (paid)	yes
Multiple tax per price	yes	no
Basket rule system	yes	no
One-page checkout	yes	no (?)
Time based data	yes	no
Products bought together	yes	no
Promoted products/category	yes	no
Last seen products	yes	no
Watched products	yes	no
Configurable data sets	yes	no
XML import/export	yes	no
SQL injection protection	yes	no
Content Security Policy	yes	no
Elasticsearch	extension (paid)	cache only
Multi-tentant SaaS	yes	extension (paid)
AI-based text generation	yes	no
AI-based text translation	yes	no
AI-based image search	no	yes
SEO	fully optimized	no schema.org
CMS	full-featured	minimal
POS	no	extension (paid)
Code quality	9/10	?
Unit tests	6000+	a few
Update customized shops	easy	hard

Bagisto offers more (paid) extensions than Aimeos but that's due to the fact that Bagisto base system hasn't many features included while in Aimeos all major features are part of the Aimeos core and thus available for free.
Nevertheless, Bagisto offers some special extensions like an NTF marketplace builder for $10,000 that are not available for Aimeos.

The ratings of Aimeos and Bagisto are taken from Capterra, a platform for product ratings where verified users can write detailed high quality reviews for products. Bagisto makes a lot of noise around their Trustpilot rating which is much better than their Capterra rating. But in Trustpilot, users only rate the customer service, not the product itself so the Trustpilot rating is equal to the service sub-category rating in Capterra only.

Backend

The administration back-ends of Aimeos and Bagisto differ in layout and handling while the navigation is more or less similar.

Aimeos

The admin back-end of Aimeos has a card based layout with a light and dark theme. Major attributes are:

Fully mobile optimized
Supports right-to-left (RTL) languages like arabic
Available in several languages

Bagisto

The back-end of Bagisto tries to resemble the Magento back-end in some way but is very light in terms of colors (only white and grey). Major attributes are:

Not mobile optimized
Doesn't support RTL languages
Only available in English

Performance

Aimeos and Bagisto published some performance data but they are not directly comparable. Nevertheless, here are the raw numbers for the product category pages:

	Aimeos	Bagisto
App server	Apache: 8 core / 16 GB RAM	Apache: 2 core / 4 GB RAM
Data server	Elasticsearch: 8 core / 32 GB RAM	MySQL: 1 core / 2 GB RAM
SKUs	1.010 billion (1,010,000,000)	1.3 million (1,300,000)
Categories	1111	7
Request/sec	~600	~100
Response time	110 - 160 ms	14,000 - 22,000 ms
Hosting	Profihost	AWS

Notes

The Aimeos test system has almost 1000x more products and 150x more categories than the Bagisto test system
The Aimeos app server (they are handling the web requests) is 4x as powerful as the Bagisto one
The Aimeos app server can handle 6x the requests of the Bagisto one
The response time for a complete page load of the Aimeos setup is 125x better than the Bagisto one

What you can see is that the Bagisto test system has been sized way to small for the load because the response time for a complete page load is at least 14sec and up to 22sec. Such response times render every eCommerce site unusable and the Bagisto setup seems to be only good for ~10 concurrent users.

Sources

Aimeos: #gigacommerce – Aimeos shop performance with 1 billion items
Bagisto: Bagisto eCommerce Benchmarking Report

Conclusion

Which one is suited better for your needs depends on your requirements. If you need a scalable system that can be highly customized, you should have a deeper look at Aimeos. Bagisto is the right choice if you need one of their special extensions. For simple shop requirements, both will do their job and it depends on personal preferences, e.g. which admin back-end you prefer.

Demo installations:
Aimeos: https://demo.aimeos.org/
Bagisto: https://demo.bagisto.com/

PHP Map: Advanced collection methods

toco — Wed, 11 Mar 2020 11:29:25 +0000

The PHP Map package for collections contains many methods to ease your day to day work. They are extremely helpful in a lot of situations where you’ve written custom code up to now. This tutorial explains some of the most useful ones you don’t want to miss any more!

Installation

To use the PHP Map package, you have to add it to your composer based application:

composer req aimeos/map

Afterwards, there will be a map() function available, that creates a Map object which offers the methods explained.

col(): Map key/value pairs

There are numerous times when you need to transform an existing array into a list of key/value pairs. Think about a list of database records for example which should be indexed by ID instead of a sequencial index. The col() method creates that without the necessity of a loop:

$rows = [['id' => 1, 'code' => 'a'], ['id' => 3, 'code' => 'd']];
$result = map( $rows )->col( 'code', 'id' );

// Result equals:
map( [1 => 'a', 3 => 'd'] );

This does also work with objects if they implement the magic PHP __get() method.

collapse() and flat(): Transform multi-dimensional arrays

Do you remember the last time when you had a multi-dimensional array and you needed a flat array of all elements? If you know the maximum depth, you can nest several loops but if not, you need to write a recursive function, which is very cumbersome. The Map object offers the flat() method, that can to do that in one line:

$array = [[1, 2], [3, [4, 5]]];
$result = map( $array )->flat();

// Result equals:
map( [1, 2, 3, 4, 5] );

There’s a similar method named collapse(), that does almost the same but keeps the key of each value. Thus, it will overwrite elements with duplicate keys (also numeric keys):

$array = [['a' => 1, 'b' => 2], ['c' => 3, ['a' => 4, 'b' => 5]]];
$result = map( $array )->collapse();

// Result equals:
map( ['a' => 4, 'b' => 5, 'c' => 3] );

Both methods accept the number of levels they should collapse or flatten as parameter. That way it’s easy to keep e.g. the third level and above unflattened or uncollapsed.

concat(), merge() and union(): Differences in combining arrays

In PHP, you can combine arrays using array_merge() or the + operator but their results are different. The PHP map package also offers the concat() method:

$one = [0 => 'a', 'b' => 2];
$two = ['b' => 3, 0 => 4];

$result = map( $one )->concat( $two );
//equals map( [0 => 'a', 'b' => 2, 1 => 3, 2 => 4] );

$result = map( $one )->merge( $two );
//equals map( [0 => 'a', 'b' => 3, 1 => 4] );

$result = map( $one )->union( $two );
//equals map( [0 => 'a', 'b' => 2] );

concat() combines the elements of both arrays but doesn’t care about their keys and the resulting list will contain all elements of both arrays. merge() which uses the array_merge() function overwrites existing string keys but renumbers numeric keys. union() is the same as using the + operator and doesn’t add elements whose keys does already exist.

equals(): Test if arrays contains the same elements

To compare arrays, PHP only offers the == and === operators. They return only true if both array contains the same elements with the same keys (and the same order in case of ===). Contrary, the equals() method of the Map object can also test arrays without checking the keys:

$one = ['a', 'b'];
$two = ['b', 'a'];

map( $one )->equals( $two ); // true
map( $one )->equals( $two, true ); // false

When passing true as second parameter, equals() works like the == operator.

find(): Return the first matching element

Sometimes, you need the first element from an array that matches your needs. The Map object offers the find() method which allows you to pass a closure function as parameter. This anonymous function can check whose element matches your needs:

map( ['a', 'c', 'e'] )->find( function( $value, $key ) {
    return $value >= 'b';
} );

// Result equals 'c'

If no matching value is found, null is returned. If you pass true as second parameter, the search for the matching element will be reversed and you will get the last matching element.

first(), last(), get() and pull(): Advanced ways to retrieve an element

Fetching the first, last or any element of a list of elements is very handy and most useful in many cases. But the PHP Map object offers more than that. What if those methods don’t return null if no element is found but throw an exception or execute a closure? Instead of:

if( ( $item = map( [] ) )->first() === null ) {
    throw new \Exception( 'error' );
}

if( ( $item = map( [] ) )->last() === null ) {
    // fetch and return record from database
}
$id = $item->getId();

you can simply write:

$id = map( [] )->first( new \Exception( 'error' ) )->getId();

$id = map( [] )->last( function() {
    // fetch and return record from database
} )->getId();

All methods (first(), last(), get() and pull()) methods accept either an exception that’s thrown or a closure that’s executed if no element is available. Thus, it saves you the annoying checks that make you code full of if/else statements.

If you pass an exception, the exception object is created whether it’s used or not. This is no problem as long as you don’t do that in a loop. Then, create one exception object before the loop and pass only the variable to the methods.

in(): Check if several elements are in the list

To test if an value is in a list of elements with in() isn’t much different than using in_array(). But what if you need to do that several times with different elements? Then, in() takes away the burden of doing that within a loop:

map( ['a', 'b', 'c'] )->in( 'b' ); // true
map( ['a', 'b', 'c'] )->in( ['b', 'a'] ); // true
map( ['a', 'b', 'c'] )->in( ['d', 'a'] ); // false

The in() method of the Map object checks if all elements of the passed array are available in the list and only then it returns true.

toJson(): Encode everything into JSON

When working with APIs, you almost always need to encode the result into its JSON representation. The PHP map object offers a convenient way to transform all elements to JSON:

map( ['a', 'b', ['c', 'd'] )->toJson();

Like the PHP json_encode() method, it accepts a parameter for passing options that are used during encoding the elements. There are two that you may find extremely useful:

map( ['a', 'b', ['c', 'd'] )->toJson( JSON_FORCE_OBJECT|JSON_HEX_QUOT );

JSON_FORCE_OBJECT always creates {}, even for empty lists to avoid being encoded as []. If you add JSON output to HTML data attributes for storing something you need for dynamic Javascript features later on, JSON_HEX_QUOT saves you from generating invalid HTML.

walk(): Visit each value in a multi-dimensional array

You receive a multi-dimensional array from an HTML form and want to make sure that all values are of a certain type or doesn’t contain HTML tags? Then, the walk() method of the PHP Map object is your friend:

map( ['a', 'b', ['c', '<b>d</b>'] )->walk( function( &$val ) {
    $val = strip_tags( $val );
} );

You can also create a mapping based on the list you pass as second parameter:

$mapping = [1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'];

map( [1, 2, [3, 4] )->walk( function( &$val, $key, $data ) {
    $val = $data[$val] ?? $val;
}, $mapping );

// Result equals
map( ['one', 'two', ['three', 'four']] )

method(): Register your own methods

The best of all comes last: You can extend the PHP Map object by your own methods! This is extremely handy if you need the same code several times and different places. To register your own method, just do this:

\Aimeos\Map::method( 'strrev', function( $sep ) {
    return strrev( join( '-', $this->list ) );
} );

Your closure function has access to the internal array of elements using $this->list and you can read and/or modify that internal array of the Map object. You can use your new method the same way as any other method of the Map object afterwards:

map( ['a', 'b'] )->strrev( '-' );
// returns "b-a"

Conclusion

The PHP Map object offers some great methods that can simplify your code drastically and you will never want to miss them any more. Especially the possibility to register own methods to extend the Map object dynamically gives your great power in a few lines of code.

PHP Collections: Array to Map

toco — Tue, 07 Jan 2020 16:34:56 +0000

Arrays are the working horse of PHP, the programming language used by the vast majority of web applications. An array seems to be incredible simple to use but things get complicated and ugly when PHP functions for array manipulation come into play. Are you tired of hard to read code with excessive error handling too? Then collections can be the answer.

Why?

Here’s a common example of how array manipulation is done in most PHP code:

$list = [
    ['id' => 'one', 'value' => 'value1'],
    ['id' => 'two', 'value' => 'value2'],
    null
];

$list[] = ['id' => 'three', 'value' => 'value3'];    // add element
unset( $list[0] );                                   // remove element
$list = array_filter( $list );                       // remove empty values
sort( $list );                                       // sort elements
$pairs = array_column( $list, 'value', 'id' );       // create ['three' => 'value3']
$value = reset( $pairs ) ?: null;                    // return first value

It adds/removes elements, sorts and transforms the content and retrieves the first element. You can’t write that shorter or more elegant and moreover, you need to check almost all array functions for errors.

Using maps

The map composer package offers an easy API comparable to jQuery or Laravel collections:

composer req aimeos/map

When using the Map object, you can do the same as above more elegant with less code:

$list = [
    ['id' => 'one', 'value' => 'value1'],
    ['id' => 'two', 'value' => 'value2'],
    null
];

$value = map( $list )                                // create Map
    ->push( ['id' => 'three', 'value' => 'value3'] ) // add element
    ->remove( 0 )                                    // remove element
    ->filter()                                       // remove empty values
    ->sort()                                         // sort elements
    ->col( 'value', 'id' )                           // create ['three' => 'value3']
    ->first();                                       // return first value

And contrary to PHP arrays, you don’t have to care about error handling because either, there are no errors possible or the Map object will throw an exception if something is really wrong.

Of course, you can use the Map object still like a plain PHP array:

$map[] = ['id' => 'three', 'value' => 'value3'];
$value = $map[0];
count( $map );
foreach( $map as $key => value );

In addition, Map objects allow you to pass anonymous functions to a lot of methods. Thus, you can process and transform the elements according to your current needs, e.g. using the each() method:

$map->each( function( $val, $key ) {
    echo $key . ': ' . $val;
} );

You can even extend Maps dynamically by own methods. This is especially useful if you need a transformation of the Map elements more often and at several places of your code:

Map::method( 'strrev', function( $sep ) {
    return strrev( join( '-', $this->items ) );
} );
Map::from( ['a', 'b'] )->strrev( '-' );

The best part is using a Map like a jQuery object, where methods are applied to all objects of the Map. Then, you can create expressive code in one line:

class MyClass {
    private $code;
    private $status;

    public function __construct( $code ) { $this->code = $code; }
    public function setStatus( $s ) { $this->stat = $s; return $this; }
    public function getCode() { return $this->code; }
}

$objects = Map::from( ['a' => new MyClass( 'x' ), 'b' => new MyClass( 'y' )] );
$result = $objects->setStatus( 1 )->getCode()->toArray();

The example will call setStatus(1) on all objects and creates a new Map with the returned values. Because setStatus() returns the same object ($this), we can apply another method on all objects afterwards (getCode()). The results of getCode() is wrapped in a Map object again and toArray() returns a plain PHP array which consists of:

['a' => 'x', 'b' => 'y']

Available methods

The Map object contains methods for almost all array functions available and more like collapse(), flat(), toJson() or methods found in the Javascript Array prototype. Here’s a list of its methods and for documentation, have a look at the Map readme at GitHub where you can also check the code.

function map() : Creates a new map from elements
arsort() : Reverse sort elements with keys
asort() : Sort elements with keys
chunk() : Splits the map into chunks
clear() : Removes all elements
col() : Creates a key/value mapping
collapse() : Collapses multi-dimensional elements
concat() : Combines the elements
copy() : Creates a new copy
count() : Returns the number of elements
diff() : Returns the missing elements
diffAssoc() : Returns the missing elements and checks keys
diffKeys() : Returns the missing elements by keys
each() : Applies a callback to each element
empty() : Tests if map is empty
equals() : Tests if map contents are equal
filter() : Applies a filter to the map elements
find() : Returns the first matching element
first() : Returns the first element
flip() : Exchanges keys with their values
flat() : Flattens multi-dimensional elements
from() : Creates a new map from passed elements
get() : Returns an element by key
has() : Tests if a key exists
in() : Tests if element is included
includes() : Tests if element is included
intersect() : Returns the shared elements
intersectAssoc() : Returns the shared elements and checks keys
intersectKeys() : Returns the shared elements by keys
isEmpty() : Tests if map is empty
join() : Returns concatenated elements as string
keys() : Returns the keys
krsort() : Reverse sort elements by keys
ksort() : Sort elements by keys
last() : Returns the last element
map() : Applies a callback to each element and returns the results
merge() : Combines elements overwriting existing ones
method() : Registers a custom method
pipe() : Applies a callback to the map
pop() : Returns and removes the last element
pull() : Returns and removes an element by key
push() : Adds an element to the end
random() : Returns random elements
reduce() : Computes a value for the map content
remove() : Removes an element by key
replace() : Replaces elements recursively
reverse() : Reverses the array order
rsort() : Reverse sort elements
search() : Find the key of an element
set() : Overwrites an element
shift() : Returns and removes the first element
shuffle() : Randomizes the element order
slice() : Returns a slice of the map
sort() : Sorts elements
split() : Splits a string into map elements
splice() : Replaces a slice by new elements
toArray() : Returns the plain array
toJson() : Returns the elements in JSON format
uasort() : Sorts elements with keys using callback
uksort() : Sorts elements by keys using callback
union() : Combines the element without overwriting
unique() : Returns unique elements
unshift() : Adds an element at the beginning
usort() : Sorts elements using callback
values() : Returns all elements with new keys

Again, the Map documentation offers descriptions, explains parameters/return values and has examples for each method. Some methods are even better documented than the corresponding PHP array function.

Conclusion

Map objects are an easy to use and elegant way to handle PHP arrays. After using it for a while you won’t want to remember the times before. If you’ve already worked with jQuery and like it’s simplicity, you will feel like home when using appropriate lists of objects in your application.

As the Map methods are using the native array functions or are highly optimized, it’s also save to use them in large scale applications. The documentation contains a section about the Map performance and hints to avoid performance bottlenecks.

Laravel E-Commerce - Open Source Top 4

toco — Thu, 12 Dec 2019 18:54:34 +0000

Laravel eCommerce describes online shop, marketplace and B2B eCommerce solutions based on the Laravel PHP framework. They can be standalone applications, headless API microservices or packages that can be installed in any Laravel application to add eCommerce features to existing setups.

Laravel is the most popular PHP framework and that for good reasons:

Easy to customize and use
Really great community
Fast and scalable

These reasons make Laravel a perfect choice for building online shops and eCommerce applications. For our favorite PHP framework, e-commere packages for different purposes exist. Here's a list of the top Laravel eCommerce packages in their category:

Aimeos (eCommerce framework, headless API & shop system)
Bagisto (shop system)
GetCandy (API only)
LaravelShoppingcart (shopping cart)

What packages is best may depend on your own requirements, so let’s have a look which suits best for each case.

Aimeos

Aimeos is the most liked eCommerce framework for Laravel and is build for being as extensible as the Laravel PHP framework itself and integrates into existing Laravel 6/7/8 applications. It’s feature rich and you can adapt everything to your needs regardless of what your requirements are.

Homepage: https://aimeos.org/Laravel

Supports: Laravel 6.x LTS, 7.x, 8.x

Positive:

Supports all current Laravel versions
Multi channel, multi vendor and multi inventory support
Has multi-tenant SaaS support including custom domains
Ultra fast render times of 20ms and response times of 100ms
Has virtual, configurable and custom products incl. bundles
Sell every product as subscription with recurring payment
Supports discount rules and vouchers
100+ payment gateways via Omnipay PHP library
JSON REST API build on the jsonapi.org standard
Extension to build own market places available
Great documentation available

Negative:

Learning curve due to its huge feature set and extensible architecture

Bagisto

Bagisto is a stand-alone application that can't be integrated into already existing Laravel applications. It primarily targets small business and the middle east area with native RTL (right-to-left) support.

Homepage: https://bagisto.com

Supports: Laravel 7.x

Positive:

Has configurable, group, bundle and virtual products
Has multi channel and multi inventory support
Supports discount rules
JSON REST API build on jsonapi.org standard
Extension to build own market places available
Lots of videos from the company about Bagisto

Negative:

Not suitable for existing Laravel applications
No real multi-currency support (fixed conversion only)
Almost all available payment integrations must be paid for
~100 tables incl. fixed structures that are hard to extend
Requires ElasticSearch or Algolia for fast search
CMS features are too simple for real use
Limited documentation

GetCandy

GetCandy is a headless API package that offers a REST API only. There's also an admin package for managing products, customers and orders. No front-end is included because that you need to build on your own.

Homepage: https://getcandy.io

Supports: Laravel 5.7

Positive:

Progressive web applications (PWA) backend
Should scale because it requires ElasticSearch as storage (no MySQL)

Negative:

Unsupported and outdated Laravel version
No front-end as example available
Very limited feature set
Payment integrations are not available
Slow development (weeks and months between commits)
Limited documentation
Still in alpha stage
Future is uncertain at the moment

LaravelShoppingcart (shopping cart)

A shopping cart package is small, easy to use and contains a limited features. The LaravelShoppingcart package consists of a cart/whishlist only and need to be integrated into an existing Laravel 5 application. You have to implement products and checkout yourself.

Homepage: https://github.com/Hardevine/LaravelShoppingcart

Supports: 5.x, 6.x, 7.x and 8.x

Positive:

Only package that supports all Laravel versions since Laravel 5
Easy to learn and relative easy to integrate
If you already have products, it adds the cart features

Negative:

Feature set is very limited
A checkout process isn't available
Won't scale to higher volumes
No example template is included
Github account contains lots of unresolved issues
No support for Laravel 5.8 and later

Conclusion

Aimeos is the top eCommerce framework for Laravel if you need a highly customizable solution that is able to scale. Bagisto offers a simple shop system based on Laravel if you start from a green field. LaravelShoppingcart is a good choice for a few products you need a cart for while GetCandy is promising if you want a PWA frontend only and build that on your own.

Let’s discuss your own experiences :-)