Streamlit vs. NiceGUI (2026): Das beste Python-Web-Framework

Hinweis: Diese Anleitung enthält Referral-Links. Wenn du darüber kaufst, erhalte ich möglicherweise eine Provision – ohne zusätzliche Kosten für dich.

Streamlit vs NiceGUI ist der Vergleich, den ich am häufigsten sehe, wenn jemand ein Python-Web-Framework will und kein HTML von Hand schreiben möchte. Beide lassen dich interaktive Web-Apps in weitgehend Python bauen, beide sind Open Source, und beide laufen problemlos als einzelner Docker-Container auf einem kleinen VPS. Beide haben sich im letzten Jahr außerdem so stark verändert, dass ältere Vergleichsartikel inzwischen falsch sind.

Aktualisiert Oktober 2026. Versionen gecheckt gegen PyPI und GitHub am 2026-10-07: Streamlit 1.65.0 (released 2026-10-02) und NiceGUI 3.17.1 (2026-09-18). Wenn du einen Guide liest, der NiceGUI noch als 2.0-Ära-Framework bezeichnet, schließ ihn.

Die kurze Positionierung bleibt dieselbe wie 2024. Streamlit zielt auf Data-Apps: Dashboards, Datenexploration, ML-Demos. Du schreibst ein Python-Skript von oben nach unten, und Streamlit rendert es als Web-App mit eingebauten Charts, Tabellen und Filtern. NiceGUI zielt auf App-artige UIs: Formulare, Admin-Panels, Monitoring-Tools, IoT-Controller. Es ist event-driven, läuft auf FastAPI und gibt dir deutlich mehr Kontrolle über Layout, Events und State.

Kurzvergleich auf einen Blick

Diese Tabelle ist Orientierung, nicht das Urteil. Die Entscheidung läuft weiterhin über das Entwicklungsmodell: Script-Reruns versus Event-Callbacks. Wenn das stimmt, folgt der Rest.

Für weitere Optionen jenseits dieser zwei, siehe: Beste Python-Web-Frameworks

Streamlit vs NiceGUI: die Hauptunterschiede 2026

Die Kernpositionierung hat sich nicht bewegt. Was sich geändert hat, ist das Plumbing unter beiden Frameworks. So unterscheiden sie sich 2026 – mit den Daten, damit du siehst, wie frisch die Aussagen sind.

Primärer Zweck

Streamlit ist für Data Science, ML und Analytics-Dashboards gebaut. Sein Widget-Set, das DataFrame-Rendering und die Chart-Helper setzen alle diesen Workflow voraus. NiceGUI ist für general-purpose Web-Apps mit desktop-artigen Oberflächen gebaut: Formulare, Admin-Panels, Kontrollbildschirme.

Keines der Frameworks hat 2026 die Seite gewechselt. Streamlit fühlt sich immer noch an wie ein Notebook, dem ein Webserver gewachsen ist. NiceGUI fühlt sich immer noch an wie ein GUI-Toolkit, das zufällig im Browser läuft. NiceGUI liefert außerdem die Extras, die es eher zu einem App-Framework als zu einem Dashboard-Tool machen: native/Desktop-Fenster (PySide6-basiert), run.cpu_bound und run.io_bound für Hintergrundarbeit und ui.timer für Live-Dashboards.

Entwicklungsmodell: Script-Reruns vs event-driven

Das ist der Entscheidungsfaktor. Alles andere ist zweitrangig.

Streamlit führt dein Skript bei jeder Interaktion von oben nach unten aus. Dieses Modell ist todeinfach, bis deine App oben in der Datei schwere Arbeit ansammelt. Seit 1.37 und mit laufenden Ergänzungen bis 1.63 begrenzt @st.fragment einen Rerun auf einen Block der Seite (1.58 brachte parallel=True; 1.63 brachte Event-scoped Reruns mit @st.fragment(key=...) und st.rerun("name")). Fragmente fixen das Schlimmste der Full-Rerun-Ruckler, aber das mentale Modell bleibt „das Skript läuft nochmal”.

NiceGUI ruft deinen Handler auf und aktualisiert die Elemente, die du anfasst. Der UI-State synct über einen persistenten WebSocket. Nichts läuft von oben neu.

Wenn dein mentales Modell ein Notebook ist, gewinnt Streamlit. Wenn es ein GUI mit Event-Handlern ist, gewinnt NiceGUI. Schau nochmal auf das Diagramm oben.

Anpassbarkeit

Die alte „Streamlit ist limitiert”-Zeile braucht inzwischen einen Stern. Streamlit 1.51 (2025-10-29) lieferte Custom Components v2 (frameless, bidirektional), eigene Light- und Dark-Themes und wiederverwendbare Theme-Dateien. Du kannst ein gebrandetes internes Dashboard bauen, ohne das Framework zu forken.

An NiceGUI kommt es trotzdem nicht heran. NiceGUI sitzt auf Quasar/Vue mit Tailwind 4 (Upgrade in 3.0), und du kannst auf rohes HTML/CSS/JS runtergehen, wann immer die Component-Library ausgeht. Layouts sind explizit: Rows, Columns, Grids, Tabs, Dialogs, Drawers. Multi-Page-Apps sind ein First-Class-Pattern via @ui.page (siehe, wie man mehrere Seiten zu NiceGUI hinzufügt).

Streamlit hat auch Multi-Page-Apps, aber die Navigation ist dateibasiert, und das Page-Chrome ist weitgehend fix. Wenn du Pixel-level-Kontrolle brauchst oder ein Layout, das nicht nach einer Streamlit-App aussieht, ist NiceGUI die Wahl.

Backend-Architektur

Beide Frameworks sind 2026 ASGI-Apps. Das alte Framing „Streamlit hat einen Toy-Server, NiceGUI hat FastAPI” ist tot.

Streamlit hat Tornado in 1.57 (2026-04-29) durch Starlette/Uvicorn ersetzt. st.App (experimentell in 1.53, verfügbar seit dem Starlette-Wechsel) ist ein ASGI-Entry-Point, der eigene Routes, Middleware und Lifecycle-Hooks akzeptiert und mit FastAPI- oder Starlette-Apps zusammenspielt. Async/await im App-Code kam in 1.64 (2026-09-15), gecachte Funktionen inklusive.

NiceGUI war von Anfang an FastAPI/Starlette/Uvicorn und kann in eine bestehende FastAPI-App gemountet werden, sodass API und UI einen Prozess teilen. Der dokumentierte Integrationspunkt ist ui.run_with(app) (check den Configuration-and-Deployment-Abschnitt der NiceGUI-Docs für die exakte Signatur deiner Version).

Echtzeit-Features

Streamlit aktualisiert bei Interaktion: Eine Widget-Änderung lässt das Skript (oder das Fragment) neu laufen. Seit 2026 kannst du Reruns präziser zielen, aber das Modell bleibt Pull-bei-Interaktion. Gut genug für Filter, Drilldowns und Dashboards, die refreshen, wenn ein User klickt.

NiceGUI ist die natürliche Wahl für Monitoring- und Kontroll-Panels. ui.timer pollt oder pusht, jeder Client hält seinen eigenen State, und Handler aktualisieren einzelne Elemente. Live-Counter, Log-Tails, IoT-Controls und „die Seite aktualisiert sich ohne mein Zutun”-UIs sind Default-Verhalten, kein Workaround.

Lernkurve

Streamlit ist immer noch der freundlichste Weg in Python-Web-Apps. Wenn du ein Skript mit pandas schreiben kannst, shippst du an einem Nachmittag ein Dashboard. Du schreibst kein HTML und keine Callbacks, und es gibt keine State Machine zu verwalten.

NiceGUI ist etwas steiler. Du musst Event-Handler verstehen, wann man ui.clear() nutzt und wie Per-Client-State funktioniert. Basis-HTML/CSS-Wissen hilft beim Layout. Es zahlt diesen Preis in dem Moment zurück, in dem du etwas mit mehr als ein paar Interaktionen baust.

Beide brauchen inzwischen Python >= 3.10 (PyPI requires_python, gecheckt 2026-10-07). Auf einem alten Base-Image schlägt die Installation fehl, bevor du eine Zeile Code schreibst.

Community & Ressourcen

GitHub-Stars Stand 2026-10-07: Streamlit 45.909, Gradio 43.677, Reflex 28.937, Dash 24.442, Flet 17.263, NiceGUI 16.269. Download-Zahlen und Stars sind keine Qualität, aber sie sagen voraus, wie schnell du eine Stack-Overflow-Antwort findest.

Streamlit released alle 4 bis 6 Wochen und hat ein großes Beispiel-Ökosystem, plus Streamlit Community Cloud zum kostenlosen Veröffentlichen. NiceGUI ist aktiv (58 offene Issues beim letzten Check), mit der 3.x-Linie auf dem Weg zu einer 4.0, die in den Release Notes schon angekündigt ist. Seine Community ist kleiner und Self-Hosting-fokussiert. Du wirst die Docs mehr lesen und Stack Overflow weniger.

Lizenz & Kosten

Streamlit ist Apache-2.0 und gehört seit 2022 Snowflake. Das OSS-Paket bleibt Apache; „Streamlit in Snowflake” ist der kommerzielle Pfad. NiceGUI ist MIT, maintained von Zauberzeug (unabhängig), ohne Bezahlebene.

Authentifizierung 2026

Der alte Rat war „Streamlit hat keine Auth, NiceGUI braucht FastAPI-Patterns”. Die Hälfte davon stimmt nicht mehr. Streamlit lieferte First-Party-OIDC in 1.42 (2025-02-04) und st.user.tokens in 1.53 (2026-01-14). NiceGUIs Story ist unverändert: Du baust Auth selbst zusammen, und du besitzt den Session-Stack.

Streamlits eingebautes OIDC (st.login() / st.logout())

st.login() leitet zu jedem konfigurierten OIDC-Provider weiter (Google, Okta, Auth0, Keycloak, was auch immer OIDC spricht). st.user gibt dir die Claims nach dem Redirect; st.user.tokens legt die rohen OIDC-Tokens offen, wenn du Downstream-APIs aufrufen musst. Die Konfiguration lebt in .streamlit/secrets.toml. Die Docs zur exakten Secrets-Form sind umgezogen, also kopier von der aktuellen Streamlit-Auth-Seite statt aus einem älteren Tutorial.

NiceGUIs Middleware + app.storage.user-Pattern

NiceGUI dokumentiert ein Authentication-Pattern auf Middleware, app.storage.user und einem storage_secret. Du verdrahtest den Login-Check selbst, speicherst die User-Identität im Per-User-Storage und leitest unauthentifizierte Clients um. Wenn du NiceGUI in deine eigene FastAPI-App mountest, kannst du stattdessen jede Auth-Middleware oder Dependency Injection nutzen, die du schon fährst. Mehr Zusammenbau nötig, aber du besitzt Session- und Auth-Stack Ende zu Ende.

Die zwei Patterns als minimale Code-Formen:

import streamlit as st

if not st.user.is_logged_in:
    st.login()  # redirects to your OIDC provider
else:
    st.write(f"Hello, {st.user.name}")
    # st.user.tokens has the raw OIDC tokens (since 1.53)
    st.button("Log out", on_click=st.logout)

from nicegui import ui, app

# storage_secret comes from ui.run(storage_secret='change-me-to-a-long-random-string')
# and is required before app.storage.user works.

@ui.page('/private')
def private_page():
    if not app.storage.user.get('authenticated', False):
        ui.navigate.to('/login')
        return
    ui.label(f"Hello, {app.storage.user.get('username')}")

# Wire the actual login check in middleware (see NiceGUI docs,
# Authentication section) or use FastAPI auth when mounted via ui.run_with(app)

Wann du welches Framework wählen solltest

„Streamlit vs NiceGUI, welches ist besser” ist die falsche Frage. Welches zum Projekt passt, ist die richtige. Hier ist die Trennung, die ich nutze.

Wähle Streamlit, wenn…

Streamlit ist der schnellste Weg vom Notebook zum geteilten Dashboard.

Beispiel-Use-Cases: Sales-Analytics-Dashboard, Machine-Learning-Modell-Demo, Finanzdaten-Explorer, Forschungsdaten-Visualisierung.

Wähle NiceGUI, wenn…

NiceGUI ist das Werkzeug, wenn das „Dashboard” Buttons, Formulare und User wachsen bekommt.

Beispiel-Use-Cases: Projektmanagement-Tools, IoT-Geräte-Controller, interaktive Formulare und Umfragen, Echtzeit-Monitoring-Systeme.

NiceGUI läuft auch als natives Desktop-Fenster (PySide6), was ein netter Trick ist, wenn die „Web-App” sich als internes Desktop-Tool entpuppt.

Wenn keines der Frameworks passt

Loslegen: Code-Beispiele

Streamlit-Beispiel: Daten-Dashboard

import streamlit as st
import pandas as pd

st.title("Sales Dashboard")

data = pd.DataFrame({
    "Month": ["Jan", "Feb", "Mar", "Apr"],
    "Sales": [100, 150, 120, 200],
})

month = st.selectbox("Select month", data["Month"])
filtered = data[data["Month"] == month]

st.bar_chart(data.set_index("Month"))
st.metric(f"Sales for {month}", f"${int(filtered['Sales'].iloc[0])}")

@st.fragment  # reruns only this block, not the whole script
def notes():
    if st.button("Add note"):
        st.session_state.notes = st.session_state.get("notes", []) + [month]

notes()

Verifizieren: installieren und ausführen, dann checken, dass die App antwortet.

pip install streamlit pandas
streamlit run app.py

Öffne http://localhost:8501. Als Sanity Check, bevor du irgendetwas schreibst: streamlit hello führt die eingebaute Demo-App aus. Wenn curl -s http://localhost:8501/_stcore/health ok ausgibt, läuft der Server.

Fehlerbild: Port 8501 is already in use heißt, etwas anderes besitzt den Port. Entweder stoppe es oder führ streamlit run app.py --server.port 8502 aus.

NiceGUI-Beispiel: interaktives Formular

from nicegui import ui

def handle_submit():
    ui.notify(f"Hello {name.value}! You are {age.value} years old.")

ui.label("User Information Form")

with ui.row():
    name = ui.input("Name", placeholder="Enter your name")
    age = ui.number("Age", value=25, min=0, max=120)

ui.button("Submit", on_click=handle_submit)

ui.run(title="bitdoze demo")  # NiceGUI 3.x, Uvicorn under the hood, WebSocket UI sync

Verifizieren:

pip install nicegui
python main.py

Öffne http://localhost:8080, schick das Formular ab und bestätige, dass der Notification-Toast unten rechts erscheint. Das Terminal zeigt die Uvicorn-Startzeile; das ist dein Hinweis, dass der Server lauscht.

Fehlerbild: der häufigste Installationsfehler ist Requires-Python >=3.10 (oder ein Resolution-Fehler, der es erwähnt). Der Fix ist ein neueres Python, nicht ein neueres pip.

Was ist leichter zu lernen?

Streamlit gewinnt bei absoluten Einsteigern. Lineares Skript rein, Web-App raus. NiceGUI ist zugänglich, sobald das Callback- plus ui.clear()-Mentalmodell klickt, und es zahlt sich weiter aus, während die App wächst. Beide brauchen Python >= 3.10. Wenn du noch nie eine Web-App gebaut hast, starte ein Wochenende mit Streamlit und schau dir NiceGUI an, wenn dich das Rerun-Modell zu nerven beginnt.

Streamlit und NiceGUI auf einem VPS self-hosten

Beide Frameworks self-hosten auf dieselbe langweilige Weise: ein Docker-Container hinter einem Reverse Proxy auf einem kleinen VPS. Keines braucht eine Datenbank zum Laufen. Das ist der Abschnitt, den andere Vergleichsartikel überspringen – und genau da, wo beide Frameworks in Produktion scheitern.

Voraussetzungen

Bevor du startest, sollte all das stehen:

Docker-Setup und Healthchecks

Ein Container ohne Healthcheck ist ein Container, den du nicht sicher neu starten kannst. Streamlit hat einen eingebauten Endpoint. NiceGUI nicht, also exponierst du einen.

FROM python:3.12-slim
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends curl \
    && rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8501
HEALTHCHECK CMD curl -f http://localhost:8501/_stcore/health || exit 1
CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

# main.py
from fastapi import FastAPI
from nicegui import ui

app = FastAPI()

@app.get('/health')
def health():
    return {'ok': True}

@ui.page('/')
def index():
    ui.label('Hello from NiceGUI')

# Mount NiceGUI into the FastAPI app so /health and the UI share one process.
# Check the exact run_with signature in the NiceGUI docs for your version.
ui.run_with(app)

FROM python:3.12-slim
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends curl \
    && rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8080
HEALTHCHECK CMD curl -f http://localhost:8080/health || exit 1
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

Eine minimale Compose-Datei-Form (auf die beweglichen Teile gekürzt):

services:
  streamlit:
    build: ./streamlit-app
    ports:
      - "8501:8501"
    restart: unless-stopped
  nicegui:
    build: ./nicegui-app
    ports:
      - "8080:8080"
    restart: unless-stopped

Verifizieren:

curl -f http://localhost:8501/_stcore/health   # -> ok
curl -f http://localhost:8080/health          # -> {"ok": true}
docker ps                                     # STATUS column shows (healthy)

Fehlerbilder: curl: (7) Connection refused im Container heißt meist, die App startet noch oder ist an 127.0.0.1 statt 0.0.0.0 gebunden. curl: (22) vom Healthcheck heißt, der Endpoint 404’t – bei NiceGUI bedeutet das, die FastAPI-Route ist nicht gemountet. unhealthy in docker ps bei einer App, die im Browser funktioniert, ist fast immer ein Tippfehler in der Health-URL.

Für eine längere Behandlung von Python-Apps in Containern, siehe jede Python-App in Docker mit Docker Compose laufen lassen.

Reverse-Proxy- und WebSocket-Hinweise

Der Nummer-eins-Realweltfehler bei beiden Frameworks ist eine leere Seite oder ein endloser Spinner hinter einem Reverse Proxy. Beide Symptome bedeuten dasselbe: Das WebSocket-Upgrade wird nicht weitergeleitet.

location / {
    proxy_pass http://streamlit:8501;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_read_timeout 86400;
}

labels:
  - traefik.http.routers.streamlit.rule=Host(`app.example.com`)
  - traefik.http.services.streamlit.loadbalancer.server.port=8501
  # Traefik forwards WebSocket upgrades by default.
  # Raise forwardAuth/response timeouts if you see idle sockets drop.

app.example.com {
    reverse_proxy streamlit:8501
    # Caddy forwards WebSocket upgrades without extra config
}

Verifizieren: Öffne die App über die Proxy-URL, nicht den Container-Port. Browser-Dev-Tools, Network-Tab: Der WebSocket-Request sollte Status 101 (Switching Protocols) zeigen. Ein Status 200 oder 400 auf diesem Request ist dein fehlschlagendes Upgrade.

Fehlerbilder:

• Leere Seite, keine Fehler im App-Log: fehlende Upgrade/Connection-Header (Nginx ohne den proxy_http_version 1.1-Block oben).
• App lädt, dann löst der Spinner nie auf: Ein Idle-Timeout killt den Socket. Erhöh proxy_read_timeout oder das Traefik-Äquivalent.
• Streamlit 1.60 (2026-07-21) lieferte breaking Security-Hardening: Origin- und Host-Message-Checks (CWE-346), Query-String-Caps bei 512 KiB / 1.000 Felder und server.maxWidgetStateSize (Default 25 MB). Wenn du Streamlit hinter einem Proxy mit nicht-standardmäßiger Host- oder X-Forwarded-Host-Behandlung fährst, lies diese Release Note vor dem Upgrade und teste auf deinem eigenen Stack. Ein Standard-Caddy- oder -Traefik-Setup sollte unbetroffen sein, aber ungewöhnliches Header-Rewriting ist genau das, wonach diese Checks suchen.

Kosten- und Ressourcen-Hinweise

Größenordnungs-Zahlen, weil genau hier Leute überrascht werden:

• Beide Apps self-hosten auf einem kleinen VPS (2 vCPU, 2-4 GB RAM, grob EUR 5/Monat). Keines braucht eine Datenbank. Ein Hostinger-VPS ist eine Budget-Alternative mit NVMe-Storage, wenn du mehr Disk für Daten-Workloads willst.
• Streamlit hält State pro Session-Prozess. RAM skaliert mit gleichzeitigen Sessions, nicht nur mit dem Code. Wenn zwanzig Leute dein Dashboard öffnen, budgetiere zwanzig Sessions. Das ist die echte VPS-Sizing-Überlegung.
• NiceGUI hält ebenfalls Per-Client-State im Worker. Multi-Worker-Deployments haben Fallstricke (in den NiceGUI-Docs dokumentiert), also lies das, bevor du horizontal skalierst.
• Streamlit Community Cloud: kostenlos, aber 12-Stunden-Ruhezustand plus Ressourcen-Caps, wie oben behandelt. Okay für Demos. Für always-on interne Tools: self-hosten.
• Pinne deine Image-Tags und Paket-Versionen. NiceGUI 3.0 war breaking, und 4.0-Deprecations sind schon angekündigt; Streamlit entfernt alle paar Releases deprecated APIs.
• Rollback-Pfad: Behalte den vorherigen Image-Tag. Wenn ein Bump die App bricht, docker compose up den alten Tag. Das ist der ganze Undo-Plan, und er funktioniert.

Wenn du den PaaS-förmigen Weg statt rohem Compose willst, deploye ein Python-uv-Projekt mit Dokploy. Für das volle Streamlit-Runbook inklusive TLS und Tunnels, deploye Streamlit auf einem VPS mit Cloudflare Tunnels.

Alternativen 2026

Wenn keines der Frameworks passt, sehen die aktuellen Streamlit-Alternativen (Versionen und Stars gecheckt 2026-10-07) so aus:

• Gradio 6 (6.29.1, 43.7k Stars): ML-Demos und Hugging Face Spaces. Wenn die App „Modell rein, Sample raus” ist, ist Gradio immer noch der kürzeste Weg.
• Dash 4.4 (24.4k Stars): das OG-Python-Analytics-Framework von Plotly, jetzt auf der 4.x-Linie. Heavy-Duty-Dashboards mit Callbacks.
• Reflex 0.9 (28.9k Stars): Full-Stack-Python, das zu Next.js kompiliert. Mehr wie eine klassische Web-App bauen, nur ohne Python zu verlassen.
• Flet (17.3k Stars): Flutter-basiert, liefert Desktop und Web aus einer Codebase.
• Taipy: Pipeline plus GUI für Data-Apps. Wir haben es direkt im Streamlit-vs-Taipy-Vergleich verglichen.
• FastHTML: leichtes Python-UI für Leute, die HTML-förmige Kontrolle ohne ein großes Framework wollen. Siehe FastHTML für Einsteiger.

Eine Warnung: Googles Mesop stand 2024 auf jeder „beobachtenswert”-Liste, inklusive der früheren Version dieses Artikels. Das Repo ist 2026 archiviert. Experimentelle Frameworks großer Vendoren können verschwinden. Bevorzuge Projekte mit einer Release-Historie, die du auditieren kannst.

Das breitere Feld steht in beste Python-Web-Frameworks.

Welches solltest du wählen?

Um „Streamlit vs NiceGUI, welches ist besser” direkt zu beantworten: Keines ist objektiv besser. Wähl für das Projekt, nicht für die Benchmark-Chart. Beide werden aktiv maintained und sind 2026 produktions-tauglich.

Starte mit dem Framework, das zum Projekt vor dir passt. Du kannst später wechseln, wenn das Projekt die Form ändert; beide APIs sind klein genug, dass ein Rewrite nach einem Prototyp billig ist.

Streamlit vs NiceGUI FAQ

Quick-Start-Ressourcen

Streamlit:

• Offizielle Dokumentation
• 30-Days-of-Streamlit-Challenge
• Streamlit auf VPS deployen

NiceGUI:

• Offizielle Dokumentation (die Abschnitte Authentication und Configuration/Deployment decken die Auth- und Healthcheck-Patterns oben ab)
• NiceGUI-Tutorial für Einsteiger
• GitHub-Beispiele