
Blockstudio 7 ist da. Dies ist die größte Veröffentlichung in der Geschichte des Projekts: Die gesamte Codebasis wurde von Grund auf neu geschrieben. Jede Klasse, jeder Hook und jede Codezeile wurde mit Blick auf modernes PHP, WordPress-Codieren und langfristige Wartbarkeit neu erstellt.

Doch das ist nicht einfach nur ein Refactoring. Blockstudio 7 bringt wichtige neue Funktionen wie dateibasierte Seiten und Patterns, ein Post-Meta-Speichersystem, SEO-Integration und einen völlig neuen HTML-zu-Block-Parser, der alles antreibt. Außerdem ist Blockstudio jetzt vollständig kostenlos und quelloffen.

Schauen wir uns an, was alles neu ist.

## Kostenlos und quelloffen

Ich arbeite seit 2020 an Blockstudio und habe im Laufe der Jahre Dutzende Versionen veröffentlicht. Die Nutzer waren begeistert, doch für ein kommerzielles WordPress-Block-Framework die passende Marktposition zu finden, war immer schwierig.

Was die Lage verändert hat, sind LLMs. KI-Coding-Assistenten sind inzwischen gut genug, um Block-Code zu schreiben, brauchen dafür aber klare, dateibasierte Strukturen. WordPress-Block-Markup ist unübersichtlich: serialisierte HTML-Kommentare mit eingebetteten JSON-Attributen, vermischt mit DOM-Struktur. Das ist für Menschen schwierig und für LLMs noch schwieriger richtig umzusetzen.

Der dateibasierte Ansatz von Blockstudio sollte von Anfang an alles einfach halten: ein `block.json` und eine PHP-Vorlage in einem Ordner. Keine Datenbankeinträge, kein React, kein Build-Schritt. Mit v7 geht diese Philosophie noch weiter. Mit dem HTML-zu-Block-Parser kannst du einfaches HTML schreiben, das automatisch in gültiges Block-Markup umgewandelt wird. Alles bleibt im Dateisystem. In die Datenbank wird nur geschrieben, wenn du die Seitensynchronisierung ausdrücklich über PHP API oder CLI anforderst; Grundlage dafür sind Dateivorlagen.

Blockstudio quelloffen zu machen, ist der natürliche nächste Schritt. Je mehr LLMs mit Blockstudio-Code trainieren, desto besser können sie ihn generieren. Eine offene Codebasis, offene Dokumentation und eine vorgefertigte [KI-Kontextdatei](https://blockstudio.dev/de/docs/dev/ai/), die jedes Tool nutzen kann: So schaffst du die beste Umgebung für KI-gestützte WordPress-Entwicklung.

Das vollständige Plugin ist auf [GitHub](https://github.com/inline0/blockstudio) für alle verfügbar, die es nutzen, forken und dazu beitragen möchten. Keine Lizenzschlüssel, keine Bezahlschranken, keine gesperrten Funktionen.

## Neue Funktionen

### Dateibasierte Seiten

Dies ist eine der größten Neuerungen in 7.0. Du kannst jetzt ganze WordPress-Seiten als Dateivorlagen definieren, die bei Aufruf des Seitensynchronisierungs-API oder CLI als native Block-Inhalte mit der Datenbank synchronisiert werden.

Erstelle einen Ordner mit einem `page.json` und einer Vorlagendatei:

```json title="page.json"
{
  "name": "about",
  "title": "About Us",
  "slug": "about",
  "postStatus": "publish"
}
```

```php title="index.php"
<div class="about-page">
  <h1>About Us</h1>
  <p>Welcome to our site.</p>
</div>
```

Führe `wp bs pages sync` aus, damit Blockstudio das HTML in WordPress-Blöcke umwandelt und die Seite in der Datenbank erstellt oder aktualisiert.

#### Zusammenführen von Blöcken anhand von Schlüsseln

Bei der Synchronisierung von Vorlagen würden Nutzeränderungen normalerweise überschrieben. Das Attribut `key` verhindert dies, indem es Nutzerinhalte bei der Synchronisierung beibehält:

```html title="index.php"
<h1 key="hero-title">Default Title</h1>
<p key="hero-description">Default description.</p>
```

Blöcke mit übereinstimmenden Schlüsseln behalten ihre von Nutzern bearbeiteten Inhalte, wenn die Vorlage aktualisiert wird. Blöcke ohne Schlüssel werden vollständig ersetzt.

#### Blockbindungen

Als Alternative zu Schlüsseln kannst du die [Block Bindings API](https://developer.wordpress.org/block-editor/reference-guides/block-api/block-bindings/) von WordPress core verwenden, um Blöcke direkt mit Post-Meta zu verknüpfen. Dies ist keine Blockstudio-Funktion, sondern eine native WordPress API. Blockstudio reicht das Attribut `metadata` einfach an das erzeugte Block-Markup weiter. Die Inhalte liegen in Meta statt im Block-Markup, sodass die Vorlagensynchronisierung Nutzeränderungen niemals löscht. Die Daten lassen sich außerdem über `WP_Query` abfragen und sind über REST API verfügbar.

```html title="index.php"
<h1 metadata='{"bindings":{"content":{"source":"core/post-meta","args":{"key":"hero_title"}}}}'>
  Default Title
</h1>
```

Beide Ansätze lassen sich in derselben Vorlage verwenden.

#### Bearbeitungsoptionen

Für Seiten kannst du `blockEditingMode` und `templateLock` festlegen, um zu steuern, was Nutzer ändern können:

```json title="page.json"
{
  "name": "landing",
  "title": "Landing Page",
  "blockEditingMode": "contentOnly",
  "templateLock": "all"
}
```

Damit wird die Seitenstruktur gesperrt, während Nutzer weiterhin Text und Medien bearbeiten können. Einzelne Elemente können die Einstellung für die gesamte Seite mit einem `blockEditingMode`-Attribut in der Vorlage überschreiben.

#### An Post-IDs binden

Mit `postId` kannst du eine Seitenvorlage an einen bestehenden WordPress-Beitrag binden. So verhinderst du doppelte Seiten und stellst sicher, dass die Vorlage immer den richtigen Beitrag aktualisiert:

```json title="page.json"
{
  "name": "home",
  "title": "Home",
  "postId": 2
}
```

Alle Details findest du in der [Dokumentation zu Seiten](https://blockstudio.dev/de/docs/pages-and-patterns/pages/).

### Dateibasierte Patterns

Wie Seiten kannst du jetzt auch Block-Patterns als Dateivorlagen definieren. Schreibe dein Pattern in HTML; Blockstudio wandelt es in Block-Markup um und registriert es als natives WordPress-Block-Pattern. Die Patterns erscheinen im Block-Inserter und können von Nutzern überall eingefügt werden.

```json title="pattern.json"
{
  "name": "hero-section",
  "title": "Hero Section",
  "categories": ["featured"],
  "keywords": ["hero", "banner"]
}
```

```html title="index.php"
<div class="hero">
  <h1>Welcome</h1>
  <p>Get started today.</p>
</div>
```

Anders als Seiten legen Patterns keine Datenbankeinträge an. Sie werden bei jedem Seitenaufruf im Arbeitsspeicher registriert. Siehe die [Dokumentation zu Patterns](https://blockstudio.dev/de/docs/pages-and-patterns/patterns/).

### HTML-zu-Block-Parser

Seiten und Patterns basieren auf einem neuen HTML-Parser, der standardmäßige HTML-Vorlagen in WordPress-Block-Markup umwandelt. Er verarbeitet Container-Blöcke wie Gruppen und Spalten sowie einfache Blöcke wie Absätze und Überschriften automatisch. Der Parser verwendet eine Renderer-Architektur auf Trait-Basis, die sich über den `blockstudio/parser/renderers`-Filter einfach um weitere Blocktypen ergänzen lässt:

```php title="functions.php"
add_filter( 'blockstudio/parser/renderers', function ( $renderers, $parser ) {
    $renderers['acme/hero'] = function ( $element, $attrs, $parser ) {
        $content = $parser->get_inner_html( $element );
        $html    = '<div class="acme-hero">' . $content . '</div>';

        return array(
            'blockName'    => 'acme/hero',
            'attrs'        => $attrs,
            'innerBlocks'  => array(),
            'innerHTML'    => $html,
            'innerContent' => array( $html ),
        );
    };

    return $renderers;
}, 10, 2 );
```

Nach der Registrierung kannst du den Block in jeder Seiten- oder Pattern-Vorlage verwenden:

```html title="index.php"
<block name="acme/hero" background="/hero.jpg">
  <h1>Welcome to our site</h1>
</block>
```

### Speicher

Felder können ihre Werte jetzt zusätzlich zu Block-Attributen auch in Post-Meta oder Website-Optionen speichern. Eine große Neuerung:

```json title="block.json"
{
  "id": "subtitle",
  "type": "text",
  "label": "Subtitle",
  "storage": {
    "type": "postMeta"
  }
}
```

Wenn Werte in Post-Meta gespeichert sind, kannst du:

- Beiträge anhand von Feldwerten mit `WP_Query` und `meta_query` abfragen
- über REST API auf Felddaten zugreifen, etwa für Headless-Setups
- Daten mit anderen Plugins wie SEO-Tools und Caching-Ebenen teilen

Du kannst Werte auch für globale, websiteweite Einstellungen in der Options-Tabelle speichern:

```json title="block.json"
{
  "id": "phone",
  "type": "text",
  "label": "Phone Number",
  "storage": {
    "type": "option",
    "optionKey": "company_phone"
  }
}
```

Die vollständige API findest du in der [Storage-Dokumentation](https://blockstudio.dev/de/docs/blocks/storage/).

### Benutzerdefinierte Felder

Wiederverwendbare Felddefinitionen lassen sich jetzt über mehrere Blöcke hinweg teilen. Definiere eine Feldgruppe einmal und verweise dann von jedem Block darauf. So vermeidest du Wiederholungen, wenn mehrere Blöcke dieselbe Feldstruktur verwenden.

Erstelle ein `field.json` in deinem blockstudio-Verzeichnis:

```json title="fields/hero/field.json"
{
  "name": "hero",
  "title": "Hero Section",
  "attributes": [
    { "id": "heading", "type": "text", "label": "Heading", "default": "Hello World" },
    { "id": "description", "type": "textarea", "label": "Description" }
  ]
}
```

Verweise dann über das Präfix `custom/` von jedem Block darauf:

```json title="block.json"
{
  "blockstudio": {
    "attributes": [
      { "type": "custom/hero", "idStructure": "hero_{id}" }
    ]
  }
}
```

Die Eigenschaft `idStructure` stellt jeder Feld-ID ein Präfix voran, sodass `heading` zu `hero_heading` wird. Mit dem Schlüssel `overrides` kannst du einzelne Feldeigenschaften pro Instanz überschreiben.

Siehe die [Dokumentation zu benutzerdefinierten Feldern](https://blockstudio.dev/de/docs/blocks/attributes/custom-fields/).

### Tailwind CSS v4

Die Unterstützung für Tailwind wurde für v4 vollständig überarbeitet. Statt clientseitiger Kompilierung über CDN mit Speicherung auf der Festplatte nach dem Speichern eines Beitrags (der Ansatz in v6) kompiliert Blockstudio 7 Tailwind bei jeder Frontend-Anfrage serverseitig über [TailwindPHP](https://github.com/dnnsjsk/tailwindphp). Kein Node.js, kein CLI, kein Build-Schritt erforderlich.

Die Kompilierung verwendet kandidatenbasiertes Caching: Blockstudio extrahiert alle CSS-Klassennamen aus dem finalen HTML, sortiert und hasht sie zusammen mit deiner CSS-Konfiguration und sucht nach einer zwischengespeicherten Datei. Dieselben Klassen führen immer zu einem Cache-Treffer, selbst wenn sich das umgebende HTML ändert, etwa durch Nonces, Zeitstempel oder dynamische Inhalte.

Die Konfiguration verwendet die CSS-first-Syntax von Tailwind v4. Definiere benutzerdefinierte Themes und Utility-Klassen direkt in deinem `blockstudio.json` oder über den `blockstudio/tailwind/css`-Filter:

```php title="functions.php"
add_filter('blockstudio/tailwind/css', function ($css) {
  return $css . '
    @theme {
      --color-brand: #4f46e5;
    }

    @layer utilities {
      .container-narrow {
        max-width: 48rem;
        margin-inline: auto;
      }
    }
  ';
});
```

Im Block-Editor ermöglicht ein gebündeltes Tailwind-CDN-Skript eine Live-Vorschau während der Eingabe. Der Feldtyp `classes` bietet Autovervollständigung für alle Tailwind-Utilities. Das Frontend verwendet immer das serverseitig kompilierte CSS, das als Inline-Style-Tag vor `</head>` eingefügt wird.

Die vollständige Einrichtung findest du in der [Tailwind-Dokumentation](https://blockstudio.dev/de/docs/tailwind/).

### Interaktivität API

Blockstudio unterstützt jetzt
[WordPress Interactivity API](https://developer.wordpress.org/block-editor/reference-guides/interactivity-api/).
Aktiviere sie in deiner block.json:

```json title="block.json"
{
  "blockstudio": {
    "interactivity": true
  }
}
```

Füge `data-wp-*`-Direktiven zu deiner Vorlage hinzu:

```php title="index.php"
<div useBlockProps
     data-wp-interactive="myBlock"
     data-wp-context='{ "isOpen": false }'>
  <button data-wp-on--click="actions.toggle"
          data-wp-bind--aria-expanded="context.isOpen">
    Toggle
  </button>
  <div data-wp-bind--hidden="!context.isOpen">
    This content is toggled by the button.
  </div>
</div>
```

Erstelle anschließend ein `script.js` mit deiner Store-Logik:

```javascript title="script.js"
import { store, getContext } from '@wordpress/interactivity';

store('myBlock', {
  actions: {
    toggle: () => {
      const context = getContext();
      context.isOpen = !context.isOpen;
    },
  },
});
```

Blockstudio kümmert sich im Frontend und im Block-Editor um die Importmap, das Laden der Module und die Verarbeitung der Direktiven. Blöcke, die nur deklarative Direktiven mit `data-wp-context` verwenden, etwa `data-wp-bind--hidden` oder `data-wp-text`, funktionieren ganz ohne JavaScript. Serverseitiger Zustand über `wp_interactivity_state()` wird im Frontend ebenfalls unterstützt.

Die vollständige Einrichtung findest du in der [Dokumentation zu Interactivity](https://blockstudio.dev/de/docs/blocks/interactivity/).

### SEO-Inhaltsanalyse

Blockstudio-Blöcke sind dynamisch, daher sind ihre Feldinhalte für SEO-Plugins standardmäßig unsichtbar. Blockstudio 7 behebt das mit automatischen Integrationen für Yoast SEO, Rank Math und SEOPress. Textwerte aus Feldern vom Typ `text`, `textarea`, `richtext`, `wysiwyg` und `link` (einschließlich verschachtelter Repeater-Zeilen) werden extrahiert und in die Inhaltsanalyse der jeweiligen Plugins übernommen. SEO-Plugins können deine Block-Inhalte nun korrekt auf Keyword-Dichte, Lesbarkeit und weitere Kennzahlen untersuchen. Eine Konfiguration ist nicht erforderlich.

### Standardzeilen für Repeater

Repeater-Felder unterstützen jetzt eine Eigenschaft `default` mit einem Array vorausgefüllter Zeilen. Beim Einfügen eines Blocks wird der Repeater sowohl im Editor als auch im Frontend mit den angegebenen Zeilen und Werten befüllt:

```json title="block.json"
{
  "id": "features",
  "type": "repeater",
  "label": "Features",
  "default": [
    { "title": "Fast", "icon": "bolt" },
    { "title": "Secure", "icon": "shield" }
  ],
  "attributes": [
    { "id": "title", "type": "text", "label": "Title" },
    { "id": "icon", "type": "text", "label": "Icon" }
  ]
}
```

Die Eigenschaft `min` funktioniert auch mit Feldstandardwerten: Hat ein Repeater `min: 3` und haben seine inneren Felder `default`-Werte, werden die automatisch erzeugten Zeilen mit diesen Standardwerten statt mit leeren Feldern vorausgefüllt.

## Verbesserungen und Fehlerbehebungen

- **Repeater `min` mit Feldstandardwerten**: Automatisch erzeugte Mindestzeilen verwenden jetzt sowohl im Frontend als auch im Editor die Standardwerte auf Feldebene
- **Tailwind-Editorstile**: Das kompilierte Tailwind CSS wird jetzt zusammen mit CDN in das Iframe des Block-Editors eingefügt, sodass benutzerdefinierte `@apply`-Regeln und Theme-Konfigurationen im Editor funktionieren
- **[KI-Kontextdatei](https://blockstudio.dev/de/docs/dev/ai/)**: Die `blockstudio-llm.txt` wurde als statische Datei aus der vollständigen v7-Dokumentation und deduplizierten JSON-Schemas (ca. 48.000 Tokens) neu erstellt und ersetzt die dynamische Generierung aus v6
- **Codefeld-Popup**: Das Codefeld lässt sich jetzt in einem separaten Fenster öffnen und bietet unabhängiges Rückgängigmachen und Wiederherstellen sowie JavaScript-Syntaxhervorhebung
- **Serverseitige Tailwind-v4-Kompilierung**: Siehe oben den [Tailwind-Abschnitt](#tailwind-css-v4)
- **API Version 3**: Blöcke werden jetzt im Iframe-Editor korrekt dargestellt, auch im Site-Editor und in responsiven Vorschauen
- **Punktnotation für Assets**: übersichtlichere Dateinamen für Asset-Suffixe (`*.inline.css`, `*.editor.js`, `*.scoped.css`)
- `bs_render_block()`-Warnung von `WP_Block_Supports` bei Verwendung von `useBlockProps` behoben
- Fehler behoben, durch den bedingte Felder beim ersten Laden ihre Standardwerte nicht berücksichtigten
- Fehler behoben, durch den Dollarzeichen im Frontend aus `<RichText />`-Inhalten entfernt wurden
- `populate`-Funktion so korrigiert, dass sie auch mit von anderen Plugins registrierten Taxonomien funktioniert
- `optionsPopulate`-Null-Fehler in WPML-Kontexten behoben

## Unter der Haube

### Vollständige Neuentwicklung

Dies ist weder ein Refactoring noch eine Bereinigung. Jede Klasse wurde von Grund auf neu geschrieben. Das Ergebnis ist eine klarere, modularere Codebasis, die sich leichter warten und erweitern lässt.

### Modernes PHP

Blockstudio 7 erfordert PHP 8.2+ und verwendet durchgehend moderne Typdeklarationen.

## Inkompatible Änderungen

Als größeres Versionsupdate enthält 7.0 mehrere inkompatible Änderungen. Die meisten verfügen über abwärtskompatible Ausweichlösungen, du solltest sie aber vor dem Upgrade prüfen. Eine vollständige Anleitung zur Migration findest du in der [v7 Migrationsdokumentation](https://blockstudio.dev/de/docs/dev/migration/v7/).

### Hook-Namen verwenden jetzt snake_case

Alle PHP-Hooks wurden von camelCase in snake_case umbenannt, passend zu den Konventionen von WordPress core:

```php title="functions.php"
// Before (v6)
add_filter('blockstudio/settings/blockEditor/cssClasses', function() {
    return ['my-stylesheet'];
});

// After (v7)
add_filter('blockstudio/settings/block_editor/css_classes', function() {
    return ['my-stylesheet'];
});
```

Die alten camelCase-Namen funktionieren weiterhin, aber wir empfehlen dir, sie zu aktualisieren.

### Feldschalter ist standardmäßig deaktiviert

Die Eigenschaft `switch` ist jetzt standardmäßig auf `false` statt auf `true` gesetzt. In v6 hatte jedes Feld links einen unsichtbaren Schalter, der standardmäßig aktiviert war. In v7 ist der Schalter optional und wird als sichtbares Augensymbol in der Feldbezeichnung dargestellt. Wenn du dich auf das Standardverhalten des Schalters verlassen hast, füge `"switch": true` zu deinen Felddefinitionen hinzu.

### Asset-Dateinamen verwenden Punktnotation

Asset-Suffixe verwenden jetzt Punkte statt Bindestriche (`style.inline.css` statt `style-inline.css`). Die alte Schreibweise mit Bindestrich funktioniert weiterhin, aber künftig wird die Punktnotation empfohlen.

### Importpräfix npm

ES-Modul-Importe verwenden jetzt `npm:` statt `blockstudio/`:

```javascript title="script.js"
// Before (v6)
import confetti from "blockstudio/canvas-confetti@1.6.0";

// After (v7)
import confetti from "npm:canvas-confetti@1.6.0";
```

Das Präfix `blockstudio/` wird aus Gründen der Abwärtskompatibilität weiterhin unterstützt.

### Entfernte Funktionen

**Admin-Bereich und Code-Editor.** Die WordPress-Admin-Einstellungsseite und der integrierte Block-Code-Editor wurden entfernt. Die gesamte Konfiguration erfolgt jetzt über die Filter `blockstudio.json` und PHP. Dadurch liegt dein Setup zusammen mit deinen Blöcken in der Versionsverwaltung.

Der Code-Editor war in früheren Versionen hilfreich, um Blöcke in der Vorschau anzuzeigen, erreichte aber nie den Funktionsumfang einer echten Entwicklungsumgebung. Im Laufe der Jahre mussten mehrere Plugin-Funktionen zurückgehalten werden, weil sie im eigenständigen Editor nicht unterstützt werden konnten. Außerdem war er nie als Ersatz für eine vollständige IDE gedacht. Durch seine Entfernung kann sich das Plugin ohne Kompromisse ganz auf die dateibasierte Entwicklung konzentrieren.

**Lizenzschlüssel.** Nicht mehr erforderlich. Blockstudio ist kostenlos und quelloffen.

**Block-Bibliothek.** Die integrierte Bibliothek „Blockstudio Elements“ (Gallery, Slider, Image Comparison, Code, Icon) wurde entfernt. Dabei handelte es sich um vorgefertigte Beispielblöcke, die mit dem Plugin ausgeliefert wurden. Wenn du sie verwendet hast, kopiere die Block-Ordner aus v6 in das blockstudio-Verzeichnis deines Themes.

## Erste Schritte

Installiere Blockstudio 7 und erstelle in wenigen Minuten deinen ersten Block. In der Anleitung [Erste Schritte](https://blockstudio.dev/de/docs/general/getting-started/) findest du eine Schritt-für-Schritt-Anleitung. Wenn du von v6 upgradest, hilft dir die [v7 Migrationsanleitung](https://blockstudio.dev/de/docs/dev/migration/v7/).

Den vollständigen Quellcode findest du auf [GitHub](https://github.com/inline0/blockstudio). Fehlerberichte, PRs und Feedback sind willkommen.
