Die visuelle Oberfläche von Home Assistant ist praktisch für den schnellen Einstieg. Aber wer wirklich beeindruckende Dashboards bauen will, kommt an YAML nicht vorbei. Die deklarative Konfigurationssprache gibt dir volle Kontrolle über jedes Pixel – von responsiven Layouts über animierte Karten bis hin zu komplexen Conditional-Elementen, die sich dynamisch an deine Smart-Home-Zustände anpassen.
Dieser Guide führt dich vom ersten YAML-Block bis zum professionellen Dashboard. Wir behandeln die Grundlagen der YAML-Syntax, die verschiedenen Kartentypen, fortgeschrittene Templating-Techniken und bewährte Architektur-Patterns. Egal ob du ein minimalistisches Control-Center für dein Wohnzimmer oder ein umfassendes Monitoring für dein gesamtes Haus planst – hier lernst du, wie du es baust.
Keine Angst vor der Syntax. YAML ist menschenlesbar, und Home Assistants Fehlermeldungen sind mittlerweile aussagekräftig. Mit diesem Guide und etwas Übung wirst du in kürzester Zeit Dashboards erstellen, die den UI-Editor weit hinter sich lassen.
Inhaltsverzeichnis
- Warum YAML statt UI-Editor?
- YAML-Grundlagen für Home Assistant
- Dashboard-Struktur und Konfigurationsdateien
- Die wichtigsten Karten im Überblick
- home assistant dashboard yaml examples für jeden Raum
- Templating und dynamische Inhalte
- Fortgeschrittene Techniken: Conditional, Stacks und mehr
- home assistant dashboard yaml editor und Workflow
- FAQ: Häufige Fragen zu YAML-Dashboards
- Fazit und nächste Schritte
Warum YAML statt UI-Editor?
Home Assistant bietet zwei Wege zur Dashboard-Erstellung: den visuellen UI-Editor und YAML-Konfiguration. Beide haben ihre Berechtigung, aber für ernsthafte Dashboard-Projekte ist YAML die bessere Wahl.
Vorteile der YAML-Konfiguration
Versionskontrolle: YAML-Dateien kannst du in Git speichern, Änderungen nachvollziehen und bei Bedarf zurückrollen. Der UI-Editor speichert alles in einer Datenbank – bei Fehlern ist die Ursachenforschung schwierig.
Wiederverwendbarkeit: Einmal geschriebene YAML-Blöcke kopierst du in andere Dashboards, teilst sie mit der Community oder archivierst sie für spätere Projekte. Templates und Includes machen Code modular.
Zugriff auf alle Features: Nicht alle Karten-Optionen sind im UI-Editor verfügbar. YAML gibt dir Zugriff auf fortgeschrittene Features wie Custom-CSS, komplexe Conditionals und spezielle Card-Modifikationen.
Schnelle Iteration: Ein guter Editor mit Autocomplete und Syntax-Highlighting ist schneller als Klicken durch Menüs. Für erfahrene Nutzer ist Tippen effizienter als Drag-and-Drop.
Übersichtlichkeit: Eine gut strukturierte YAML-Datei zeigt auf einen Blick die gesamte Dashboard-Architektur. Im UI-Editor musst du durch mehrere Ebenen navigieren.
Wann der UI-Editor sinnvoll ist
Der UI-Editor hat seine Stärken bei:
- Schnellen Prototypen und Experimenten
- Einmaligen Anpassungen ohne Versionskontrolle
- Nutzern ohne Programmiererfahrung
- Dem Erkunden verfügbarer Optionen (als Dokumentation)
Viele erfahrene Home Assistant-Nutzer nutzen einen hybriden Ansatz: Prototypen im UI-Editor bauen, dann in YAML überführen und dort verfeinern.
Der Lernaufwand lohnt sich
Die anfängliche Hürde der YAML-Syntax ist gering. Die Grundstruktur ist intuitiv: Einrückungen definieren Hierarchie, Listen beginnen mit Bindestrichen. Nach wenigen Stunden wirst du flüssiger in YAML als im UI-Editor.
Die Investition zahlt sich aus. Professionelle Dashboards, die du in der Community siehst – die schönen Lovelace-Beispiele auf Reddit und GitHub – sind fast ausnahmslos in YAML geschrieben.
YAML-Grundlagen für Home Assistant
YAML (YAML Ain’t Markup Language) ist eine Daten-Serialisierungssprache, die auf Lesbarkeit optimiert ist. Für Home Assistant brauchst du nur einen Teil der Spezifikation.
Grundlegende Syntax
Schlüssel-Wert-Paare:
name: Wohnzimmer Dashboard
icon: mdi:sofa
Listen:
cards:
- type: entities
entities:
- light.wohnzimmer
- switch.stecker
Verschachtelte Strukturen:
type: vertical-stack
cards:
- type: entity
entity: sensor.temperatur
- type: entity
entity: sensor.luftfeuchtigkeit
Wichtige Regeln
Einrückungen sind entscheidend: YAML nutzt Leerzeichen (keine Tabs) zur Strukturierung. Zwei Leerzeichen pro Ebene ist der Home Assistant-Standard.
# Richtig
cards:
- type: button
entity: light.wohnzimmer
# Falsch (Tabs statt Leerzeichen)
cards:
→- type: button
→→entity: light.wohnzimmer
Strings mit Sonderzeichen: Werte mit Doppelpunkten, geschweiften Klammern oder Anführungszeichen müssen in Anführungszeichen gesetzt werden:
# Nötig
name: "Temperatur: Wohnzimmer"
# Optional bei einfachen Strings
name: Wohnzimmer
Mehrzeilige Strings:
description: |
Dies ist ein
mehrzeiliger Text
mit Zeilenumbrüchen.
Inline-Syntax für kompakte Listen:
entities: [light.wohnzimmer, light.kueche, light.schlafzimmer]
Home Assistant-spezifische Konventionen
Entity-IDs:
Home Assistant verwendet das Format domain.entity_id:
light.wohnzimmer_deckenlampesensor.temperatur_aussenbinary_sensor.fenster_kueche
States und Attributes: Der Zustand einer Entity ist ein einfacher Wert. Attribute enthalten zusätzliche Metadaten:
state: 'on'
attributes:
brightness: 255
color_temp: 300
Services aufrufen:
tap_action:
action: perform-action
perform_action: light.turn_on
target:
entity_id: light.wohnzimmer
data:
brightness_pct: 80
Häufige YAML-Fehler
Fehler 1: Falsche Einrückung
cards:
- type: button # Falsch: keine Einrückung
entity: light.wohnzimmer
Fehler 2: Gemischte Listen und Maps
cards:
- type: entities
entities: # Falsch: fehlender Bindestrich
- light.wohnzimmer
Fehler 3: Reservierte Wörter ohne Quotes
state: on # Falsch: 'on' wird als Boolean interpretiert
state: "on" # Richtig: explizit als String
Dashboard-Struktur und Konfigurationsdateien
Um YAML-Dashboards effektiv zu nutzen, musst du verstehen, wie Home Assistant die Konfiguration organisiert.
home assistant dashboard yaml file location
Die Dashboard-Konfiguration liegt an verschiedenen Orten, je nachdem wie du Home Assistant installiert hast:
Home Assistant OS / Container:
config/
└── lovelace/
├── ui-lovelace.yaml # Legacy-Modus
└── dashboards/
├── dashboard-wohnzimmer.yaml
└── dashboard-system.yaml
Speicherort in der UI:
- Einstellungen → Dashboards
- Drei-Punkte-Menü → Ressourcen
- “Im YAML-Modus bearbeiten” für das gewünschte Dashboard
Mode-Umschaltung: Standardmäßig speichert Home Assistant Dashboards in der Datenbank (UI-gesteuert). Für YAML-Dateien musst du den YAML-Modus aktivieren:
# configuration.yaml
lovelace:
mode: yaml
resources:
- url: /local/my-custom-card.js
type: module
Dashboard-Registrierung
Jedes YAML-Dashboard muss in der configuration.yaml registriert werden:
# configuration.yaml
lovelace:
dashboards:
wohnzimmer:
mode: yaml
title: Wohnzimmer
icon: mdi:sofa
show_in_sidebar: true
filename: lovelace-wohnzimmer.yaml
system:
mode: yaml
title: System
icon: mdi:server
show_in_sidebar: true
filename: lovelace-system.yaml
Nach einem Neustart erscheinen die Dashboards in der Seitenleiste.
Grundstruktur einer Dashboard-Datei
Eine vollständige Dashboard-Datei hat folgende Struktur:
title: Mein Dashboard
views:
- title: Übersicht
path: uebersicht
icon: mdi:home
cards:
- type: entities
title: Lichter
entities:
- light.wohnzimmer
- light.kueche
- title: Klima
path: klima
icon: mdi:thermometer
cards:
- type: weather-forecast
entity: weather.home
Erklärung der Elemente:
title: Der Name des Dashboards (Browser-Tab)views: Liste der Tabs/Unterseitentitle(in view): Name des Tabspath: URL-Pfad (für direkte Links)icon: Material Design Iconcards: Die eigentlichen UI-Elemente
Includes und Wiederverwendung
Für große Dashboards empfiehlt sich die Aufteilung in mehrere Dateien:
# lovelace-wohnzimmer.yaml
title: Wohnzimmer
views:
- !include lovelace/wohnzimmer-uebersicht.yaml
- !include lovelace/wohnzimmer-medien.yaml
Wiederverwendbare Card-Templates:
# configuration.yaml
lovelace:
mode: yaml
resources: !include_dir_list lovelace/resources/
Die wichtigsten Karten im Überblick
Home Assistant bietet Dutzende integrierte Kartentypen. Hier sind die wichtigsten für YAML-Dashboards.
Entities Card
Die klassische Listenansicht für mehrere Entities:
type: entities
title: Wohnzimmer
entities:
- light.wohnzimmer
- sensor.temperatur_wohnzimmer
- binary_sensor.fenster_wohnzimmer
- entity: switch.stecker_tv
name: TV-Steckdose
icon: mdi:television
Besondere Features:
tap_action: Aktion beim Klickenhold_action: Aktion beim Haltenstate_color: Farbige Icons je nach Zustandfooter: Zusätzliche Elemente am Ende
Button Card
Große, klickbare Buttons für häufige Aktionen:
type: button
entity: light.wohnzimmer
name: Deckenlampe
icon: mdi:ceiling-light
tap_action:
action: toggle
hold_action:
action: more-info
Styling-Optionen:
type: button
entity: scene.wohnzimmer_abend
name: Abendstimmung
icon: mdi:weather-night
show_name: true
show_icon: true
show_state: false
size: 40px
style: "color: var(--primary-color); font-size: 14px;"
Glance Card
Kompakte Übersicht mit Icons:
type: glance
title: Schnellzugriff
entities:
- entity: light.wohnzimmer
tap_action:
action: toggle
- entity: climate.wohnzimmer
tap_action:
action: more-info
- entity: sensor.temperatur_aussen
show_state: true
show_icon: true
columns: 4
Picture Elements Card
Die mächtigste Karte für benutzerdefinierte Layouts. Du legst ein Hintergrundbild fest und positionierst Entities darauf:
type: picture-elements
image: /local/floorplan.png
elements:
- type: state-icon
entity: light.wohnzimmer
tap_action:
action: toggle
style:
top: 30%
left: 45%
- type: state-label
entity: sensor.temperatur_wohnzimmer
style:
top: 10%
left: 10%
color: white
font-size: 16px
Conditional Card
Zeigt Karten nur bei bestimmten Bedingungen:
type: conditional
conditions:
- entity: binary_sensor.bewegung_wohnzimmer
state: "on"
card:
type: entities
title: Bewegung erkannt
entities:
- camera.wohnzimmer
Vertical-Stack und Horizontal-Stack
Gruppieren mehrerer Karten:
type: vertical-stack
cards:
- type: markdown
content: "## Beleuchtung"
- type: horizontal-stack
cards:
- type: button
entity: light.wohnzimmer
- type: button
entity: light.kueche
- type: entities
entities:
- light.alle_lichter
Grid Card
Moderne Alternative zu Stack-Cards mit responsiven Spalten:
type: grid
title: Räume
columns: 2
square: false
cards:
- type: button
entity: light.wohnzimmer
- type: button
entity: light.kueche
- type: button
entity: light.schlafzimmer
- type: button
entity: light.bad
Mushroom Cards (HACS)
Die beliebteste Custom-Card-Sammlung:
type: custom:mushroom-light-card
entity: light.wohnzimmer
name: Deckenlampe
icon: mdi:ceiling-light
fill_container: true
use_light_color: true
show_brightness_control: true
show_color_temp_control: true
Mushroom Cards erfordern die Installation über HACS (Home Assistant Community Store).
home assistant dashboard yaml examples für jeden Raum
Praxisnahe Beispiele, die du direkt übernehmen und anpassen kannst.
Wohnzimmer-Dashboard
title: Wohnzimmer
views:
- title: Steuerung
path: steuerung
icon: mdi:sofa
cards:
- type: vertical-stack
cards:
- type: weather-forecast
entity: weather.home
show_forecast: true
- type: horizontal-stack
cards:
- type: button
entity: scene.wohnzimmer_tag
name: Tag
icon: mdi:weather-sunny
tap_action:
action: perform-action
perform_action: scene.turn_on
target:
entity_id: scene.wohnzimmer_tag
- type: button
entity: scene.wohnzimmer_abend
name: Abend
icon: mdi:weather-night
tap_action:
action: perform-action
perform_action: scene.turn_on
target:
entity_id: scene.wohnzimmer_abend
- type: custom:mushroom-light-card
entity: light.wohnzimmer_deckenlampe
name: Deckenlampe
use_light_color: true
show_brightness_control: true
show_color_temp_control: true
- type: custom:mushroom-media-player-card
entity: media_player.wohnzimmer_tv
name: Fernseher
use_media_info: true
show_volume_control: true
Klima-Übersicht
title: Klima
views:
- title: Übersicht
path: uebersicht
icon: mdi:thermometer
cards:
- type: horizontal-stack
cards:
- type: gauge
entity: sensor.temperatur_durchschnitt
name: Ø Temperatur
min: 15
max: 30
severity:
green: 20
yellow: 24
red: 27
- type: gauge
entity: sensor.luftfeuchtigkeit_durchschnitt
name: Ø Luftfeuchtigkeit
min: 30
max: 70
severity:
green: 40
yellow: 55
red: 65
- type: entities
title: Räume
entities:
- entity: sensor.temperatur_wohnzimmer
name: Wohnzimmer
- entity: sensor.temperatur_schlafzimmer
name: Schlafzimmer
- entity: sensor.temperatur_kueche
name: Küche
- entity: sensor.temperatur_bad
name: Bad
- type: history-graph
entities:
- sensor.temperatur_aussen
- sensor.temperatur_wohnzimmer
hours_to_show: 24
refresh_interval: 0
System-Monitoring
title: System
views:
- title: Status
path: status
icon: mdi:server
cards:
- type: glance
title: Home Assistant
entities:
- sensor.home_assistant_version
- sensor.uptime
- sensor.database_size
columns: 3
- type: entities
title: Server
entities:
- entity: sensor.cpu_temperature
name: CPU-Temperatur
- entity: sensor.processor_use
name: CPU-Auslastung
- entity: sensor.memory_use_percent
name: RAM-Auslastung
- entity: sensor.disk_use_percent
name: Speicherplatz
- type: history-graph
title: Last (24h)
entities:
- sensor.processor_use
- sensor.memory_use_percent
hours_to_show: 24
Sicherheits-Dashboard
title: Sicherheit
views:
- title: Übersicht
path: uebersicht
icon: mdi:shield-home
cards:
- type: alarm-panel
entity: alarm_control_panel.haus
name: Alarmanlage
states:
- arm_home
- arm_away
- arm_night
- type: conditional
conditions:
- entity: binary_sensor.bewegung_eingang
state: "on"
card:
type: picture-entity
entity: camera.eingang
show_state: false
camera_view: live
- type: entities
title: Sensoren
entities:
- entity: binary_sensor.tuer_eingang
name: Haustür
- entity: binary_sensor.fenster_wohnzimmer
name: Wohnzimmerfenster
- entity: binary_sensor.fenster_schlafzimmer
name: Schlafzimmerfenster
- entity: lock.haustuer
name: Türschloss
Templating und dynamische Inhalte
Templates machen deine Dashboards intelligent. Sie reagieren auf Zustände, berechnen Werte und formatieren Anzeigen.
Grundlagen der Jinja2-Templates
Home Assistant nutzt Jinja2 als Template-Engine. Die Syntax wird in YAML mit doppelten geschweiften Klammern eingebettet:
{{ states('sensor.temperatur') }}
Wichtige Funktionen:
{{ states('sensor.temperatur') }} # Aktueller Zustand
{{ state_attr('climate.wohnzimmer', 'temperature') }} # Attribut
{{ is_state('light.wohnzimmer', 'on') }} # Boolean-Check
{{ now() }} # Aktuelles Datum/Zeit
Templates in Karten
Dynamic Name:
type: entity
entity: sensor.temperatur_aussen
name: >
{% if states('sensor.temperatur_aussen')|float > 25 %}
Heiß draußen!
{% else %}
Außentemperatur
{% endif %}
Conditional Icon:
type: button
entity: light.wohnzimmer
icon: >
{% if is_state('light.wohnzimmer', 'on') %}
mdi:lightbulb-on
{% else %}
mdi:lightbulb-off
{% endif %}
Formatted State:
type: entities
entities:
- entity: sensor.energieverbrauch
name: Stromverbrauch
state: >
{{ states('sensor.energieverbrauch') }} kWh
({{ (states('sensor.energieverbrauch')|float * 0.30)|round(2) }} €)
Markdown-Card mit Templates
Die Markdown-Card ist ideal für dynamische Textinhalte:
type: markdown
content: |
## Willkommen zuhause!
**Heute ist {{ now().strftime('%A, %d.%m.%Y') }}**
{% if is_state('binary_sensor.regen', 'on') %}
☔ Es regnet gerade. Nimm einen Schirm mit!
{% else %}
☀️ Kein Regen in Sicht.
{% endif %}
### Aktive Geräte:
{% for entity in states.light if entity.state == 'on' %}
- {{ entity.name }}
{% endfor %}
Template-Sensoren für komplexe Logik
Für wiederkehrende Berechnungen erstelle einen Template-Sensor:
# configuration.yaml
template:
- sensor:
- name: "Energiekosten Heute"
unit_of_measurement: "€"
state: >
{{ (states('sensor.energieverbrauch_tag')|float * 0.30)|round(2) }}
Dann nutze den Sensor im Dashboard:
type: entity
entity: sensor.energiekosten_heute
Fortgeschrittene Techniken: Conditional, Stacks und mehr
Professionelle Dashboards nutzen fortgeschrittene Patterns für bessere UX.
Komplexe Conditional Cards
Mehrere Bedingungen kombinieren:
type: conditional
conditions:
- entity: binary_sensor.anwesend
state: "on"
- entity: sun.sun
state: "below_horizon"
- entity: light.wohnzimmer
state: "off"
card:
type: markdown
content: "💡 Es ist dunkel und du bist zu Hause. Soll ich das Licht einschalten?"
View-Conditional mit Badges
Zeige Badge-Informationen nur wenn relevant:
title: Wohnzimmer
path: wohnzimmer
badges:
- entity: sensor.temperatur_wohnzimmer
- entity: binary_sensor.fenster_wohnzimmer
visibility:
- condition: state
state: "on"
cards:
# ...
Swipe-Card für mobile Dashboards
Für Touch-optimierte Dashboards:
type: custom:swipe-card
parameters:
spaceBetween: 8
pagination:
type: bullets
cards:
- type: entities
title: Seite 1
entities:
- light.wohnzimmer
- type: entities
title: Seite 2
entities:
- light.kueche
Decluttering Card
Wiederverwendbare Template-Definitionen:
# In der Dashboard-Datei
decluttering_templates:
light_button:
default:
- entity: light.default
card:
type: button
entity: '[[entity]]'
tap_action:
action: toggle
# Verwendung
cards:
- type: custom:decluttering-card
template: light_button
variables:
- entity: light.wohnzimmer
- type: custom:decluttering-card
template: light_button
variables:
- entity: light.kueche
Card-Mod für Custom CSS
Erweitere Karten mit eigenem Styling:
type: entities
title: Stilisierte Karte
entities:
- light.wohnzimmer
card_mod:
style: |
ha-card {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
}
.card-header {
font-weight: bold;
font-size: 20px;
}
Auto-Entities für dynamische Listen
Zeige Entities basierend auf Filterkriterien:
type: custom:auto-entities
card:
type: entities
title: Offene Fenster
filter:
include:
- domain: binary_sensor
attributes:
device_class: window
state: "on"
exclude:
- entity_id: binary_sensor.fenster_ignore
sort:
method: friendly_name
home assistant dashboard yaml editor und Workflow
Ein effizienter Workflow macht den Unterschied zwischen frustrierendem Trial-and-Error und produktiver Dashboard-Entwicklung.
Empfohlene Editoren
VS Code mit Extensions: Die beste Wahl für Home Assistant YAML:
- Home Assistant Config Helper: Autocomplete für Entities, Services, Icons
- YAML: Syntax-Highlighting und Validierung
- indent-rainbow: Visuelle Einrückungshilfe
- Bracket Pair Colorizer: Übersichtliche Klammern
Installation:
- VS Code installieren
- Extensions öffnen (Ctrl+Shift+X)
- Nach “Home Assistant” suchen und installieren
Samba-Share für Dateizugriff:
# configuration.yaml
homeassistant:
allowlist_external_dirs:
- /config
Dann mounte /config als Netzlaufwerk in VS Code.
File Editor Add-on: Für schnelle Änderungen direkt in Home Assistant:
- Einstellungen → Add-ons → Add-on Store
- “File editor” installieren
- In der Seitenleiste aufrufen
YAML-Validierung
Home Assistant Check Config:
# In VS Code Terminal oder SSH
ha core check
Dies prüft die gesamte Konfiguration auf Fehler.
Online-Validatoren:
- yamllint.com für Syntax-Checks
- json2yaml.com für Konvertierungen
Entwicklungs-Workflow
1. Änderung in YAML vornehmen
2. Speichern und prüfen: Home Assistant lädt YAML-Dashboards automatisch neu. Bei Fehlern erscheint eine rote Benachrichtigung.
3. Browser-Cache leeren: Strg+F5 (Windows) oder Cmd+Shift+R (Mac) für saubere Darstellung.
4. Versionierung mit Git:
cd /config
git init
git add .
git commit -m "Dashboard Update: Wohnzimmer"
5. Backup vor größeren Änderungen:
cp lovelace-wohnzimmer.yaml lovelace-wohnzimmer.yaml.backup
Debugging-Tipps
Fehlermeldungen lesen: Home Assistant zeigt präzise Fehler mit Zeilennummer:
"Invalid config for [lovelace]: expected a dictionary @ data['views'][0]['cards']"
Entwickler-Tools: Einstellungen → Entwicklerwerkzeuge → Zustände:
- Prüfe Entity-IDs
- Teste Templates in Echtzeit
- Simuliere Zustände
Browser-Console: F12 → Console zeigt JavaScript-Fehler von Custom Cards.
Dashboard-Backup und Migration
Export: YAML-Dateien sind selbst dokumentierend. Kopiere sie für Backups oder teile sie.
Import:
- Datei nach
/configkopieren - In
configuration.yamlregistrieren - Neustart
Teilen mit der Community: Home Assistant Community Forum und Reddit r/homeassistant sind aktive Orte für Dashboard-Inspiration.
FAQ: Häufige Fragen zu YAML-Dashboards
Muss ich YAML für gute Dashboards nutzen?
Nein, der UI-Editor reicht für viele Anwendungsfälle. YAML ist aber notwendig für fortgeschrittene Features, Versionierung und professionelle Workflows.
Wie finde ich die Entity-ID einer Komponente?
Einstellungen → Geräte & Dienste → Entitäten. Oder Entwicklerwerkzeuge → Zustände.
Kann ich YAML und UI-Editor mischen?
Ja, aber nicht im selben Dashboard. Jedes Dashboard ist entweder YAML- oder UI-gesteuert.
Was ist der Unterschied zwischen views und cards?
Views sind die Tabs/Reiter eines Dashboards. Cards sind die Elemente innerhalb eines Views.
Wie füge ich Custom Cards hinzu?
Über HACS (Home Assistant Community Store) oder manuell:
JavaScript-Datei nach
/config/www/kopierenIn
configuration.yamlals Ressource registrieren:lovelace: resources: - url: /local/my-card.js type: module
Warum werden meine Änderungen nicht angezeigt?
- Browser-Cache leeren (Strg+F5)
- Home Assistant neu laden (Einstellungen → System → Neustarten)
- YAML-Syntax prüfen
Kann ich Dashboards für verschiedene Benutzer anpassen?
Ja, über die Benutzerverwaltung. Jeder Benutzer kann eigene Dashboards haben oder auf bestimmte Views beschränkt werden.
Wie mache ich Dashboards mobil-optimiert?
- Grid-Cards mit responsiven Spalten nutzen
- Swipe-Card für Touch-Navigation
- Conditional Cards für gerätespezifische Inhalte
columnsParameter in Grid/Stack anpassen
Was sind die besten Custom Cards?
- Mushroom: Moderne, schöne UI-Komponenten
- Button-Card: Hochgradig anpassbare Buttons
- Mini-Graph-Card: Kompakte Diagramme
- Swipe-Card: Touch-optimierte Navigation
- Auto-Entities: Dynamische Listen
Wie debugge ich Template-Fehler?
Entwicklerwerkzeuge → Vorlagen. Hier kannst du Templates in Echtzeit testen.
Kann ich Dashboards automatisch generieren?
Ja, mit Packages und Automatisierungen. Einige Integrationen erstellen automatisch Dashboards bei der Einrichtung.
Was ist HACS und brauche ich es?
HACS (Home Assistant Community Store) ist ein inoffizieller Store für Custom Components, Cards und Themes. Für fortgeschrittene Dashboards sehr empfohlen.
Fazit und nächste Schritte
YAML-Dashboards sind die Königsdisziplin der Home Assistant-Visualisierung. Sie bieten unübertroffene Flexibilität, volle Versionskontrolle und Zugang zu allen Features der Plattform.
Der Einstieg erfordert etwas Lernbereitschaft, aber die Grundlagen sind schnell beherrscht. Die YAML-Syntax ist intuitiv, und die Community bietet unzählige Beispiele zum Lernen und Adaptieren.
Deine nächsten Schritte:
Aktiviere den YAML-Modus: Konvertiere ein bestehendes Dashboard oder erstelle ein neues YAML-Dashboard
Installiere VS Code: Der beste Editor für Home Assistant mit Autocomplete und Syntax-Highlighting
Starte klein: Baue ein einfaches Dashboard mit Entities- und Button-Cards
Experimentiere mit Templates: Füge dynamische Inhalte hinzu
Installiere HACS: Erweitere deine Möglichkeiten mit Custom Cards
Teile deine Arbeit: Die Community gibt Feedback und Inspiration
Mit der Zeit wirst du ein Gespür dafür entwickeln, welche Karten für welche Zwecke geeignet sind. Du wirst eigene Patterns entwickeln und Templates wiederverwenden. Und irgwann wirst du auf dein Dashboard schauen und feststellen, dass es genau das tut, was du wolltest – elegant, effizient und genau nach deinen Vorstellungen.
Die Mühe lohnt sich. Ein gut gestaltetes YAML-Dashboard ist mehr als eine Steuerzentrale – es ist die visuelle Manifestation deines Smart Homes.
Hast du Fragen zu deinem Dashboard-Projekt? Zeige deine YAML-Konfiguration und lass uns gemeinsam optimieren.
Dieser Artikel wurde zuletzt aktualisiert: Februar 2026
Empfehlungen zum Thema (Affiliate-Links)
- Raspberry Pi 5 (4GB) – Leistungsstarker Mini-PC für Home Assistant
- SONOFF Zigbee 3.0 USB Dongle Plus – Zigbee-Koordinator für Home Assistant
- Aqara Temperature Sensor – Kompatible Sensoren für dein Dashboard