Grav – das CMS ohne Datenbank, das alles kann

Grav ist kein Kompromiss. Es ist eine Entscheidung.

Die meisten Content-Management-Systeme beginnen mit einer Frage: Welche Datenbank soll es sein? Grav stellt diese Frage gar nicht erst. Es braucht keine. Keine MySQL-Instanz, kein phpMyAdmin, kein Backup-Chaos mit Dump-Dateien. Inhalte leben als einfache Textdateien auf dem Server – lesbar, versionierbar, portabel. Das klingt nach Verzicht, ist aber in Wahrheit eine Befreiung.

Dieser Artikel ist für alle, die ernsthaft überlegen, ob Grav das richtige Werkzeug für ihr Projekt ist. Keine Marketing-Broschüre, keine Kurzfassung – sondern alles, was man wirklich wissen muss.

Was ist Grav überhaupt?

Grav ist ein Flat-File-CMS, entwickelt von RocketTheme und erstmals 2014 veröffentlicht. „Flat File" bedeutet: Alle Inhalte werden als Dateien gespeichert, typischerweise im Markdown-Format. Es gibt keine relationale Datenbank. Der Webserver liefert Seiten aus, die Grav aus diesen Dateien zusammenbaut – entweder live (mit intelligentem Caching) oder als statisch gecachte HTML-Ausgabe.

Grav ist in PHP geschrieben und nutzt Twig als Template-Engine. Es folgt modernen Entwicklungsstandards: Composer für Abhängigkeiten, YAML für Konfiguration, Markdown für Inhalte. Wer diese Werkzeuge kennt, fühlt sich sofort zu Hause.

Das Projekt ist Open Source (MIT-Lizenz) und wird aktiv gepflegt. Der Quellcode liegt auf GitHub, die Community ist überschaubar, aber engagiert.

Die Philosophie hinter Grav

Grav wurde mit einem klaren Designziel gebaut: Einfachheit ohne Einschränkung. Das bedeutet konkret:

• Kein Overhead durch Datenbankabfragen bei jedem Seitenaufruf
• Volle Kontrolle über Struktur, Templates und Verhalten
• Portabilität – ein Grav-Projekt ist ein Ordner, der sich kopieren, sichern und deployen lässt
• Entwicklerfreundlichkeit als Grundprinzip, nicht als nachträgliches Feature

Grav folgt dem Prinzip: Was du nicht brauchst, ist nicht da. Was du brauchst, holst du dir.

Systemvoraussetzungen und Installation

Was Grav braucht

Die Anforderungen sind bewusst niedrig gehalten:

• PHP 8.0 oder neuer (empfohlen: 8.2+)
• PHP-Erweiterungen: mbstring, curl, openssl, zip, gd (meist standardmäßig aktiv)
• Apache mit mod_rewrite oder nginx mit entsprechender Konfiguration
• Kein MySQL, kein Redis, keine externe Abhängigkeit

Auch auf einem einfachen Shared Hosting läuft Grav – solange PHP in ausreichender Version vorhanden ist.

Installation in drei Minuten

# Grav herunterladen (mit Admin-Plugin)
wget https://getgrav.org/download/core/grav-admin/latest -O grav-admin.zip

# Entpacken ins Webroot
unzip grav-admin.zip -d /var/www/html/

# Fertig.

Kein Installer-Wizard mit Datenbankpasswörtern. Kein Warten auf Tabellen-Erstellung. Der erste Aufruf im Browser zeigt direkt die Website.

Alternativ via Composer:

composer create-project getgrav/grav mein-projekt

Oder mit dem Grav CLI:

bin/grav install

Grav CLI – der stille Held

Das mitgelieferte Kommandozeilen-Werkzeug bin/grav und bin/plugin sind mächtig unterschätzt. Damit lassen sich:

• Plugins und Themes installieren
• Cache leeren
• Backups erstellen
• Benutzer anlegen
• Systeminformationen abfragen

Für alle, die lieber mit SSH als mit Mausgeklicke arbeiten, ist das ein erheblicher Vorteil gegenüber WordPress & Co.

Die Verzeichnisstruktur – alles am richtigen Platz

mein-grav/
├── cache/          # Automatisch generierter Cache
├── images/         # Verarbeitete Bildversionen
├── logs/           # Fehler- und Systemlogs
├── system/         # Grav-Core (nicht anfassen)
├── tmp/            # Temporäre Dateien
├── user/           # HIER lebt alles, was man selbst macht
│   ├── accounts/   # Benutzerdaten
│   ├── config/     # Konfigurationsdateien (YAML)
│   ├── data/       # Plugin-Daten
│   ├── pages/      # Inhalte (Markdown-Dateien)
│   ├── plugins/    # Installierte Plugins
│   └── themes/     # Installierte Themes
└── vendor/         # PHP-Abhängigkeiten (Composer)

Die entscheidende Erkenntnis: Alles Eigene liegt unter user/. Das bedeutet, ein Update des Grav-Cores lässt sich durchführen, ohne auch nur eine eigene Datei anzufassen. Backups beschränken sich auf diesen einen Ordner.

Inhalte erstellen – Markdown als erste Sprache

Die Seitenstruktur

Jede Seite in Grav ist ein Verzeichnis unter user/pages/, das eine Markdown-Datei enthält:

user/pages/
├── 01.home/
│   └── default.md
├── 02.blog/
│   ├── blog.md
│   └── erster-beitrag/
│       └── item.md
└── 03.kontakt/
    └── default.md

Die Nummerierung (01., 02.) steuert die Reihenfolge im Menü. Der Name nach dem Punkt ist der URL-Slug. Alles ohne Datenbank-IDs, ohne Tabellen – einfach Ordner und Dateien.

Frontmatter und Inhalt

Jede Markdown-Datei beginnt mit einem YAML-Frontmatter-Block:

---
title: Mein erster Beitrag
date: 2024-03-15
author: Horst Mustermann
taxonomy:
    category: [blog]
    tag: [grav, cms, web]
published: true
---

Hier beginnt der eigentliche Inhalt in **Markdown**.

Dies ist ein Absatz. Bilder lassen sich einfach einbinden:

![Beschreibung](bild.jpg)

Das Frontmatter ist der Metadaten-Bereich – vollständig anpassbar, erweiterbar um eigene Felder, die dann in Templates genutzt werden können.

Medienverwaltung

Bilder und andere Medien landen direkt im gleichen Ordner wie die zugehörige Markdown-Datei. Grav verarbeitet Bilder intelligent:

![Foto](foto.jpg?width=800&height=600&cropResize=800,600)

Grav generiert die verkleinerte Version automatisch und cached sie. Responsive Bilder, Lazyloading, WebP-Konvertierung – alles über einfache URL-Parameter steuerbar, ohne ein einziges Plugin.

Das Admin-Panel – optional, aber komfortabel

Grav funktioniert vollständig ohne Web-Interface. Wer Markdown-Dateien direkt bearbeitet, braucht das Admin-Plugin nicht. Für alle anderen – und das ist die große Mehrheit – bietet das Admin-Plugin eine vollwertige Backend-Oberfläche:

• Dashboard mit System-Übersicht und letzten Aktivitäten
• Seiten-Editor mit Live-Vorschau und Markdown-Unterstützung
• Plugin-Manager zum Suchen, Installieren, Konfigurieren
• Theme-Manager analog dazu
• Konfigurationsoberfläche für alle System- und Plugin-Einstellungen
• Benutzerverwaltung mit Rollen und Berechtigungen
• Backup und Update direkt im Browser

Das Admin-Panel ist selbst ein Plugin – wer es nicht braucht, installiert es nicht. Das hält den Core schlank.

Themes – Aussehen ist konfigurierbar

Wie Themes funktionieren

Ein Grav-Theme besteht aus:

• Twig-Templates (.html.twig) für die HTML-Struktur
• SCSS/CSS für das Styling
• JavaScript für Interaktivität
• einer blueprints.yaml zur Definition von Konfigurationsoptionen
• einer theme.yaml mit Metadaten

Twig ist eine leistungsfähige, übersichtliche Template-Sprache. Wer schon einmal mit Jinja2, Django-Templates oder Blade gearbeitet hat, lernt Twig in einer Stunde.

{% extends 'partials/base.html.twig' %}

{% block content %}
    <h1>{{ page.title }}</h1>
    <div class="content">
        {{ page.content|raw }}
    </div>
    
    {% if page.collection %}
        {% for child in page.collection %}
            <article>
                <h2><a href="{{ child.url }}">{{ child.title }}</a></h2>
                <p>{{ child.summary }}</p>
            </article>
        {% endfor %}
    {% endif %}
{% endblock %}

Verfügbare Themes

Das Grav Theme Repository bietet über 100 fertige Themes, darunter:

• Quark – das Standard-Theme, modern und clean
• Antimatter – klassisch, blogfokussiert
• Deliver – Business/Portfolio
• Minisite – minimalistisch, One-Pager
• Learn2 – Dokumentations-Theme (ähnlich ReadTheDocs)
• Agency – einseitiges Business-Theme
• Haywire – leichtgewichtig, semantisch korrekt

Viele Themes sind Starter-Themes, die man als Ausgangspunkt nimmt und nach eigenen Vorstellungen anpasst. quark bietet sich als Basis an.

Eigene Themes entwickeln

Ein eigenes Theme lässt sich in wenigen Minuten aufsetzen:

php bin/plugin devtools new-theme

Das Devtools-Plugin generiert die Grundstruktur. Dann werden eigene Twig-Templates, SCSS und Assets hinzugefügt. Grav kompiliert SCSS automatisch (wenn entsprechendes Plugin installiert), optimiert Assets und versioniert sie per Cache-Busting.

Plugins – der Weg zur Erweiterung

Das Plugin-Ökosystem

Das Grav Plugin Repository bietet über 400 Plugins. Sie werden entweder über das Admin-Panel oder per CLI installiert:

bin/gpm install sitemap
bin/gpm install seo
bin/gpm install form

Unverzichtbare Plugins

Inhalt und Navigation

SEO und Performance

Formulare und Interaktion

Entwicklung und Debugging

Medien und Darstellung

Suche

Plugins selbst entwickeln

Ein Plugin ist im Kern eine PHP-Klasse, die auf Grav-Events reagiert:

class MeinPlugin extends Plugin
{
    public static function getSubscribedEvents(): array
    {
        return [
            'onPageInitialized' => ['onPageInitialized', 0],
        ];
    }

    public function onPageInitialized(Event $event): void
    {
        $page = $this->grav['page'];
        // Seite manipulieren, Daten hinzufügen etc.
    }
}

Die Event-Liste ist umfangreich: Seitenaufbau, Template-Rendering, Asset-Verarbeitung, Cache-Handling – an praktisch jedem Punkt lässt sich einhaken. Die Dokumentation ist gut, die Community hilfsbereit.

Skeletons – fertige Projektvorlagen

Skeletons sind vollständige Grav-Installationen mit vorinstalliertem Theme, Plugins und Beispielinhalten. Sie sind der schnellste Weg, ein Projekt aufzusetzen, das einem bestimmten Anwendungsfall entspricht.

Beispiele:

Ein Skeleton installieren:

bin/grav install https://github.com/getgrav/grav-skeleton-blog/archive/develop.zip

Oder einfach herunterladen, entpacken, fertig. Der Einstieg dauert Minuten, nicht Stunden.

Caching und Performance

Grav ohne Cache liefert Seiten in der Regel in unter 50ms. Mit Cache – der standardmäßig aktiviert ist – liegt die Auslieferung im einstelligen Millisekunden-Bereich.

Caching-Mechanismen

Grav nutzt mehrere Cache-Ebenen:

• Doctrine Cache: Kompilierte Seitenstruktur und Konfiguration
• Twig Cache: Kompilierte Templates
• Asset Cache: Komprimierte und zusammengeführte CSS/JS-Dateien
• Image Cache: Verarbeitete Bildversionen

Der Cache liegt unter cache/ und lässt sich per Knopfdruck oder CLI leeren:

bin/grav cache:clear

Statisches Caching

Für maximale Performance kann Grav vollständig statische HTML-Dateien ausgeben. Ein Reverse Proxy (nginx, Varnish) liefert diese Dateien dann direkt aus, ohne PHP auch nur zu starten. Besucherzahlen, die ein normales PHP-CMS in die Knie zwingen würden, sind dann kein Problem mehr.

Asset-Pipeline

Grav bündelt und minimiert CSS und JavaScript automatisch:

assets:
  css_pipeline: true
  js_pipeline: true
  css_minify: true
  js_minify: true

Eine Zeile YAML – und alle Assets werden zusammengeführt, minimiert und mit Cache-busting-Hashes versehen.

Konfiguration – YAML bis ins letzte Detail

Grav wird ausschließlich über YAML-Dateien konfiguriert. Das klingt nach trockenem Entwickler-Kram, ist in der Praxis aber elegant: Konfiguration ist versionierbar, diffbar, durch einfaches Kopieren übertragbar.

Systemkonfiguration

user/config/system.yaml:

home:
  alias: /home

pages:
  theme: quark
  markdown:
    extra: true
    auto_line_breaks: true

cache:
  enabled: true
  lifetime: 604800

debugger:
  enabled: false

languages:
  supported:
    - de
    - en
  default_lang: de
  include_default_lang: false

Seitenkonfiguration

Konfiguration kann auf drei Ebenen greifen:

1. System (user/config/system.yaml) – global
2. Seite (Frontmatter der Markdown-Datei) – für eine einzelne Seite
3. Ordner (user/config/site.yaml, .orders-Dateien) – für eine Seitengruppe

Diese Kaskade erlaubt feingranulare Kontrolle ohne aufgeblähte Konfigurationsdialoge.

Mehrsprachigkeit

Grav bietet eingebaute Mehrsprachigkeitsunterstützung ohne Plugin-Overhead. Sprachvarianten einer Seite liegen als separate Markdown-Dateien im gleichen Ordner:

user/pages/02.about/
├── default.de.md
├── default.en.md
└── default.fr.md

Grav erkennt die Browsersprache, löst Sprachpräfixe in der URL auf (/de/about, /en/about) und stellt Template-Funktionen für Sprachumschalter bereit.

Übersetzungen für UI-Strings landen in Sprachdateien:

# user/languages/de.yaml
PLUGIN_BLOG:
  READ_MORE: Weiterlesen
  COMMENTS: Kommentare

Versionskontrolle und Git-Sync

Weil Inhalte einfache Textdateien sind, lässt sich ein Grav-Projekt vollständig mit Git verwalten. Das Git-Sync-Plugin automatisiert das:

• Bei jeder Änderung im Admin wird automatisch ein git commit und git push ausgeführt
• Änderungen im Repository werden per Webhook automatisch eingespielt
• Mehrere Redakteure können über Git-Branches zusammenarbeiten

Das ermöglicht Continuous Deployment für Inhalte: Artikel im Git-Repository schreiben, pushen – Grav aktualisiert sich automatisch.

Benutzer und Berechtigungen

Grav speichert Benutzer als YAML-Dateien unter user/accounts/. Kein Benutzertabellen-Chaos:

# user/accounts/horst.yaml
email: horst@example.com
fullname: Horst Mustermann
title: Chefredakteur
access:
  admin:
    login: true
    super: false
  site:
    login: true

Das Berechtigungssystem (ACL) ist granular: Welcher Benutzer darf welche Seiten bearbeiten, welche Plugins konfigurieren, welche Bereiche des Admins aufrufen?

Für Mehrbenutzerbetrieb mit komplexen Rechte-Anforderungen gibt es das Login Pro Plugin (kostenpflichtig, aber erschwinglich), das Benutzergruppen, Frontend-Login und Inhaltsschutz bietet.

Formulare

Das Form-Plugin ist eine der stärksten Komponenten von Grav. Formulare werden vollständig in YAML definiert:

form:
    name: kontakt
    fields:
        - name: name
          label: Ihr Name
          type: text
          validate:
              required: true
        - name: email
          label: E-Mail-Adresse
          type: email
          validate:
              required: true
        - name: nachricht
          label: Ihre Nachricht
          type: textarea
          rows: 5
    buttons:
        - type: submit
          value: Absenden
    process:
        - email:
              to: kontakt@example.com
              from: '{{ form.value.email }}'
              subject: 'Neue Anfrage: {{ form.value.name }}'
        - save:
              fileprefix: kontakt-
              dateformat: Ymd-His
              extension: txt
              body: "{{ form.value|yaml }}"
        - message: Vielen Dank! Ihre Nachricht wurde gesendet.
        - redirect: /danke

Kein PHP-Code, kein Plugin-Flickwerk – ein einziger YAML-Block erzeugt ein vollständiges Formular mit Validierung, E-Mail-Versand, Datenspeicherung und Weiterleitung.

Einsatzmöglichkeiten

Grav ist kein Nischen-Werkzeug. Es eignet sich für ein breites Spektrum:

Blog und persönliche Website

Der klassische Anwendungsfall. Grav bietet alles, was ein Blog braucht: Beiträge, Kategorien, Tags, RSS-Feed, Paginierung, Suche. Die Schreiberfahrung im Admin ist komfortabel, mit Markdown-Editor und Live-Vorschau.

Unternehmenswebsite

Portfolio, Produktpräsentation, Landing Pages – Grav liefert die Struktur, ein passendes Skeleton oder Theme die Optik. Updates der Inhalte sind einfach, keine Entwickler-Einbindung nötig.

Dokumentationssysteme

Das Learn2-Theme und verwandte Skeletons sind explizit für technische Dokumentation optimiert: Seitennavigation, Suchfunktion, Code-Highlighting, versionierbar über Git. Read-the-Docs-Feeling, selbst gehostet.

Mehrsprachige Websites

Eingebaut, ohne Dritt-Plugin. Für Unternehmen, die in mehreren Märkten präsent sind, ist das ein erheblicher Vorteil gegenüber WordPress, wo Mehrsprachigkeit immer Plugin-Abhängigkeit bedeutet.

Intranet und Wissensdatenbanken

Grav mit Login-Schutz, internen Benutzerkonten und feingranularen Berechtigungen eignet sich für geschlossene Wissensdatenbanken. Kein Cloud-Dienst, keine Datenschutz-Grauzone – alles auf eigenem Server.

Entwickler-Portfolio und Open Source Projekte

Versionskontrolle, Git-Sync, statisches Caching – Grav passt ideal in Entwickler-Workflows. Die Dokumentation eines Open-Source-Projekts lässt sich direkt aus dem Code-Repository befüllen.

E-Learning und Kursinhalte

Das Course Hub-Skeleton ist speziell für Bildungsinhalte konzipiert, mit Modulstruktur, Lernzielen und Fortschrittsverfolgung.

Statische Site-Generierung

Für maximale Sicherheit und Performance lässt sich Grav in Kombination mit einem Headless-Setup oder dem Static-Site-Generator-Modus nutzen. Das Ergebnis: eine Sammlung statischer HTML-Dateien, die ohne Server-Overhead ausgeliefert werden können.

Für wen ist Grav geeignet?

Definitiv geeignet für...

Entwickler und Techniker, die Kontrolle schätzen. Wer gerne mit SSH arbeitet, Konfigurationsdateien bearbeitet und Versionskontrolle nutzt, wird Grav lieben. Es stellt sich nicht in den Weg.

Blogger und Autoren, die Markdown beherrschen. Wer ohnehin in Markdown schreibt, gewinnt mit Grav gegenüber WordPress: keine WYSIWYG-Überraschungen, kein Block-Editor-Chaos, saubere Textdateien.

Datenschutzbewusste und Selbsthoster. Keine Clouddienste, keine externen Datenbankserver, kein Tracking-Overhead. Grav läuft auf dem eigenen Server, Punkt.

Kleine Teams mit klarer Struktur. Mehrere Redakteure, verschiedene Rechte, Git als Zusammenarbeitswerkzeug – das funktioniert hervorragend.

Entwickler, die Themes und Plugins bauen. Die API ist sauber, die Dokumentation vollständig, die Community freundlich. Ein Grav-Plugin zu schreiben, ist kein Hexenwerk.

Websites mit vorhersehbarem Inhalt. Blogs, Dokumentationen, Portfolios, Unternehmenswebsites – überall dort, wo die Inhaltsstruktur klar ist und nicht täglich neu erfunden wird.

Für wen ist Grav weniger geeignet?

Mit Vorsicht zu genießen für...

Nicht-technische Nutzer ohne Backup-Plan. Grav hat einen Admin, der komfortabel ist. Aber wenn etwas schiefläuft – eine defekte Konfigurationsdatei, ein fehlerhaftes Plugin-Update – muss man wissen, wo man sucht. Eine WordPress-Lösung mit Managed Hosting ist für absolut nicht-technische Nutzer ehrlichkeitshalber einfacher.

Große Teams mit komplexen Workflows. Mehrere Autoren mit Entwurfs-/Review-/Veröffentlichungs-Workflows, Kommentar-Moderation, bezahltem Zugang, Newsletter-Integration – für solche Anforderungen ist ein vollwertiges CMS wie WordPress oder ein Headless-System besser ausgestattet.

E-Commerce. Grav ist kein Shop-System. Es gibt Ansätze, Produkte abzubilden, aber wer einen Online-Shop betreiben will, ist mit WooCommerce oder Shopify besser bedient.

Websites mit sehr dynamischen Inhalten. Echtzeit-Kommentare, Benutzerprofil-Feeds, Live-Datenanbindung – solche Anforderungen sprengen das Flat-File-Modell. Hier braucht man eine Datenbank.

Sehr große Content-Bibliotheken. Mit einigen tausend Seiten beginnt das Flat-File-Modell an Grenzen zu stoßen. Das Laden der Seitenstruktur aus dem Dateisystem ist langsamer als eine optimierte Datenbankabfrage. Zehn- oder hunderttausende Artikel gehören in ein datenbankgestütztes System.

Grav im Vergleich

Grav vs. WordPress

Grav vs. Hugo / Jekyll (statische Generatoren)

Grav vs. Statamic

Beide sind moderne PHP-Flat-File-CMS. Statamic ist mächtiger, ausgereifter für Enterprise-Einsatz und kostenpflichtig (ab 259 USD für Einzelseiten). Grav ist vollständig Open Source und kostenlos.

Sicherheit

Grav hat naturgemäß eine kleinere Angriffsfläche als datenbankbasierte CMS:

• Kein SQL-Injection-Risiko (keine SQL-Datenbank)
• Keine Datenbankserver-Konfiguration, die falsch gesetzt werden könnte
• Inhalte sind einfache Textdateien – kein ausführbarer Code in der Datenbank

Das Admin-Panel ist per Standard unter /admin erreichbar – das lässt sich ändern. Benutzerpasswörter werden mit bcrypt gehasht.

Zu den sicherheitsrelevanten Best Practices:

# Admin-Verzeichnis mit IP-Beschränkung in nginx
location /admin {
    allow 192.168.1.0/24;
    deny all;
}

Regelmäßige Updates sind wichtig – Grav und Plugins werden aktiv gepflegt, Sicherheitslücken werden zügig behoben.

Community und Support

• Offizielle Dokumentation: learn.getgrav.org – umfangreich und gut gepflegt
• Forum: discourse.getgrav.org – aktiv, hilfreich
• GitHub: Issues, Pull Requests, Diskussionen
• Discord: Echtzeit-Austausch mit Entwicklern und Nutzern

Die Community ist kleiner als die von WordPress, aber konzentrierter. Fragen werden oft von Kern-Entwicklern beantwortet.

Fazit: Wann lohnt sich Grav?

Grav ist kein Allheilmittel und will es auch nicht sein. Es ist ein präzises Werkzeug für bestimmte Aufgaben – und diese Aufgaben löst es ausgezeichnet.

Grav lohnt sich, wenn:

• man die Kontrolle über seine Infrastruktur schätzt
• Portabilität und Versionierbarkeit von Inhalten wichtig sind
• Performance ohne aufwendiges Tuning gefragt ist
• ein kleines, wartungsarmes System gesucht wird
• man Markdown schreibt und das Ergebnis direkt auf dem Server landen soll

Grav ist der richtige Beweis dafür, dass ein CMS keine Datenbank braucht, um leistungsfähig zu sein.

Die Entscheidung für Grav ist keine Kompromissentscheidung. Sie ist die bewusste Wahl für ein System, das tut, was man von ihm erwartet – und sonst nichts im Weg steht.

Weitere Informationen: getgrav.org · Dokumentation: learn.getgrav.org · GitHub: github.com/getgrav/grav