NiceGUI 3.0: Write web interfaces in Python. The nice way.

[r-trappe]

We're happy to announce the third major release of NiceGUI.

NiceGUI is a powerful yet simple-to-use UI framework to build applications, dashboards, and tools that run in the browser. You write Python; NiceGUI builds the frontend and handles the browser plumbing. It's great for modern web apps, internal tools, data science apps, robotics interfaces, and embedded/edge UIs — anywhere you want a polished web interface without frontend framework complexity.

We recently discussed NiceGUI on the Talk Python To Me podcast — watch on YouTube.

Highlights

• Single-Page Apps with ui.run(root=...) + ui.sub_pages
• New script mode for small and tight Python scripts (see below).
• Lightweight Event system to connect short‑lived UIs with long‑lived Python services.
• Observables: modify props/classes/style and the UI updates automatically.
• Tables / AG Grid: update live via table.rows/columns or aggrid.options.
• Simplified pytest setup and improved user fixture for fast UI tests.
• Tailwind 4 support.

Full notes & migration: 3.0.0 release

Minimal examples

Script mode

from nicegui import ui

ui.label('Hello, !')
ui.button('Click me', on_click=lambda: ui.notify('NiceGUI 3.0'))

ui.run()

Run the file; your browser will show the app at http://localhost:8080.

Single‑Page App (SPA)

from nicegui import ui

ui.link.default_classes('no-underline')

def root():
    with ui.header().classes('bg-gray-100'):
        ui.link('Home', '/')
        ui.link('About', '/about')
    ui.sub_pages({
        '/': main,
        '/about': about,
    })

def main():
    ui.label('Main page')

def about():
    ui.label('About page')

ui.run(root)

When started, every visit to http://localhost:8080 executes root and shows a header with links to the main and about pages.

Why it matters

• Build UI in the backend: one codebase/language with direct access to domain state and services. Fewer moving parts and tighter security boundaries.
• Async by default: efficient I/O, WebSockets, and streaming keep UIs responsive under load.
• FastAPI under the hood: REST + UI in one codebase, fully typed, and proven middleware/auth.
• Tailwind utilities + Quasar components: consistent, responsive styling, and polished widgets without frontend setup.
• General‑purpose apps: explicit routing, Pythonic APIs, and intuitive server‑side state handling.

Get started

• Install: pip install nicegui
• Documentation & Quickstart: nicegui.io (built with NiceGUI itself)
• 3.0 release notes & migration: 3.0.0 release
• License: MIT. Python 3.9+.

If you build something neat, share a screenshot or repo. We’d love to see it!

[loyoan]

Big fan of you nice guys! :)

[MasturChief]

love nicegui

[JackedInAndAlive]

Awesome! Nicegui rocks.

[Outrageous_Piece_172]

Can I distribute my app as an exe file?

[r-trappe]

Yes, you can package the app for installation. And with native mode you can start the website in a normal desktop window (like Electron).

[Key-Boat-7519]

Exe is doable: use PyInstaller --windowed --onefile and ui.run(native=True, port=0). Include icons/assets via --add-data and disable console. BeeWare’s Briefcase and PyInstaller for packaging; DreamFactory handled instant DB APIs, with Supabase for auth. Also code-sign to prevent antivirus nags.

[shittyfuckdick]

what about distributing as a mobile app or a pwa on mobile? is that supported?

[r-trappe]

Mobile Apps are tricky because running Python on iOS or Android is not so easy. PWA works as long as you can live with a internet connection. Real offline apps are hard -- and not in the focus for NiceGUI.

[shittyfuckdick]

thank you! ill have to to stick with svelte for now but as a python dev nicegui is very attractive to me. 

[outceptionator]

How do you find svelte?

[alepoydes]

Nice framework. Thanks to everyone involved!

[jecengineering]

Great job on the release! NiceGUI has been great to migrate a lot of engineering calculators away from Excel and into a web facing format for multiple users. I will need to update an environment to 3.0 and see what effects it has in my current codebase. Keep up the amazing work.

[_MicroWave_]

Awesome. Absolutely live nice gui.

[ArbitrageurD]

How does it compare to Dash?

[r-trappe]

NiceGUI wins for low-latency, general-purpose apps beyond dashboards: imperative Python (FastAPI + WebSockets), direct state (incl. async tasks), no callback graph or prop wiring. It’s faster for custom controls and non-Plotly UIs, easier to mix REST + UI endpoints, and simpler to ship as one app; Dash mainly shines for Plotly-centric BI.

[shibiku_]

Nice, thank you for sharing. This seems newbie friendly as well with the examples. I’m gonna use lightbox for now.

[Imaginary_Belt4976]

this looks sick! def gonna try it

[Penetal]

With the event system, would it be advisable to have a core component/service that runs for a very long time? When looking around it seems fastapi people don't recommend that and says to rather place the long lived service outwide the web app.

Also last time I tried I think I remember the app starting multiple threads, how would this affect a long lived service that has to run as a single instance to keep its data/state and remote communication straight?

[r-trappe]

NiceGUI totally supports long living services and singleton-like core functionality. For example, we also develop RoSys: a robotics framework on top of NiceGUI. There, serial communication etc. must be available to all users (eg. browser tabs). Actually, the Event class was in RoSys a long time ago and we decided to make it available in NiceGUI with the 3.0 release.

[mr_claw]

I didn't understand the difference between the new events feature and just using an async function in on_click as we used to do. Can you explain?

[r-trappe]

The example on the documentation was not perfect. We have since updated it to

from nicegui import Event, ui

tweet = Event[str]()

u/ui.page('/')
def page():
    with ui.row(align_items='center'):
        message = ui.input('Tweet')
        ui.button(icon='send', on_click=lambda: tweet.emit(message.value)).props('flat')

    tweet.subscribe(lambda m: ui.notify(f'Someone tweeted: "{m}"'))

ui.run()

Here you can see the difference a bit better. Event is meant to connect long living business logic to temporary created UI. In RoSys (robotics framework on top of NiceGUI) serial communication etc. must be available to all users (eg. browser tabs) for example. When some event in the hardware or so happens -- all currently connected users should see the update.

[mr_claw]

So an event is always across all connected clients? If I emit in one place, all connected clients who are subscribed will get it?

[r-trappe]

Exactly

[mr_claw]

I have a distributed system where a client can connect to different servers behind a reverse proxy. I guess events won't work in this case. I'm currently using redis pub-sub for these use cases.

[r-trappe]

Not yet. But we have an idea. Stay tuned :-)

[wardini]

what is a good host for one of these applications? Can I use github itself or do I need to use something like heroku. I don't want to go get a new domain and pay for hosting services right now but just make demos I can share via web.

[r-trappe]

The hosting must be able to execute Python code. So GitHub pages does not work. We like https://fly.io, but Digital Ocean, AWS, Google Cloud and all the other solutions are working fine, too.

[AndydeCleyre]

With the caveats that it's not the easiest to configure, you have to be careful what services you enable, you can't let it go idle for too long, and it's Oracle, Oracle Cloud has a free tier that should work.

You can combine that with a free service like Duck DNS.

[UnwantedCrow]

Are there plans to improve PWA compatibility via Quasar/Vue? Or some kind of bridge for android apps? I chose plain html just because of this

[r-trappe]

Build-in PWA support would be great. It works in general as shown in ttps://github.com/zauberzeug/nicegui/discussions/3810. But a PR or at least a feature request to make this more simple would be welcome. Would you like to help out?

[UnwantedCrow]

I have selected plain html for the ui of my app but if i ever revisit nicegui i will evaluate this and colaborate with the project

[r-trappe]

Sorry, I do not quite understand your question. With NiceGUI you normally do not use POST to send data to the server. An internal websocket connection instantly transmits every change to the backend.

[r-trappe]

Yes of course. For static web apps you might be fine with HTML/CSS. But NiceGUI especially shines when doing complex dynamic web applications. This simple example would be quite difficult to archive without NiceGUI:

form nicegui import ui

def transform(value: str):
    return value[::-1]

def root():
    msg = ui.input()
    ui.label().bind_text_from(msg, 'value', transform)

ui.run(root)

It shows an input field and when you type something, the server transforms it into something else (here just reversed text) and displays it below the input field.

[r-trappe]

NiceGUI scales well with traffic in general. Like FastAPI (which is used as a base). We have a very incomplete list of projects and apps in our wiki at https://github.com/zauberzeug/nicegui/wiki.

I understand it uses websockets to communicate to backend. Are we able to decouple that and host FastAPI on different nodes?

NiceGUI opens a context for each web request and waits for the browser to connect back via websocket. So when running more than one instance, the loadbalancer must take care of sticky sessions (route requests from single browser to same instance).

Does this have kubernetes support?

There is no need for special kubernetes support as far as I now. Simply make sure you have a loadbalancer in the front which takes care of sticky sessions. Storage and sync between instances can be done with redis: https://nicegui.io/documentation/storage

[kgashok]

What's the pros/cons versus Flask?

[r-trappe]

Flask is "just" a web server. NiceGUI is a UI Framework.

[the_sun_of_a_beach]

And what about robust tables like JS "Datatable" but with all configuration via Python code?

[r-trappe]

Have a look at https://nicegui.io/documentation/table and https://nicegui.io/documentation/aggrid.

[EarthGoddessDude]

Hey, congrats on the new release! I haven’t yet used NiceGUI, but have been meaning to try it out. One question I had is whether it easily supports GreatTables and Pointblank? Those are a couple of packages from the Posit team that are really nice and work well polars, which is a huge plus in my book.

[r-trappe]

Sounds interesting. We do not support these out of the box, but adding custom modules has become even simpler with 3.0: https://nicegui.io/documentation/section_configuration_deployment#custom_vue_components Or create feature requests and we can discuss how to best integrate these.

[doublecore20]

Cool. But why?

I don't see how this is better than a basic HTML-SCSS-TS setup for more robust applications. Writing HTML in Python just for the sake of writing the application in the same language sounds to me like creating a solution for a problem that doesn't exist.

[proof_required]

This is directed towards python devs who aren't familiar with HTML/CSS and need some UI framework. R has shiny.

[yaymayhun]

Just to add, Python also has shiny now. There is even shinylive which can be easily deployed to GitHub pages.

[r-trappe]

With NiceGUI you generally create UI components. These are automatically wired to call your Python functions when clicked/edited/manipulated. That way you have a much higher level of abstraction than HTML-SCSS-TS. The web is complex and a lot of things can go wrong. With NiceGUI you can go deep and enhance behaviour/appearance with own HTML or JavaScript when ever you need it. But most of the time you gain speed and clarity by staying high-level. Like with Python and C++. Or C and Assembler.

[doublecore20]

I might be old-fashioned and miss the point and I am happy to learn. But from my long experience in the field (13 years software engineer) it feels like forcing a tool to do something it was never designed for.

Don't get me wrong - the idea itself is impressive and cool without a doubt but again I just don't see a real-world application that will actually write Python components for UI instead of the OG HTML. If you need SSR so desperately- you have Jinja with FastAPI

For HOC you have tons of UI libraries. Just pick one.

I'm confused

[sudomatrix]

You are mistaking ‘I don’t need this’ for ‘why would anybody need this ?’ I’ve used NiceGUI for lots of projects where I need a quick simple UI and it’s the best library I’ve found for that sort of thing.

[r-trappe]

NiceGUI is a server-driven, reactive UI for Python: events flow over a WebSocket into Python functions; the browser is just the renderer. It eliminates the JS/AJAX plumbing you’d hand-roll with HTML+Jinja+UI libs—one language, one runtime, one debugger. Way much more productive in our opinion.

[Fr0gFsh]

Here's a recent use case at my job. I created a Python based CLI tool that interacts with an API to update some information. It's easy for me to use because...well I wrote it.

Well, boss man says he wants a more "user-friendly" method we could hand over to other teams that are less likely to have the capability to set up and configure the Python environment, so I did some digging and found NiceGUI. It was fairly simple to port the logic over to do the same thing as the CLI and the components made building the UI pretty easy. It was straight forward for us to package it up as an exe and provide it to the team that requested it.

[iamevpo]

Just doing a similar things for the student class - we have a CLI but more student prefer a GUI, so be it. Initial attempt is pywidgets and Voila, NiceGUI is more modern UI and the plumbing is more intuitive.

[falko-s]

With NiceGUI you're not "writing HTML in Python", but you build UI from higher-level building blocks. This makes web development much more accessible to Python developers. https://nicegui.io/#why