NiceGUI is an easy to use, Python-based UI framework, which renderes to the web browser.

Overview

NiceGUI

NiceGUI is an easy to use, Python-based UI framework, which renderes to the web browser. You can create buttons, dialogs, markdown, 3D scences, plots and much more.

It was designed to be used for micro web apps, dashboards, robotics projects, smart home solutions and similar use cases. It is also helpful for development, for example when tweaking/configuring a machine learning algorithm or tuning motor controllers.

Features

  • browser-based graphical user interface
  • shared state between multiple browser windows
  • implicit reload on code change
  • standard GUI elements like label, button, checkbox, switch, slider, input, file upload, ...
  • simple grouping with rows, columns, cards and dialogs
  • general-purpose HTML and markdown elements
  • powerful elements to plot graphs, render 3D scences and get steering events via virtual joysticks
  • built-in timer to refresh data in intervals (even every 10 ms)
  • straight-forward data binding to write even less code
  • notifications, dialogs and menus to provide state of the art user interaction

Installation

python3 -m pip install nicegui

Usage

Write your nice GUI in a file main.py:

from nicegui import ui

ui.label('Hello NiceGUI!')
ui.button('BUTTON', on_click=lambda: print('button was pressed', flush=True))

ui.run()

Launch it with:

python3 main.py

The GUI is now avaliable through http://localhost/ in your browser. Note: The script will automatically reload the page when you modify the code.

Configuration

You can call ui.run() with optional arguments for some high-level configuration:

  • host (default: '0.0.0.0')
  • port (default: 80)
  • title (default: 'NiceGUI')
  • favicon (default: 'favicon.ico')
  • reload: automatically reload the ui on file changes (default: True)
  • show: automatically open the ui in a browser tab (default: True)
  • uvicorn_logging_level: logging level for uvicorn server (default: 'warning')
  • interactive: used internally when run in interactive Python shell (default: False)

Docker

Use the multi-arch docker image for pain-free installation:

docker run --rm -p 8888:80 -v $(pwd)/my_script.py:/app/main.py -it zauberzeug/nicegui:latest

This will start the server at http://localhost:8888 with code from my_script.py within the current directory. Code modification triggers an automatic reload.

Why?

We like Streamlit but find it does too much magic when it comes to state handling. In search for an alernative nice library to write simple graphical user interfaces in Python we discovered justpy. While too "low-level HTML" for our daily usage it provides a great basis for "NiceGUI".

API

The API reference is hosted at https://nicegui.io and is implemented with NiceGUI itself. You should also have a look at examples.py for an extensive demonstration of what you can do with NiceGUI.

Comments
  • Allow creating a new page per client

    Allow creating a new page per client

    Discussed in https://github.com/zauberzeug/nicegui/discussions/61

    Originally posted by falkoschindler August 26, 2022 Idea: ui.page can not only be used as context, but also accepts a Callable argument for re-creating the page whenever a client connects. If the path if / or omitted, the page replaces the main page.

    This is related to https://github.com/zauberzeug/nicegui/issues/6, where @me21 posted a draft for a PrivatePage, which I haven't looked into, yet.

    After discussing several concepts, we tend to break with with ui.page contexts and move towards @ui.page decorators. This simplifies defining page factory functions and is similar to how Flask and FastAPI define routes. In the end, pages are more like routes rather than hierarchical UI elements. Thus defining them like routes makes a lot of sense.

    Also, in the flavor of Flask, FastAPI or JustPy, pages should be "private" by default, i.e. without shared state between different clients. A page should only be "shared" when an optional decorator argument is set True.

    This change has interesting consequences:

    1. Pages are no longer built using (possibly nested!) with expressions. Thus, the (internal) page_stack is obsolete. This removes one source of confusion.
    2. The pre-evaluation of ui.run is no longer needed. Since the main script primarily defines functions, we don't need to bother about re-evaluation in case of auto-reload being activated. This complies with the traditional way of running uvicorn and removes another confusing "feature" of NiceGUI.
    3. The decorated page functions can be async.

    To keep NiceGUI very accessible for new Python developers and to reduce boilerplate code for simple single-page applications, we plan to automatically create an index page if there is none. So the NiceGUI hello-world example should remain unchanged:

    from nicegui import ui
    
    ui.label('Hello, world!')
    
    ui.run()
    

    This will be equivalent to the following:

    from nicegui import ui
    
    @ui.page('/')
    def index_page():
        ui.label('Hello, world!')
    
    ui.run()
    

    TODOs

    • [x] get rid of page_stack
    • [x] remove context enter/exit from pages class
    • [x] use a default main page for ui elements created "globally"
    • [x] find better place to create default main page (and maybe remove code duplication with ui.page factory)
    • [x] find way to set head and body html for each page
    • [x] allow configuring pages through parameters for ui.page
    • [x] find way to apply default configurations passed in ui.run to default main page (which already has been created)
    • [x] reloading implicitly created index page causes "No page to load" and other server errors
    • [x] show 404 page for routes which do not exist (or at least avoid 500 error)
    • [x] allow on_connect handler with sessions for non-shared pages (see sessions demo on main.py)
    • [x] allow passing page builder functions to ui.link and ui.open
    • [x] test/fix await/run java script per page
    • [x] remove pre-evaluation of ui.run
    • [x] how to exclude costly imports without pre-evaluation of ui.run?
    • [x] let JustPy serve Highcharts and Aggrid on demand
    • [x] create routes for additional libraries on demand
    • [x] introduce environment variable "MATPLOTLIB" to avoid its costly import (don't import if it's "false")
    • [x] how to dynamically add a first custom element? routes to js files are added on startup.
    • [x] how to dynamically add a first chart or table? js files are excluded from the template.
    • [x] update documentation
    • [x] fix memory leak for private pages -> this is a starlette issue
    • [x] what to do with page routes which are created after startup?
    • [x] rethink the strategy of page-reload after adding js dependencies
    • [x] NiceGUI serves wrong template folder
    • [x] dependencies are not found when running with reload=False
    • [x] do we trigger too many reloads after adding dependencies? --> we do not reload anymore
    • [x] how to add dependencies on private pages that loose their state when reloading? --> make excludes explicit again
    • [x] handle new UI elements in an event callback without container (see Color Theming and JavaScript examples)
    • [x] fix wrong title and favicon
    enhancement 
    opened by falkoschindler 36
  • A question about component update moment in the page lifecycle

    A question about component update moment in the page lifecycle

    I have a page with on_connect handler. In this handler, I start some tasks with asyncio.create_task:

    cls.messages_tasks = [
        asyncio.create_task(cls.handle_di_messages(cls.mqtt_client)),
        asyncio.create_task(cls.handle_ai_messages(cls.mqtt_client)),
        asyncio.create_task(cls.handle_tc_messages(cls.mqtt_client)),
        asyncio.create_task(cls.refresh_aout_values(cls.mqtt_client)),
    ]
    

    Several tasks are ongoing and the last of them is single-shot. They all are async as they request and receive values from MQTT broker. What I experience is that I receive the message from MQTT broker in the last task, but the corresponding UI elements are sometimes not updated.

    I suspect this is due to the asynchronous nature of the task:

    • if the response comes quicker than the page is rendered, it's ok
    • if the response comes after the websocket connection is established, it's ok
    • but if the response comes between the page has been loaded, but before the websocket connection is up, then the component update is lost.

    Please share your thoughts on the matter - am I right? Is it possible to check it somehow?

    I currently fixed it by awaiting the single-shot task instead of putting it to the common list of running tasks. Is this fix good or it's a hackish way to work around the problem?

    opened by me21 12
  • How to modularize and customise pages?

    How to modularize and customise pages?

    The recent changes to page creation with the release of 0.9.0 renders the example discussed in #50 unfeasible:

    class MainPage(ui.page):
        def __init__(self):
            super().__init__('/', dark=True)
            with self:
                ui.label('Hi!')
    
    MainPage()
    

    I have tried adapting the code (using PageBuilder) in the simple example, but failed to get it running as before.

    from nicegui import ui
    from nicegui.globals import page_builders
    from nicegui.page import Page
    from nicegui.page_builder import PageBuilder
    
    
    class MainPage(Page):
        def __init__(self):
            super().__init__(dark=True)
    
            ui.label('Hi!')
    
    
    async def page_builder() -> Page:
        return MainPage()
    
    
    def index_page():
        builder = PageBuilder(shared=False, function=page_builder)
        page_builders.setdefault('/', builder)
    
    
    index_page()
    
    ui.run()
    

    results in

        raise RuntimeError('cannot find parent view, view stack is empty')
    RuntimeError: cannot find parent view, view stack is empty
    

    I have just recently migrated a great chunks of previously justpy code to the above inheritance approach including additional element/group classes (such as header, layout, pagecontainer, ...) and am now seeking ways to make it work, again.

    @falkoschindler: could you please guide me here, again? Thanks!

    This issue is possibly related to #85.

    opened by hroemer 11
  • Provide ui.linear_progress and ui.circular_progress elements

    Provide ui.linear_progress and ui.circular_progress elements

    As written in https://github.com/zauberzeug/nicegui/pull/101#issuecomment-1268344725 we would like to see the Quasar progress types as NiceGUI elements. This should be straight forward as @hroemer showed in pull request #101.

    enhancement 
    opened by rodja 10
  • Remove a specific component from the container

    Remove a specific component from the container

    There is a method called clear which removes the children of a container. But is there a way to remove the specific child component? In addition, this method removes JustPy objects, but does it remove corresponding NiceGUI wrappers?

    enhancement 
    opened by me21 9
  • Is it possible to not share the state between multiple browser windows?

    Is it possible to not share the state between multiple browser windows?

    In the button example,

    from nicegui import ui
    
    def button_increment():
        global button_count
        button_count += 1
        button_result.set_text(f'pressed: {button_count}')
    
    button_count = 0
    ui.button('Button', on_click=button_increment)
    button_result = ui.label('pressed: 0')
    
    ui.run()
    

    How can I have separate button counts for different multiple browser windows?

    enhancement 
    opened by qiuwei 9
  • Quasar props can not contain spaces

    Quasar props can not contain spaces

    Discussed in https://github.com/zauberzeug/nicegui/discussions/97

    Originally posted by gbrandt September 27, 2022 I am using ui.input() and it allows a prop called 'error-message'.

    self.input_add_user_email = ui.input(label='Email', on_change=self.on_change_email).props('error-message=Invalid Email').style('width: 300px')

    However only the text Invalid is shown on the error when I do this: self.button_add_user.props('disable=false')

    Is there anyway to get a string with spaces into the error message?

    This is indeed a limitation of our current simple property parsing: https://github.com/zauberzeug/nicegui/blob/f417d7a64b43f00e52dd843445a8a9d8b9b366b9/nicegui/elements/element.py#L93

    Task List:

    • [x] write integration test (skip execution until issue is fixed)
    • [x] unit-test str_to_dict function which is used by element.props
    • [x] allow multi-word values in props
    • [x] enable integration test if everything is running
    • [x] review
    enhancement 
    opened by rodja 8
  • Some UI elements dont work

    Some UI elements dont work

    I am new to nicegui. I tried the examples listed in the API reference, but some elements such as table, toggle, etc., do not work for me. The code I used was a copy-paste from the nicegui site:

    from nicegui import ui
    slider = ui.slider(min=0, max=1, step=0.01, value=0.5)
    ui.linear_progress().bind_value_from(slider, 'value')
    ui.run()
    

    The error message I get is: AttributeError: 'Ui' object has no attribute 'linear_progress'


    For toggle (and some other elements), I can't get the value of the toggle into a variable. For example:

    toggle1 = ui.toggle([1, 2, 3], value=1)
    print(f"Value of toggle1 = {toggle1}")
    

    does not print out. If I use a callback function, I can, at best print out / notify the value of the variable with e.value, but can't assign it to a variable in the main function, even though I use something like return e.value from the callback.

    Is there something I'm doing wrong; is there some comprehensive nicegui document I can refer to for help?

    βœ“ 
    opened by shakamoushie 7
  • Grid component can load data from Excel at page creation time but not after button is clicked

    Grid component can load data from Excel at page creation time but not after button is clicked

    I have the following code:

            df = pandas.read_excel(data)  # read Excel containing datetime values
            table = ui.table({})
            table.view.load_pandas_frame(df)
    

    It works and the data is displayed.

    But if I comment the last line and run load_pandas_frame in, say, button click handler function, nothing is displayed, and even table.update() doesn't help. Digging into JustPy sources, it seems that an error is thrown on update saying datetime objects are not JSON serializable. It is silently swallowed by NiceGUI, only "Problem with websocket update, ignoring" message is printed. But why does it work at the page creation time?..

    wontfix 
    opened by me21 7
  • Graceful shutdown

    Graceful shutdown

    Is there any way of gracefully shutting down the server after use? I am using it to have a configuration page for a larger project and once the configuration is completed the main part of the project takes over and no more configuration is needed. I would like to kill everything UI related at that point.

    enhancement 
    opened by Avriox 7
  • binding_refresh_interval not having any impact

    binding_refresh_interval not having any impact

    Running on a Raspberry Pi, NiceGUI is fairly CPU intensive (although still usable). I tried changing the binding_refresh_interval value, via a ui.run() parameter, but it doesn't seem to make any difference on CPU usage.

    opened by bapowell 7
  • fix favicon routes for pages that are created during or after startup

    fix favicon routes for pages that are created during or after startup

    Until now favicons are collected in a global dictionary. During startup a function create_favicon_routes() is called to create routes for all favicons in this dictionary. This is because we need wait until ui.run(..., favicon=...) has been called because it might define a default favicon.

    But this does not work for pages that are also created during startup (but a bit later) or even dynamically caused by a user event.

    from nicegui import ui
    
    ui.label('The favicon is correct on the index page.')
    
    def startup():
        @ui.page('/sub')
        def page():
            ui.label('There is no favicon route for this page because it was only created during startup.')
    
    ui.on_startup(startup)
    
    ui.run(favicon='favicon.ico')
    

    This PR proposes to create routes directly when initializing pages. Even though we need to wait for the favicon argument in ui.run, we can already create routes and let the callback access the fallback favicon when called. This simplifies things (no need for the global dictionary anymore) and works more robustly, since pages can be created at any time and favicons will be routed.

    bug 
    opened by falkoschindler 0
  • Authentication example does not redirect to '/' after logging in

    Authentication example does not redirect to '/' after logging in

    ui.open() doesn't seem to work when used in a function that gets called while loading a page or clicking a button. Code used is an exact copy of the authentication example from:

    https://github.com/zauberzeug/nicegui/blob/main/examples/authentication/main.py

    The function that get's called after login button is pressed:

    def try_login(session_id: str, username: str, password: str) -> None:
        if (username, password) in users:
            session_info[session_id] = {'username': username, 'authenticated': True}
        ui.open('/')
    
    question 
    opened by Mantanium 2
  • uploading large files for data analysis

    uploading large files for data analysis

    Hi,

    would it possible to open large files >10Mb for data analysis? The upload function seems not to work for this. In pure python one would open a file and iterate through it line by line (loading only one line at a time to RAM).

    with open("log.txt") as infile:
        for line in infile:
            print(line)
    

    i want to open a microcontroller serial trace and visualize certain events on a timeline as a plot (timeline or matplotlib)

    opened by Knochi 0
  • Fix object duplication in ui.scene when using without page decorator

    Fix object duplication in ui.scene when using without page decorator

    If the following code is run and accessed from multiple tabs the sphere is duplicated.

    from nicegui import ui
    
    with ui.scene() as scene:
        sphere = scene.sphere().move(0, -4, 0)
        ui.timer(0.1, lambda: sphere.move(0, sphere.y + 0.5, 0))
    
    ui.run()
    

    This is caused by the connect event send by each tab. It was meant to initialize the scene. But this does not work with our index_client. This special client is used when elements are not enclosed in an @ui.page decorator. So the tab which connects first will receives the init-commands also from the second tab.

    • [x] create pytest reproduction
    • [x] ensure connect event from ui.scene is only send to the client which connects
    • [ ] code review
    • [ ] extend solution to also work for other "connect" events (like we have with ui.interactive_image).
    • [ ] revisit reconnect behaviour (it looks like there may be send multiple connect commands from a single tab)
    bug 
    opened by rodja 0
  • on-demand loading of dependencies

    on-demand loading of dependencies

    In https://github.com/zauberzeug/nicegui/pull/211 we started to load Highcharts dependencies on demand. In this issue we will discuss and implement a more general solution.

    • [x] rename vue.py into dependencies.py
    • [x] add a flag optional to the Dependency class to avoid code duplication in register_component()
    • [x] move the URL generation for extras from chart.py to dependencies.py
    • [ ] How to generalize this approach to for other elements?
    enhancement 
    opened by rodja 1
  • ValueError: Too many packets in payload

    ValueError: Too many packets in payload

    The connection can break down with "ValueError: Too many packets in payload" if lots of data need to be transferred. This happens due to a packets limit from engineio. It can be fixed by increasing the limit (see see https://github.com/miguelgrinberg/python-engineio/issues/142) before importing nicegui:

    from engineio.payload import Payload
    Payload.max_decode_packets = 500
    
    from nicegui import ui
    
    ...
    

    We should increase this limit directly in NiceGUI so users do not run into the issue in normal scenarios.

    enhancement 
    opened by rodja 0
Releases(v1.0.9)
  • v1.0.9(Dec 31, 2022)

    • Fixing lost state changes with ui.timer (#207, #206)
    • Caching markdown to speed up repeated requests (#205)
    • Allow to load Highcharts "extra" libraries like solid-gauge (#210, #211)
    • Fixing dynamically adding/removing chart series (#208)
    • Adding svg clock example
    Source code(tar.gz)
    Source code(zip)
  • v1.0.8(Dec 24, 2022)

  • v1.0.7(Dec 21, 2022)

  • v1.0.6(Dec 20, 2022)

  • v1.0.5(Dec 19, 2022)

  • v1.0.4(Dec 17, 2022)

  • v1.0.3(Dec 16, 2022)

    • remove deprecated lastModifiedDate in ui.upload #193
    • introduced nicgui.globals.socket_io_js_extra_headers to provide extra headers for the javascript socket.io connection
    • using the above variable to enable sticky connections for our fly.io deployment
    Source code(tar.gz)
    Source code(zip)
  • v1.0.2(Dec 15, 2022)

  • v1.0.1(Dec 15, 2022)

  • v1.0.0(Dec 15, 2022)

    Changes

    • removed JustPy dependency (thank you for the great ride!)
    • upgrade to Vue 3, Quasar 2 as well as more recent Tailwind and Google Material Icons
    • now the core is based on FastAPI and supports all of its features πŸŽ‰
    • new branding of https://nicegui.io (logo, website, primary color #5898d4, favicon, …)

    Solved issues

    • container does not clear #191
    • NiceGUI link in startup message is incorrect with reload=False #157
    • remove a specific component from the container #145
    • table disappears when triggering sort via ui.select #127
    • 404-page should return error code 404 #106
    • ui.tree still causes page updates #69
    • upgrade Quasar #65
    • upgrade to more recent Google Material Icons #63

    We have taken much care to keep most APIs compatible. But upgrading from version 0.9 may still require some small adaptations. Reach out if you have been using the underlying JustPy API a lot and need help to find alternative approaches with 1.0. The old documentation of version 0.9 is still available at https://0.9.nicegui.io/ if you can not upgrade immediately.

    Thank you, JustPy, for providing the core engine for NiceGUI until now. We are super grateful for the bootstrapping. Without JustPy, NiceGUI would never have been possible. Now, with 1.0 we moved to our own core which is based on FastAPI. We are excited about this step because it enables NiceGUI to evolve even quicker.

    Source code(tar.gz)
    Source code(zip)
  • v0.9.26(Dec 14, 2022)

  • v0.9.25(Nov 8, 2022)

  • v0.9.24(Nov 7, 2022)

  • v0.9.23(Nov 7, 2022)

  • v0.9.22(Nov 5, 2022)

    • new elements (special thanks to @hroemer for contribution #107):
      • ui.linear_progress
      • ui.circular_progress
    • allow content binding for ui.markdown and ui.html
    • improved docker image
    • introduction of remove(element) method on groups (eg. column, row, card, ...) #145
    Source code(tar.gz)
    Source code(zip)
  • v0.9.21(Oct 28, 2022)

    • auto-update page before each await in a generator-style page (see #142 and #131)
    • use Python 3.11 in tests and for the public docker image
    • update ui.plot when leaving its context
    • improved consistency of ui.update and element.update
    • new example: infinite scrolling
    Source code(tar.gz)
    Source code(zip)
  • v0.9.20(Oct 25, 2022)

    • allowing sophisticated page structures through Quasar Layout (see docs and #128)
      • define ui.header, ui.footer, ui.left_drawer and ui.right_drawer
      • make elements "sticky" on a page with ui.page_sticky
    • enabled accessing websocket instance in generator-style pages (see #130)
    • fixed missing UI update when setting SVG content on interactive image (see #137)
    • improved favicon API (see #125)
    • improved documentation
    • other bugfixes
    Source code(tar.gz)
    Source code(zip)
  • v0.9.19(Oct 19, 2022)

  • v0.9.18(Oct 15, 2022)

    • allow declaring path parameters for ui.page like with ui.get (#105)
    • improved javascript execution (#112)
    • exceptions during page creation now present a "nice" 500 page (#119)
    • provided more complex examples (#90)
    • fixed infinite loops created by timers on individual pages for each connection (#118)
    Source code(tar.gz)
    Source code(zip)
  • v0.9.17(Oct 12, 2022)

  • v0.9.16(Oct 12, 2022)

  • v0.9.15(Oct 12, 2022)

  • v0.9.14(Oct 10, 2022)

    • introduce the yield keyword as an alternative way for defining code that should be executed on-page-ready
    • reduce CPU usage of line plot demo
    Source code(tar.gz)
    Source code(zip)
  • v0.9.13(Oct 10, 2022)

    Several optimizations to keep the online docs at https://nicegui.io available. Thanks for all the visits to our page. It really points out opportunities to improve the performance.

    Source code(tar.gz)
    Source code(zip)
  • v0.9.12(Oct 9, 2022)

    • create gaps via tailwind class instead of CSS style (see #104)
    • raising exception for javascript execution if page is not ready (see #112)
    • more examples
    • improved documentation
    Source code(tar.gz)
    Source code(zip)
  • v0.9.11(Oct 5, 2022)

  • v0.9.10(Oct 5, 2022)

    • improve style and props parsing to support multi-word props; now you can write .props('name="some multi-word value"') (see #98)
    • testing joystick behaviour and styling with integration tests
    • fixed auto-screenshot in integration tests
    Source code(tar.gz)
    Source code(zip)
  • v0.9.9(Oct 4, 2022)

  • v0.9.8(Oct 1, 2022)

  • v0.9.7(Sep 30, 2022)

Owner
Zauberzeug GmbH
Use magic. With intelligent software and robotics.
Zauberzeug GmbH
A keyboard-driven, vim-like browser based on PyQt5.

qutebrowser is a keyboard-focused browser with a minimal GUI. It’s based on Python and PyQt5 and free software, licensed under the GPL.

qutebrowser 8.4k Jan 1, 2023
Basic browser based on PyQt5

goneDev-browser "basic browser based on PyQt5" This application is primarily built on macOS with more adaptibility for MacOS than Windows. v1.0 will s

Harsh ADV) 1 Jan 19, 2022
EZ Presence - A GUI-Python app which makes it easy to set a custom Discord Rich Presence. (BETA)

EZ Presence EZ Presence is a GUI-Python app which makes it easy to set any custom Discord Rich Presence. Using the App How to Run Since the app is in

notsniped 2 Mar 1, 2022
An qt asset browser for applications like houdini/nuke/maya/blender

AssetBrowser A qt asset browser for applications like houdini/nuke/maya/blender Currently in development Note: Only houdini plugin available during de

Jonas Sorgenfrei 6 Aug 5, 2022
A simple browser for familiarity to PyQt :)

Erown_Browser a simple browser for familiarity to PyQt :) for start work with this install requirements by pip install -r requirements or you can use

Ehsan Amirahmadi 9 May 18, 2022
Textual is a TUI (Text User Interface) framework for Python inspired by modern web development.

Textual is a TUI (Text User Interface) framework for Python inspired by modern web development.

Will McGugan 17.1k Jan 8, 2023
A tf publisher gui tool for ROS, which publish /tf_static message. The software is based on PyQt5.

tf_publisher_gui for ROS Introduction How to use cd catkin_ws/src git clone https://github.com/yinwu33/tf_publisher_gui.git cd catkin_ws catkin_make s

yinwu33 7 Dec 28, 2022
Weather-API-GUI-Tkinter - A weather tool made using tkinter which works by fetching query city weather using an API

Weather-API-GUI-Tkinter ☁️ ❄️ version- 1️⃣ . 0️⃣ . 0️⃣ This repo contains a weat

SasiVatsal 4 Jul 8, 2022
Write desktop and web apps in pure Python

Flexx Want to stay up-to-date about (changes to) Flexx? Subscribe to the NEWS issue. Introduction Flexx is a pure Python toolkit for creating graphica

flexxui 3.1k Dec 29, 2022
πŸ† A ranked list of awesome python libraries for web development. Updated weekly.

Best-of Web Development with Python ?? A ranked list of awesome python libraries for web development. Updated weekly. This curated list contains 540 a

Machine Learning Tooling 1.8k Jan 3, 2023
Write desktop and web apps in pure Python

Flexx Want to stay up-to-date about (changes to) Flexx? Subscribe to the NEWS issue. Introduction Flexx is a pure Python toolkit for creating graphica

flexxui 3.1k Jan 8, 2023
Python Web Version 3.0 Using PyQty module

Python-Web-Version-3.0 Python Web Version 3.0 Using PyQty module you have to install pyinstaller module then install PyQt5 module and install PyQtwebE

JehanKandy 9 Jul 13, 2022
Use NixOS Without Coding

(Work in Progress) Nix-Gui Make NixOS usable for non-technical users through a settings / package management GUI. Motives The declarative nature of Ni

null 548 Dec 30, 2022
Use CSS styling in Tkinter apps

cssTk To-Do Support Upto CSS 4.15 Set Up Docs Features * Corner Radius Gradient BG Blur Animations Usage Scenarios Allows easy import of GTK 3 and GTK

RUG 5 Oct 18, 2022
A quick GUI script to pseudo-anonymize patient videos for use in the GRK

grk_patient_sorter A quick GUI script to pseudo-anonymize patient videos for use in the GRK. Source directory β€” the highest level folder that will be

Peter Somers 1 Dec 9, 2021
Windows & Linux GUI application to use a Satodime (satodime.io)

Satodime-Tool Licence: LGPL v3 Author: Toporin Language: Python (>= 3.6) Homepage: https://github.com/Toporin/Satodime-Tool Introduction What is Satod

null 4 Dec 16, 2022
Use any of the 1k+ free FontAwesome icons in your tkinter application.

TkFontAwesome A library that enables you to use FontAwesome icons in your tkinter application. You may use any of the 1k+ free FontAwesome 5.0 icons.

Israel Dryer 33 Dec 20, 2022
These are some useful tkinter utilities that i like to personally use.

ntkutils nefs tkinter utilities These are some useful tkinter utilities that i like to personally use. I upload this here because someone might wants

nef 7 Dec 6, 2022