Für Entwickler

Plugins bauen. Keine Workarounds.

AcelleMail ist eine Laravel-11+-E-Mail-Marketing-Plattform mit vollständigem, unverschlüsseltem PHP-Quellcode — und einem typisierten Hook-System, mit dem Ihre Plugins Sending-Driver, Payment-Gateways, KI, eigene UI und sogar REST APIs ergänzen. Ohne Core-Fork.

Echte Plugins, die heute ausgeliefert werden

acelle/ai athena/evs rencontru/postal acelle/console
myvendor/loyalty/ PLUGIN SOURCE composer.json 240 B routes.php 1.2 KB src/ ServiceProvider.php entry Controllers/ Models/ database/migrations/ resources/ views/ lang/ index.json auto $ php artisan plugin:init … HOOK SYSTEM no core touches ACELLEMAIL Laravel 11+ · PHP 8.3+ layout.head.assets layout.body.close admin.sidebar.groups register_sending_* page.{ctrl}.{slot} customer_added sidebar-menu-items dispatch_*_job + many more…

Warum sich Entwickler für AcelleMail entscheiden

Gebaut auf dem Framework, das Sie schon kennen.
Erweitert über Muster, die Sie schon nutzen.

Open Source PHP / Laravel

Vollständiger, unverschlüsselter PHP-Quellcode liegt jeder Lizenz bei. Jede Klasse anpassen, jeden Service überschreiben, in Ihren eigenen Namespace forken — Ihr Code, Ihre Regeln. Auf Laravel 11+ aufgesetzt, sodass das Framework, das Sie kennen, die Schwerarbeit erledigt.

$ grep -r "protected function" vendor/acelle/

Plugin-Architektur

Legen Sie einen Composer-Ordner unter storage/app/plugins/<vendor>/<name>/ ab und die Anwendung lädt ihn automatisch. Der ServiceProvider injiziert Routen, Views, Migrations, Hooks — aktivieren, deaktivieren, sauber entfernen.

$ php artisan plugin:init myvendor/loyalty

Token-authentifizierte REST API

CRUD-Endpoints für Kampagnen, Listen, Subscriber, Templates, Automatisierungen. Webhook-Events für jedes Domain-Ereignis. Drop-in für SaaS-Frontends, mobile Apps oder andere Laravel-Services. Dieselbe API, die Plugins nutzen, nutzen auch externe Clients — keine zweitklassigen Endpoints.

GET /api/v1/campaigns · POST /api/v1/lists

Selbstgehostet auf Ihrer Infrastruktur

Ihr Server, Ihre DB, Ihre Subscriber-Daten. Kein Vendor-Lock-in. Einmal für die Lizenz bezahlen; danach nur die SMTP-Kosten (z. B. Amazon SES bei 0,10 $/1K). Deployen Sie überall, wo PHP läuft — Bare Metal, Kubernetes, Forge, Laravel Vapor. Skaliert so, wie Ihr Stack skaliert.

· PHP 8.3+ · MySQL / MariaDB · Redis (optional)

Was Sie mit Plugins bauen können

14 Erweiterungsflächen.
Jede mit einem echten Produktivbeispiel von heute.

Ein Plugin ist ein eigenständiges Laravel-Paket, das auf der Platte lebt — mit eigenem Namespace, eigenen DB-Tabellen, Routen, Views, Controllern, Models — und sich über ein typisiertes Hook-System in den Core einklinkt, statt mit include-Hacks.

Driver & Integrationen · 4

Sending-Server / Driver REGISTRY
register_sending_server_driver
rencontru/postal — Postal-MTA-Driver als einzelnes Drop-in-Plugin
E-Mail-Verifizierung / Zustellbarkeit REGISTRY
REGISTRY + FILTER
athena/evs — Verifizierungs-Subsystem mit Admin-UI
Payment-Gateways REGISTRY
REGISTRY
Mitgelieferte Stripe / PayPal / Braintree / Paystack / Razorpay / Coinbase zeigen das Muster
KI / Chatbot / Assistenten REGISTRY
REGISTRY + EVENT
acelle/ai — Chatbox + Sparkle + Observability

UI & Seiten · 5

Eigene UI-Injection REGISTRY
layout.head.assets / layout.body.before_close / admin.sidebar.groups
acelle/ai Chatbox + Sparkle-Popover
Seitenbezogene Content-Slots REGISTRY
page.{ctrl}.{action}.{slot}
page.maillist.show.body, page.campaign.index.sidebar
Admin-Seiten ROUTE
Laravel routes
/rui/admin/ai-usage, /rui/admin/ai-audit, /rui/admin/ai-conversations
Kundenseitige Seiten ROUTE
Laravel routes
/plugins/acelle/ai/dashboard
REST-APIs ROUTE
Routes + api.access_token
/api/v1/ai/* in acelle/ai

Daten & Lifecycle · 2

Eigene Eloquent-Models + DB-Tabellen BEHAVIOR
Plugin-isolated migrations
acelle/ai liefert 8 Models / 12 Migrations mit vendor-präfixierten Tabellennamen
Übersetzungen (18 Locales) REGISTRY
add_translation_file
acelle/ai liefert 162 lang-Dateien (18 × 9)

Verhalten & Flow · 3

Webhook-Listener / Domain-Events EVENT
Hook::on(…)
customer_added, plan_changed, subscription_terminated
Verhaltens-Overrides BEHAVIOR
Hook::set / setIfEmpty / perform
dispatch_list_import_job — Import-Logik vollständig ersetzen
Filterketten FILTER
Hook::modify / filter
sidebar-menu-items, Mutation des Inhalts vor dem Versand, Redirect-URLs

Ein einzelnes Plugin kann beliebige dieser Flächen kombinieren — acelle/ai nutzt 7 von 14 in einem Paket.

Das Hook-System

Vier typisierte Erweiterungsmuster. Keine überraschenden Overrides. Keine stillen Konflikte.

Der Core importiert nie Plugin-Code — er deklariert lediglich Erweiterungspunkte. Plugins hören zu und reagieren. Vier Muster, jedes mit klarer Rolle. Konflikte werfen sofort eine Exception.

1

REGISTRY add() + collect()

Plugin steuert Einträge zu einer Liste bei. Core fragt „wer hat einen Sending-Driver?" und Ihr Plugin antwortet „ich habe einen."


Hook::add('register_sending_server_driver', fn () => [
    'type'   => 'myvendor-foo',
    'driver' => \MyVendor\Foo\Driver::class,
]);


$drivers = Hook::collect('register_sending_server_driver');
2

EVENT on() + fire()

Plugin reagiert auf ein Ereignis. Rückgabewerte werden verworfen.


Hook::on('customer_added', function ($customer) {
    LoyaltyPoints::award($customer, 100, 'welcome');
});


Hook::fire('customer_added', [$customer]);
3

BEHAVIOR set() + perform()

Plugin ersetzt ein Stück Core-Logik vollständig. Nur ein Plugin kann ein bestimmtes Verhalten beanspruchen — Konflikte werfen sofort eine Exception.


Hook::set('dispatch_list_import_job',
    fn ($list, $f) => new MyFasterImportJob($list, $f));


Hook::setIfEmpty('dispatch_list_import_job',
    fn ($list, $f) => new DefaultImportJob($list, $f));
$job = Hook::perform('dispatch_list_import_job', [$list, $f]);
dispatch($job);
4

FILTER modify() + filter()

Plugin transformiert einen Wert durch eine Kette von Callbacks. Jeder Callback erhält den aktuellen Wert und gibt den veränderten Wert zurück.


Hook::modify('sidebar-menu-items', function (array $items) {
    $items[] = [
        'label' => 'Loyalty',
        'url'   => route('lp.dashboard'),
    ];
    return $items;
});


$menu = Hook::filter('sidebar-menu-items', $defaultMenu);

Hello World in 5 Minuten

Ein lauffähiges Plugin aus dem Nichts in acht Befehlen.

Das Scaffold erzeugt alles — Composer-Metadaten, ServiceProvider, Beispiel-Model, Beispiel-Migration, Beispielroute, Beispiel-View. Ab da gehört es Ihnen, es weiterzuentwickeln.

  1. 1

    Plugin scaffolden

    Erzeugt das Standard-Ordnerlayout + eine inaktive DB-Zeile.

    bash
    $ php artisan plugin:init myvendor/loyalty
      ✓ Created storage/app/plugins/myvendor/loyalty/
      ✓ DB row inserted  (status: inactive)
      ✓ index.json + ServiceProvider autoloaded
  2. 2

    composer.json bearbeiten

    Composer von Ihrem Namespace und dem ServiceProvider in Kenntnis setzen.

    json
    {
      "name": "myvendor/loyalty",
      "description": "Award points on signup",
      "version": "1.0.0",
      "autoload":  { "psr-4": { "MyVendor\\Loyalty\\": "src/" } },
      "extra":     { "laravel": { "providers": [
        "MyVendor\\Loyalty\\ServiceProvider"
      ] } }
    }
  3. 3

    Eine Migration schreiben

    Plugin-isolierte Tabelle, vendor-präfixierter Name. Läuft beim Aktivieren, rollt beim Löschen zurück.

    php
    Schema::create('myvendor_loyalty_accounts', function (Blueprint $t) {
        $t->id();
        $t->foreignId('customer_id')->constrained()->cascadeOnDelete();
        $t->integer('points')->default(0);
        $t->timestamps();
    });
  4. 4

    Ein Model definieren

    Standard-Eloquent-Model in Ihrem eigenen Namespace.

    php
    namespace MyVendor\Loyalty\Models;
    
    use Illuminate\Database\Eloquent\Model;
    
    class Account extends Model
    {
        protected $table    = 'myvendor_loyalty_accounts';
        protected $fillable = ['customer_id', 'points'];
    }
  5. 5

    Controller und View hinzufügen

    Schlichter Laravel-Controller — der View-Namespace ist Ihr Plugin-Name.

    php
    namespace MyVendor\Loyalty\Controllers;
    
    use Acelle\Http\Controllers\Controller;
    
    class DashboardController extends Controller
    {
        public function index()
        {
            return view('loyalty::dashboard', [
                'accounts' => \MyVendor\Loyalty\Models\Account::orderByDesc('points')->take(10)->get(),
            ]);
        }
    }
  6. 6

    Routen deklarieren

    Dieselbe Route::group, die Sie ohnehin nutzen. Wird vom ServiceProvider::boot() geladen.

    php
    Route::group([
        'middleware' => ['web', 'auth'],
        'namespace'  => '\MyVendor\Loyalty\Controllers',
        'prefix'     => 'plugins/myvendor/loyalty',
    ], function () {
        Route::get('/',          'DashboardController@index')->name('lp.dashboard');
        Route::get('/{account}', 'DashboardController@show');
    });
  7. 7

    Alles in ServiceProvider::boot() verdrahten

    Views + Routen laden; an activate_plugin_… hooken, um beim Aktivieren zu migrieren.

    php
    public function boot(): void
    {
        $this->loadViewsFrom (__DIR__.'/../resources/views', 'loyalty');
        $this->loadRoutesFrom(__DIR__.'/../routes.php');
    
        Hook::on('activate_plugin_myvendor/loyalty', fn () =>
            \Artisan::call('migrate', [
                '--path'  => 'storage/app/plugins/myvendor/loyalty/database/migrations',
                '--force' => true,
            ])
        );
    
        Hook::on('customer_added', fn ($customer) =>
            Models\Account::create(['customer_id' => $customer->id, 'points' => 100])
        );
    }
  8. 8

    Aus dem Admin aktivieren

    Gehen Sie zu /rui/admin/plugins. Migrations laufen automatisch. Das Plugin lebt unter seinem Prefix.

    bash
    ✓ activated  myvendor/loyalty  v1.0.0
      → migrations: 1 ran (myvendor_loyalty_accounts)
      → routes:     2 registered under /plugins/myvendor/loyalty
      → hooks:      2 listening (activate, customer_added)
      → status:     active
    
    → visit /plugins/myvendor/loyalty/  ← live

Sie haben nun ein lauffähiges Plugin. Fügen Sie so viele Models, Controller und Hooks hinzu, wie Ihr Feature verlangt. Tests liegen in tests/; ausgeführt mit php artisan test --testsuite='Plugin: myvendor/loyalty'. Den maßgeblichen Vertrag finden Sie in der Knowledge Base.

Plugin-Lifecycle

Vier Zustände. Vorhersehbare Übergänge. Kein „Lief es jetzt?"-Rätselraten.

Jedes Plugin lebt in genau einem von vier Zuständen. Der aktuelle Zustand bestimmt, welche Hooks feuern, welche Migrations gelaufen sind und was beim nächsten Übergang passiert. Source-grounded gegen docs/plugin/SOURCE_OF_TRUTH.md.

STATE 01 register (inaktiv) Plugin-Ordner entdeckt. index.json + DB-Zeile existieren. Hooks feuern NICHT. STATE 02 active Alle Hooks live. Routen gemountet. Migrations gelaufen. activate_plugin_… einmal gefeuert. STATE 03 inactive (pausiert) Ordner liegt weiter auf der Platte. Hooks pausiert. Routen unmounted. DB-Tabellen unverändert. STATE 04 deleted (entfernt) Ordner entfernt. Migrations zurückgerollt, falls $keepData = false. DB-Zeile entfernt. activate Migrations laufen deactivate Daten bleiben remove $keepData? re-activate activate-Hook läuft NICHT erneut
Register · inaktiv

Entdeckt, nicht laufend

Plugin-Ordner existiert, index.json indiziert, DB-Zeile sagt inactive. Der register() des ServiceProviders lief, doch die Hooks in boot() bleiben deaktiviert, bis Sie auf Aktivieren klicken.

Aktiv

Live, Hooks feuern

Die erste Aktivierung feuert activate_plugin_<name> einmalig — hier laufen die Migrations. Danach sind alle REGISTRY- / EVENT- / FILTER- / BEHAVIOR-Hooks live, bis deaktiviert wird.

Inactive · pausiert

Pausiert, Daten erhalten

Routen unmounten, Hooks gehen aus, doch Ordner + DB-Tabellen bleiben. Re-Activate führt weder Migrations noch den activate-Hook erneut aus — in Produktion gefahrlos togglebar.

Gelöscht

Sauber entfernt

Ordner entfernt, DB-Zeile weg. Bei $keepData = false rollen die Plugin-Migrations zurück — vendor-präfixierte Tabellen werden gelöscht. Core-Tabellen werden nie angefasst.

Echtes Plugin im Schaufenster

acelle/ai — ein komplettes KI-Subsystem in einem einzigen Plugin-Ordner.

Das acelle/ai-Plugin liefert eine vollständige KI-Assistenten-Schicht: Agenten-Chatbox auf jeder Seite, ✨ Sparkle-Textumformulierung in Rich-Text-Feldern, KB-fundierte Coach-Personas (Zustellbarkeit, Segmente, Kampagnen, Formulare) und eine Admin-Observability-Oberfläche über 5 Routen. Eingehängt über 3 Layout-Hooks. Null Core-Änderungen.

acelle/ai-Plugin in Aktion — schwebende AcelleMail-KI-Chatbox-Blase mit ✨ Sparkle-Popover für Ein-Klick-Umformulierung, dazu die Admin-Sidebar-Gruppe des Plugins, gerendert in der AcelleMail-UI

Was es mitbringt

  • Schwebende Chatbox — schlichter Support-Modus + opt-in Agent-Modus, der Tools ruft
  • Sparkle-Popover — Ein-Klick-Umformulieren / Erweitern / Vereinfachen auf jedem Rich-Text-Feld
  • Coach-Personas — domain-bewusste LLM-Helfer, je Screen gescoped
  • Admin-Observability — Nutzung, Audit, Konversationen, Feedback, Self-Improve
  • Engine-Flexibilität — BYO OpenAI, Anthropic oder lokales Ollama
  • Plugin-Landingpage unter /plugins/acelle/ai/dashboard

In Zahlen

8
Eloquent-Models
12
Migrationen
60+
Blade-Templates
100+
Pest-Tests
18 × 9
Locales × lang-Dateien
~35
CSS- + JS-Dateien

Wie es einhängt — 3 Hooks

acelle/ai plugin → CSS / JS assets Hook::add( 'layout.head.assets', fn()=>...); → Chatbox bubble Hook::add( 'layout.body.before_close' ,fn()=>...); → AI sidebar group Hook::add( 'admin.sidebar.groups', fn()=>...); Self-contained. AcelleMail core <head> + acelle-ai-chatbox.css </body> (just before) + <div class="ai-chatbox"> Admin sidebar AI · Settings AI · Usage AI · Conversations

3 REGISTRY-Layout-Hooks — mehr nicht. Dazu seitenspezifische Injektionen, Lifecycle-Event-Listener und eine eigene REST API unter /api/v1/ai/*. Null Core-Änderungen; der Plugin-Ordner ist Drop-in-deploybar.

REST-API

Token-authentifizierte Endpoints. Dieselbe API, die Plugins nutzen.

Nutzen Sie die REST API, um AcelleMail in Ihr eigenes SaaS-Frontend, Ihre mobile App oder Ihren Laravel-Service zu integrieren. Dieselbe API, die Plugins nutzen, nutzen auch externe Clients — keine zweitklassigen Endpoints.

Ressourcen

  • ListenGET/POST/PATCH/DELETE /api/v1/lists[/:uid]
  • Subscriber/api/v1/subscribers · Tags · sub/unsub
  • Kampagnen/api/v1/campaigns[/:uid] · run/pause/resume · Log-CSVs
  • Automatisierungen/api/v1/automations[/:uid] · execute · api/call
  • Sending-Server/api/v1/sending_servers[/:uid]
  • Kunden (admin)/api/v1/customers[/:uid] · assign/change-plan · enable/disable
  • Abonnements (admin)/api/v1/subscriptions[/:uid]

Webhook-Events

Lifecycle (konfiguriert in Admin → Webhooks): new_customer, new_subscription, change_plan, cancel_subscription, terminate_subscription, automation_webhook.
Per-Empfänger-Tracking (je Kampagne): open, click, unsubscribe.

Vollständige API-Referenz →
# Create a list
$ curl -X POST \
    https://your-acelle.example.com/api/v1/lists \
    -H "Authorization: Bearer $ACELLE_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Newsletter",
      "from_email": "hi@example.com",
      "from_name": "Hi Team",
      "subject": "Weekly digest"
    }'

# Add a subscriber
$ curl -X POST \
    .../api/v1/lists/:uid/subscribers \
    -H "Authorization: Bearer $ACELLE_TOKEN" \
    -d '{"EMAIL":"alice@example.com"}'

# Send a campaign
$ curl -X POST \
    .../api/v1/campaigns/:uid/send \
    -H "Authorization: Bearer $ACELLE_TOKEN"

# Receive a webhook
POST /your-webhook-endpoint
{
  "event": "campaign.sent",
  "campaign_uid": "abc123",
  "list_uid": "xyz789",
  "sent_at": "2026-05-06T12:34:56Z"
}

Open-Source-Ethos

Ihr Code, für immer. Keine Black Boxes, keine wiederkehrenden Gebühren, kein Namespace-Squatting.

Unverschlüsselter Quellcode

Jede Zeile PHP, die auf Ihrem Server läuft. Kein ionCube, kein SourceGuardian, keine Obfuskation. git diff für Ihre Anpassungen. grep, um alles zu finden.

Lebenslange Updates

Jedes AcelleMail-Release seit 2016 liegt in Ihrer CodeCanyon-Download-Historie. Ziehen Sie, was Sie wollen, wann Sie wollen. Kein Abo-Druck.

Ihr Namespace, für immer

Plugins leben unter MyVendor\MyPlugin\ — vollständig isoliert von Acelle\*-Core. Über Composer an Ihr Team oder einen Marktplatz verteilbar.

Einmalige Lizenz

Zahlen Sie $80 (Regular) oder $199 (Extended für SaaS). Keine Abos, keine Pro-Abonnenten-Gebühr, keine Pro-E-Mail-Gebühr. Die Rechnung ändert sich nicht, wenn Sie wachsen.

Ressourcen & Community

Dokumentation, Beispiel-Plugins und eine direkte Leitung zum Support.

Vollständige Entwicklerdokumentation

Elf source-grounded Deep-Dives. Springen Sie direkt zur gesuchten Seite:

Hub durchstöbern →

Plugin-Entwicklungs-Guide

Fünf hostseitige Dateien, der Boot-and-Load-Flow, die vier Lifecycle-Zustände, die zwei Injection-Schichten — das mentale Modell, das der Rest der Doku voraussetzt.

/developers/plugin-architecture →

REST API Referenz

Authentifizierung, Endpoint-Katalog, Webhook-Payloads, Fehlerformen — eigene Landingpage mit Beispielen.

/api →

Das Hook-System — vier Muster

REGISTRY / EVENT / BEHAVIOR / FILTER — die vier Erweiterungsformen, die Plugins nutzen, mit echten Call-Sites aus dem Core, Konfliktsemantik und sechs Anti-Patterns.

/developers/hook-system →

Sending-Driver — vollständiges Plugin-Muster

Ein brandneues MTA-Backend ausliefern, ohne den Core zu forken. Der register_sending_server_driver-Vertrag, neun Capability-Marker und fünf Stolperfallen aus dem Postal-Plugin.

/developers/sending-drivers →

Plugin-Schaufenster — acelle/ai

Das kanonische komplexe Plugin von Anfang bis Ende durchgegangen. Acht Models, vierzehn Migrations, achtzehn Locales, jede Hook-Fläche, die Chatbox-UI plus ein vierstufiges Lernrezept.

/developers/showcase →

Entwickler-Support

Hängen Sie an einem Hook-Vertrag oder einer Lifecycle-Frage fest? Schreiben Sie uns — Antwort typischerweise innerhalb von 24 Stunden.

support@acellemail.com →
Dokumentationsindex · CAT

Alle 11 Deep-Dives durchstöbern →

Grundlagen, Bauen, Qualität, Referenz — alle Seiten an einem Ort, source-grounded gegen storage/app/plugins/acelle/ai/ und die maßgebliche Plugin-Dokumentation.

/developers →

Entwickler-FAQ

Die Fragen, die Entwickler vor dem Kauf wirklich stellen.

Kann ich den Core-Quellcode anpassen, ohne Updates zu verlieren? +

Ja, aber das sauberste Muster ist ein Plugin. Plugins leben außerhalb des Core-Namespace und überleben jedes Upgrade automatisch. Direkte Core-Anpassungen funktionieren, erfordern aber, dass Sie Upstream-Änderungen bei jedem Release manuell mergen. Das Plugin-System existiert genau, um diesen Aufwand zu vermeiden.

Überleben Plugins AcelleMail-Upgrades? +

Ja, von Hause aus. Der Core deklariert Hook-Punkte; Plugins reagieren. Solange Hook-Name und Signatur stabil bleiben (und wir Breaking Changes versionieren), läuft Ihr Plugin weiter. Wir testen das KI-Plugin (acelle/ai) auf jedem Release.

Kann ich Plugins kommerziell verkaufen? +

Ja. Die Extended-Lizenz erlaubt Ihnen, eigene Plugins unter Ihrer eigenen Lizenz zu vertreiben. Plugins leben in ihrem eigenen Namespace; dieser Code gehört zu 100 % Ihnen. Mehrere Teams betreiben private Marktplätze für ihr internes Plugin-Ökosystem.

Wie handhabt das Plugin-System Konflikte? +

REGISTRY-Hooks mergen (jedes Plugin trägt bei); EVENT-Hooks feuern alle (Konflikt unmöglich); FILTER-Ketten akkumulieren; BEHAVIOR ist das einzige „exklusive" Muster — versuchen zwei Plugins, dasselbe Verhalten zu beanspruchen, wird sofort eine Exception geworfen. Keine stillen Override-Überraschungen.

Können Plugins miteinander sprechen? +

Ja, über dasselbe Hook-System. Plugin A kann Events feuern, auf die Plugin B hört. Oder eine öffentliche Klasse bereitstellen — MyVendor\PluginA\Service ist eine ganz normale PHP-Klasse, importierbar wie jede andere. Das acelle/ai-Plugin stellt Hooks bereit, über die andere Plugins eigene KI-Tools registrieren können.

Wo liegt für Entwickler der Unterschied zwischen Regular und Extended? +

Regular ($80) deckt Ihre eigene Nutzung auf einer einzelnen Domain ab. Extended ($199) ergänzt das Recht, Endkunden Geld zu berechnen (Wiederverkauf als SaaS), White-Label-Klone zu vertreiben und Ihre eigenen Plugins zu verkaufen. Beide liefern denselben Quellcode.

Greifen Plugin-Migrations auf die Haupt-DB zu? +

Sie schreiben in dieselbe Datenbank, aber in Tabellen mit Ihrem Vendor-Präfix (z. B. myvendor_loyalty_accounts). Migrations laufen beim Aktivieren des Plugins, rollen beim Löschen mit $keepData = false zurück. Null Risiko für Core-Tabellen.

Kann ich Plugins in etwas anderem als PHP schreiben? +

Die Plugin-Runtime ist PHP/Laravel. Aber Ihr Plugin kann auf alles ausweichen — Node-Services, Python-ML, Go-Binaries, externe HTTP-APIs. Mehrere Teams liefern Plugins aus, die externe Tools umhüllen. Das Plugin ist die Integrationsschale; die Schwerarbeit darf irgendwo liegen.

Wie interagieren Plugins mit dem KI-Subsystem? +

acelle/ai stellt Hooks bereit, mit denen andere Plugins eigene KI-Tools registrieren, Engines austauschen oder sich in die Observability-Schicht einklinken können. Lesen Sie den Plugin-Quellcode für den Vertrag. Ihr Plugin kann zudem Events feuern, die der KI-Agent als Kontext aufnimmt.

Gibt es einen Plugin-Marktplatz? +

Noch nicht. Heute werden Plugins per Direktverkauf, GitHub oder Ihre private Registry vertrieben. Ein Community-Marktplatz steht auf der Roadmap, sobald genug Drittanbieter-Plugins existieren, damit sich einer lohnt.

Liefern Sie Ihr erstes Plugin noch heute Nachmittag aus.

Vollständiger PHP-Quellcode. Lebenslange Updates. Das Hook-System. Echte Produktionsbeispiele zum Abkupfern. Einmalig $199 für die Extended-Lizenz (kommerzielle Plugin-Weiterverteilung + SaaS-Nutzung).

Extended-Lizenz kaufen — $199 Live-Demo testen