Du willst eine moderne Desktop-App bauen, aber eigentlich nur Python schreiben? Genau dafür gibt es NiceGUI. Das Framework aus dem Hause Zauberzeug erlaubt dir, Buttons, Tabellen, Charts und ganze Dashboards mit wenigen Zeilen Python zu erstellen. Kein HTML, kein JavaScript, kein Build-Prozess.
Doch wie funktioniert das eigentlich unter der Haube? In diesem Beitrag schauen wir uns den Tech Stack von NiceGUI genauer an: von FastAPI über Socket.IO bis zu Vue, Quasar und Tailwind CSS.
Was ist NiceGUI?
NiceGUI ist ein Open-Source-Framework, mit dem du grafische Benutzeroberflächen in Python entwickelst, die im Browser laufen. Du beschreibst deine Oberfläche in Python, NiceGUI kümmert sich um den Rest. Das Ergebnis ist eine echte Web-App, die du lokal, im Netzwerk oder in der Cloud betreibst.
Und das Beste:
Mit NiceGUI baust du auch richtige Desktop-Apps. Mit ui.run(native=True) läuft deine Anwendung in einem eigenen nativen Fenster, ganz ohne Browser. Zusammen mit Tools wie PyInstaller packst du sie sogar zu einer eigenständigen Anwendung für Windows, macOS oder Linux, die du weitergeben kannst.
Ein minimales Beispiel sieht so aus:
|
1 2 3 4 5 6 |
from nicegui import ui ui.label('Hallo NiceGUI!') ui.button('Klick mich', on_click=lambda: ui.notify('Geklickt!')) ui.run() |
Drei Zeilen Oberfläche, ein Aufruf zum Starten. Und trotzdem steckt dahinter ein ausgewachsener Web-Stack, den du sonst mühsam selbst zusammenbauen müsstest.
Wer oder was ist Zauberzeug?
Hinter NiceGUI steht die Zauberzeug GmbH aus Havixbeck bei Münster. Das Unternehmen wurde 2012 von Rodja Trappe gegründet, der es bis heute als CEO leitet. Zauberzeug ist kein klassisches Softwarehaus, sondern ein kleines Team, das Roboter und KI-Systeme entwickelt und baut.
Das bekannteste Produkt ist der Field Friend, ein modularer Feldroboter für die Landwirtschaft. Er erkennt mit Kameras und KI Unkraut und entfernt es mechanisch, ganz ohne Herbizide. Dafür wurde er unter anderem mit dem Münsterland Innovation Award ausgezeichnet. Damit die Bilderkennung mit jedem Einsatz besser wird, hat Zauberzeug den Learning Loop entwickelt: eine Plattform, über die eine ganze Roboterflotte gemeinsam lernt und neue KI-Modelle zurückbekommt.
Und genau hier kommt NiceGUI ins Spiel. Wer Roboter baut, braucht ständig Oberflächen: zum Steuern, zum Überwachen von Sensoren, für Karten, Kamerabilder und Einstellungen. Diese UIs sollen schnell entstehen, im Browser auf Tablet oder Laptop laufen und direkt mit dem Python-Code des Roboters sprechen. Aus diesem eigenen Bedarf ist NiceGUI entstanden und wurde 2022 als Open-Source-Projekt veröffentlicht. Maßgeblich betreut wird es von Rodja Trappe und Falko Schindler. Auch das Robotik-Framework RoSys stammt von Zauberzeug und nutzt NiceGUI für seine Oberflächen.
Für dich hat das einen handfesten Vorteil: NiceGUI ist kein Hobbyprojekt, sondern ein Werkzeug, das sein Hersteller täglich selbst im harten Praxiseinsatz auf dem Acker nutzt. Viele Features, etwa die 3D-Szenen mit three.js, interaktive Karten oder die Echtzeit-Updates per WebSocket, sind direkt aus solchen Anforderungen entstanden.
Der NiceGUI Tech Stack auf einen Blick
NiceGUI verbindet bewährte Technologien aus der Python-Welt mit etablierten Frontend-Frameworks. Die folgende Grafik zeigt dir die Schichten:
Das Backend: FastAPI, Starlette und Uvicorn
Auf der Serverseite setzt NiceGUI auf FastAPI, eines der beliebtesten Web-Frameworks im Python-Ökosystem. FastAPI basiert auf Starlette und wird von Uvicorn ausgeliefert, einem schnellen ASGI-Server. Dadurch ist NiceGUI von Grund auf asynchron und kommt gut mit vielen gleichzeitigen Verbindungen zurecht.
Für dich hat das einen großen Vorteil: Du hast über app direkten Zugriff auf die FastAPI-Instanz. Du kannst also ganz nebenbei REST-Endpunkte definieren, Middleware einbinden oder statische Dateien ausliefern:
|
1 2 3 4 5 6 7 8 9 10 11 |
from nicegui import app, ui @app.get('/api/status') def status(): return {'status': 'ok'} @ui.page('/') def index(): ui.label('Dashboard') ui.run() |
Umgekehrt funktioniert es auch: Du kannst NiceGUI in eine bestehende FastAPI-Anwendung einhängen. So bekommt deine API mit wenig Aufwand eine Admin-Oberfläche.
Die Verbindung: Socket.IO und WebSockets
Das Herzstück von NiceGUI ist die ständige Verbindung zwischen Browser und Server. Hier kommt Socket.IO ins Spiel. Sobald eine Seite geladen ist, baut der Browser eine WebSocket-Verbindung zum Server auf. Über diese Leitung laufen alle Interaktionen:
Klickst du auf einen Button, schickt der Browser ein Event an den Server. Dort läuft dein Python-Handler. Ändert der Handler etwas an der Oberfläche, etwa einen Text oder einen Wert, sammelt NiceGUI diese Änderungen und schickt sie gebündelt zurück an den Browser. Dieses Prinzip nennt man Backend-First: Der Zustand und die Logik deiner App leben in Python, der Browser zeigt nur an.
Das erklärt auch, warum Features wie Data Binding so elegant funktionieren. Mit bind_value oder bind_text_from verknüpfst du UI-Elemente direkt mit Python-Objekten, und NiceGUI hält beide Seiten synchron.
Das Frontend: Vue, Quasar und Tailwind CSS
Im Browser arbeitet ein klassischer moderner Frontend-Stack, den du nie direkt anfassen musst, aber jederzeit anfassen kannst.
Vue 3
Vue.js ist das reaktive Fundament. Jedes NiceGUI-Element entspricht im Browser einer Vue-Komponente. Kommt ein Update vom Server, aktualisiert Vue gezielt nur die betroffenen Teile der Seite. Wenn dir ein Element fehlt, kannst du eigene Vue-Komponenten schreiben und sie als Python-Klasse einbinden.
Quasar
Quasar liefert die fertigen UI-Komponenten im Material Design: Buttons, Inputs, Dialoge, Tabs, Menüs, Tabellen und vieles mehr. Viele ui.*-Elemente sind schlanke Python-Wrapper um Quasar-Komponenten. Deshalb kannst du mit .props() direkt Quasar-Eigenschaften setzen:
|
1 |
ui.button('Speichern').props('outline rounded color=green') |
Tailwind CSS
Für Layout und Styling ist Tailwind CSS an Bord. Über .classes() vergibst du Utility-Klassen für Abstände, Farben, Schriftgrößen oder Flexbox-Layouts. Seit NiceGUI 3.0 kommt Tailwind 4 zum Einsatz. Wenn du ein älteres Projekt aktualisierst, solltest du deine Layouts prüfen, da sich zum Beispiel Zeilenabstände und Rahmen leicht verändern können.
|
1 |
ui.label('Willkommen').classes('text-2xl font-bold text-blue-600 mb-4') |
Praxisbeispiel: Ein Dashboard-Layout
Wie Quasar und Tailwind zusammenspielen, siehst du am besten an einem kompletten Layout. Das folgende Beispiel baut ein kleines Dashboard mit Kopfzeile, ausklappbarer Seitenleiste, Kennzahlen-Karten, einem zweispaltigen Inhaltsbereich und einer Fußzeile:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
from nicegui import ui dark = ui.dark_mode() with ui.header().classes('items-center justify-between'): ui.label('Mein Dashboard').classes('text-xl font-bold') ui.button(icon='menu', on_click=lambda: drawer.toggle()).props('flat color=white') with ui.left_drawer().classes('bg-gray-100') as drawer: ui.label('Navigation').classes('text-lg font-bold mb-2') ui.button('Übersicht', icon='dashboard').props('flat align=left').classes('w-full') ui.button('Berichte', icon='bar_chart').props('flat align=left').classes('w-full') ui.button('Einstellungen', icon='settings').props('flat align=left').classes('w-full') with ui.row().classes('w-full gap-4'): for titel, wert in [('Nutzer', '1.284'), ('Umsatz', '12.430 €'), ('Tickets', '17')]: with ui.card().classes('flex-1'): ui.label(titel).classes('text-gray-500') ui.label(wert).classes('text-3xl font-bold') with ui.grid(columns=2).classes('w-full gap-4'): with ui.card(): ui.label('Letzte Aktivitäten').classes('font-bold') ui.label('Neuer Nutzer registriert') ui.label('Bestellung #1042 versendet') with ui.card(): ui.label('Einstellungen').classes('font-bold') ui.switch('Dark Mode').bind_value(dark, 'value') ui.slider(min=0, max=100, value=50) with ui.footer().classes('justify-center'): ui.label('© 2026 Meine Firma') ui.run(native=True) |
Die Bausteine sind schnell erklärt: ui.header, ui.left_drawer und ui.footer sind Quasar-Layout-Elemente, die NiceGUI automatisch an den richtigen Platz der Seite setzt. Mit with verschachtelst du Elemente ineinander, genau wie du es von Containern in HTML kennst. ui.row ordnet Elemente nebeneinander an, ui.column untereinander und ui.grid in einem Raster. Tailwind-Klassen wie flex-1, gap-4 oder w-full steuern dabei Breite und Abstände. Der Menü-Button klappt die Seitenleiste per drawer.toggle() ein und aus, und der Schalter für den Dark Mode ist per Data Binding direkt mit ui.dark_mode() verbunden.
Die Spezialisten: Eingebaute Bibliotheken
Ein großer Teil der Stärke von NiceGUI liegt in den integrierten JavaScript-Bibliotheken. Du nutzt sie, als wären es ganz normale Python-Elemente:
- AG Grid über
ui.aggridfür leistungsfähige Datentabellen mit Sortierung, Filtern und Bearbeitung - Apache ECharts über
ui.echartfür interaktive Diagramme - Plotly über
ui.plotlyund Matplotlib überui.pyplotfür wissenschaftliche Visualisierungen - Leaflet über
ui.leafletfür interaktive Karten - three.js über
ui.scenefür 3D-Szenen direkt im Browser - Mermaid über
ui.mermaidfür Diagramme aus Text - CodeMirror über
ui.codemirrorals Code-Editor mit Syntax-Highlighting
Gerade die Kombination aus AG Grid, ECharts und Pandas macht NiceGUI zu einer starken Wahl für Dashboards und interne Tools.
Native Mode: Desktop-Apps mit pywebview
Nicht jede App soll im Browser-Tab laufen. Mit ui.run(native=True) startet NiceGUI deine Oberfläche in einem eigenen Desktop-Fenster. Dafür nutzt das Framework pywebview, das die systemeigene Web-Engine verwendet. Der restliche Stack bleibt gleich: Im Hintergrund läuft weiterhin der FastAPI-Server, nur das Fenster ist nativ. Zusammen mit PyInstaller kannst du so sogar eigenständige Programme verteilen.
Auf welchen Plattformen laufen NiceGUI Apps?
Weil NiceGUI als reines Python-Paket ausgeliefert wird, läuft es überall dort, wo ein aktuelles Python läuft. Die wichtigste Voraussetzung ist deshalb nicht das Betriebssystem, sondern die Python-Version: Aktuelle NiceGUI-Versionen der 3er-Reihe benötigen Python 3.10 oder neuer (unterstützt werden 3.10 bis 3.14). Daraus ergeben sich die praktischen Mindestanforderungen:
- Windows: Windows 10 oder 11. Für den Native Mode nutzt pywebview die Edge-WebView2-Engine, die auf Windows 10 und 11 vorinstalliert ist bzw. per Update nachgeliefert wird.
- macOS: Die offiziellen Python-Installer von python.org setzen macOS 10.13 High Sierra oder neuer voraus. Für den Native Mode brauchst du eine WebKit-Version mit Unterstützung für ES-Module und Import Maps, also Safari bzw. WebKit ab Version 16.4. Das bekommst du ab macOS 11 Big Sur per Update. Apple Silicon und Intel werden beide unterstützt.
- Linux: Jede Distribution mit Python 3.10+, zum Beispiel Ubuntu 22.04 LTS, Debian 12 oder Fedora. Für den Native Mode brauchst du ein aktuelles WebKitGTK oder ein Qt-basiertes Backend.
- Raspberry Pi und Embedded: Auf ARM-Boards wie dem Raspberry Pi läuft NiceGUI problemlos, etwa unter Raspberry Pi OS Bookworm. Zauberzeug setzt das Framework selbst für die Steuerung von Robotern ein.
- Docker: Das offizielle Multi-Arch-Image
zauberzeug/niceguiläuft auf jedem Docker-Host, egal ob Server, NAS oder Cloud.
Auf der Client-Seite ist es noch einfacher: Im Browser-Modus öffnest du die App mit jedem modernen Browser, der ES-Module und Import Maps beherrscht. Das sind Chrome und Edge ab Version 89, Firefox ab 108 und Safari ab 16.4. Damit funktionieren auch Smartphones und Tablets mit iOS oder Android, ohne dass dort Python installiert sein muss.
Deployment: So bringst du deine NiceGUI App an den Start
Beim Deployment hast du drei typische Wege. Welcher passt, hängt davon ab, ob deine App zentral auf einem Server laufen oder als Programm auf den Rechnern deiner Nutzer landen soll.
Variante 1: Direkt auf dem Server
Der klassische Weg: Du installierst NiceGUI mit pip in einer virtuellen Umgebung, startest dein Skript als systemd-Dienst und setzt einen Reverse Proxy wie NGINX davor, der HTTPS übernimmt. Alternativ übergibst du ui.run() direkt die Parameter ssl_certfile und ssl_keyfile. Beachte, dass NiceGUI standardmäßig mit einem einzigen Uvicorn-Worker läuft, weil der Zustand jeder Seite im Speicher des Servers liegt. Mehrere Worker sind möglich, brauchen aber zusätzliche Konfiguration.
Variante 2: Docker
Am bequemsten ist das offizielle Docker-Image. Du mountest deinen Code nach /app und bist fertig:
|
1 2 3 4 |
docker run -it --restart always \ -p 80:8080 \ -v $(pwd)/:/app/ \ zauberzeug/nicegui:latest |
Für eigene Abhängigkeiten baust du einfach ein eigenes Image auf Basis von zauberzeug/nicegui und installierst deine Pakete im Dockerfile. So ist die komplette Umgebung reproduzierbar eingefroren.
Variante 3: Als Desktop-Programm verpacken
Für Desktop-Apps bringt NiceGUI das Kommando nicegui-pack mit, einen Wrapper um PyInstaller. Er packt Python-Interpreter, NiceGUI, alle Abhängigkeiten und die Frontend-Dateien in eine ausführbare Datei:
|
1 |
nicegui-pack --onefile --windowed --name "meineapp" main.py |
Wichtig dabei: Setze in ui.run() den Parameter reload=False und nutze --windowed nur zusammen mit native=True. Die Variante --onefile startet etwas langsamer, weil sie bei jedem Start in ein temporäres Verzeichnis entpackt wird. Mit --onedir geht der Start schneller. Alternativ kannst du auch Nuitka verwenden.
Und was ist mit den Python Dependencies?
Die Sorge ist berechtigt, denn Abhängigkeiten sind bei Python-Projekten oft der größte Stolperstein. Bei NiceGUI ist die Lage aber entspannter als gedacht:
- Kein Node.js, kein npm: Alle Frontend-Bibliotheken wie Vue, Quasar oder AG Grid stecken bereits fertig im Python-Paket. Auf dem Zielsystem brauchst du keine JavaScript-Toolchain.
- Reines Python-Paket: NiceGUI selbst ist plattformunabhängig und muss nicht kompiliert werden. Auch die wichtigsten Abhängigkeiten wie FastAPI, Uvicorn und python-socketio gibt es als fertige Wheels für alle gängigen Systeme.
- Versionen festnageln: Halte deine Abhängigkeiten in einem Lockfile fest, zum Beispiel mit
uv lock, Poetry oder einerrequirements.txtmit exakten Versionen. So bekommst du auf dem Server genau die Umgebung, die du lokal getestet hast. - Isolieren statt global installieren: Nutze immer eine virtuelle Umgebung oder Docker. Dann kommen sich deine App und andere Python-Programme auf dem System nicht in die Quere.
- Endnutzer brauchen kein Python: Bei Desktop-Programmen steckt der Interpreter samt aller Pakete im Bundle. Deine Nutzer installieren gar nichts.
Ein paar Fallstricke gibt es trotzdem. PyInstaller erzeugt keine Cross-Builds: Eine Windows-.exe baust du auf Windows, eine macOS-.app auf einem Mac. Am einfachsten automatisierst du das mit einer CI-Pipeline wie GitHub Actions. Pakete mit kompiliertem Code wie NumPy oder Pandas machen das Bundle deutlich größer. Und für den Native Mode musst du pywebview mitinstallieren, am einfachsten mit pip install "nicegui[native]". Alle Details findest du im Kapitel Configuration & Deployment der NiceGUI-Dokumentation.
Was ist neu in NiceGUI 3?
Mit Version 3.0 hat das Team vor allem an der Entwickler-Ergonomie gearbeitet. Zu den wichtigsten Neuerungen zählen:
- Script Mode: Kleine Apps brauchen keine
@ui.page-Dekoratoren mehr, du schreibst einfach von oben nach unten. - Root-Page-Parameter: Er vereinfacht Single-Page-Apps mit eigener Navigation.
- Event-System: Langlebige Objekte im Backend können sauber mit der Oberfläche kommunizieren.
- Aktualisierte Abhängigkeiten: Tailwind 4, aktuelle Versionen von Vue 3, Quasar 2 und Socket.IO.
NiceGUI entwickelt sich schnell weiter. Schau vor dem Start eines neuen Projekts am besten in die aktuellen Release Notes.
Warum dieser Tech Stack so gut funktioniert
Der Clou von NiceGUI ist, dass es das Rad nicht neu erfindet. Statt eigene Rendering-Engines zu bauen, kombiniert es ausgereifte Werkzeuge, die Millionen Entwickler täglich nutzen. Für dich bedeutet das:
- Nur Python: Du bleibst in deiner Sprache und nutzt dein gesamtes Python-Ökosystem.
- Kein Build-Schritt: Kein npm, kein Webpack, kein Bundler. Installieren, schreiben, starten.
- Volle Flexibilität: Wenn du willst, greifst du auf FastAPI, Quasar-Props, Tailwind-Klassen oder eigenes JavaScript zu.
- Echtzeit ohne Aufwand: Dank WebSockets aktualisiert sich die Oberfläche sofort, ohne dass du Polling oder Reloads einbauen musst.
Es gibt aber auch Grenzen: Weil die Logik auf dem Server läuft, braucht jede Interaktion eine aktive Verbindung. Für Offline-Apps oder öffentliche Websites mit extrem vielen Besuchern ist NiceGUI daher nicht die erste Wahl. Für Dashboards, Steuerungsoberflächen, Maschinen-UIs, interne Tools und Prototypen spielt es seine Stärken dagegen voll aus.
FAQ zum NiceGUI Tech Stack
Nein. Du schreibst deine komplette Oberfläche in Python. Kenntnisse in Tailwind CSS oder Quasar helfen dir beim Feinschliff des Designs, sind aber kein Muss. FastAPI ist der Webserver unter NiceGUI. Er liefert die Seiten aus, verwaltet die Routen und stellt dir über Socket.IO sorgt für eine dauerhafte Verbindung zwischen Browser und Server. Darüber laufen Events wie Klicks zum Server und UI-Updates zurück zum Browser, und das in Echtzeit. Streamlit führt bei jeder Interaktion das gesamte Skript erneut aus. NiceGUI arbeitet ereignisbasiert: Nur der betroffene Handler läuft, und nur die geänderten Elemente werden aktualisiert. Das macht komplexere, zustandsbehaftete Apps einfacher. Ja. Mit Aktuelle NiceGUI-Versionen benötigen Python 3.10 oder neuer. Damit läuft NiceGUI auf Windows 10 und 11, auf macOS ab 10.13 sowie auf allen gängigen Linux-Distributionen, auch auf dem Raspberry Pi. Für den Native Mode brauchst du zusätzlich eine moderne Web-Engine wie Edge WebView2, WebKit ab 16.4 oder ein aktuelles WebKitGTK. Nein. Im Browser-Modus läuft Python nur auf dem Server, deine Nutzer brauchen lediglich einen modernen Browser. Verpackst du deine App mit Für Server-Apps ist das offizielle Docker-Image NiceGUI wird von der Zauberzeug GmbH aus Havixbeck bei Münster entwickelt. Das Unternehmen baut Roboter wie den Feldroboter Field Friend und hat NiceGUI ursprünglich für die eigenen Roboter-Oberflächen geschaffen. Seit 2022 ist das Framework Open Source.
Muss ich JavaScript oder HTML können, um NiceGUI zu nutzen?
Welche Rolle spielt FastAPI in NiceGUI?
app die volle FastAPI-Funktionalität zur Verfügung, etwa für eigene REST-Endpunkte.Warum nutzt NiceGUI Socket.IO?
Was ist der Unterschied zwischen NiceGUI und Streamlit?
Kann ich mit NiceGUI auch Desktop-Programme bauen?
ui.run(native=True) läuft deine App in einem eigenen Fenster auf Basis von pywebview. Mit Tools wie PyInstaller kannst du daraus eine ausführbare Datei erstellen.Welche Python-Version und welches Betriebssystem brauche ich für NiceGUI?
Müssen meine Nutzer Python installieren?
nicegui-pack als Desktop-Programm, stecken Interpreter und alle Abhängigkeiten im Bundle.Wie deploye ich eine NiceGUI App am einfachsten?
zauberzeug/nicegui der schnellste Weg, idealerweise mit NGINX oder Traefik als Reverse Proxy für HTTPS. Für Desktop-Apps nutzt du nicegui-pack und baust die Datei jeweils auf dem Zielbetriebssystem.Wer entwickelt NiceGUI?
Fazit
NiceGUI zeigt eindrucksvoll, wie viel moderne Webtechnologie sich hinter ein paar Zeilen Python verstecken lässt. FastAPI, Starlette und Uvicorn sorgen für ein schnelles, asynchrones Backend. Socket.IO hält Browser und Server in Echtzeit synchron. Vue, Quasar und Tailwind CSS liefern ein ansprechendes Frontend, und Bibliotheken wie AG Grid, ECharts oder three.js erweitern die Möglichkeiten enorm. Wenn du als Python-Entwickler schnell schöne Oberflächen bauen willst, ist NiceGUI eine fantastische Wahl.
Mehr Details findest du in der offiziellen NiceGUI-Dokumentation, im GitHub-Repository von NiceGUI und in der Podcast-Folge „NiceGUI Goes 3.0“ bei Talk Python To Me.
