Research how to render / make GUI in python

[Teagueanator]

Figure out what tools we need to render our Python simulation in a GUI/web browser. Figure out the upsides and downsides for this implementation. Please play close attention to skill curve / required onboard time to learn this tool.

[danielraffo1]

Goal

Put our Python simulation behind a simple GUI that can run locally and (ideally) in a browser with minimal friction for teammates.

Options I looked at

1) Streamlit

• What it is: Python-first web UI. Write normal Python, sprinkle st.button, st.slider, etc.

• Pros: Fast to prototype; zero HTML/JS; good widgets; easy local sharing; built-in state; decent performance for many simulations.

• Cons: Single-page app vibe; custom layouts can get tricky; not great for complex multi-window flows.

• Use when: We want something working quickly with nice controls and plots, mostly single-page.

2) Plotly Dash

• What it is: Python app framework for interactive dashboards using Plotly components.

• Pros: More control over layout/routing; strong graphing; production-grade patterns; works like a lightweight Flask app.

• Cons: More boilerplate than Streamlit; callbacks can get verbose; steeper ramp than Streamlit.

• Use when: We need a real web app structure, routes, or more complex interactions.

3) Panel (HoloViz)

• What it is: General-purpose dashboarding that plays nicely with Bokeh, Matplotlib, Plotly, etc.

• Pros: Flexible layouts; works in notebooks or as a server; great for scientific viz; supports reactive params.

• Cons: Smaller ecosystem; docs are good but less mainstream.

• Use when: We want scientific plotting flexibility and don’t mind learning its layout/model.

4) Gradio

• What it is: Super quick UIs around functions, popular in ML demos.

• Pros: Easiest hello-world; file/image/audio widgets; share links easily.

• Cons: Geared toward “input → function → output” flows; less control for general GUIs.

• Use when: We need a demo UI around a compute function, not a full app shell.

5) PyQt6 / PySide6 (desktop)

• What it is: Native desktop GUI toolkit (Qt) for Windows/Mac/Linux.

• Pros: Real desktop feel; tons of widgets; mature; high performance.

• Cons: Heavier to learn; packaging & distribution take work; not browser-based.

• Use when: We want a native desktop app with multiple windows/menus and no dependency on a browser.

6) Kivy / BeeWare (desktop/mobile)

• What it is: Cross-platform/mobile UI stacks in Python.

• Pros: Can target mobile; modern UIs.

• Cons: Larger commitment; theming/UX polish takes time; not ideal if our audience is just using laptops.

• Use when: Mobile is a must.

7) FastAPI (backend) + React/Vue/Svelte (frontend)

• What it is: Real web app split: Python serves APIs; JS handles UI.

• Pros: Maximum control, scale, polish; proper SPA features; websockets for live updates.

• Cons: Two stacks to maintain; longer build time; more infra.

• Use when: We’re committing to a product-level web app with rich UX and team ownership.

8) PyScript / Pyodide (Python in the browser via WebAssembly)

• What it is: Run Python in the browser, no server compute.

• Pros: Zero server; fully client-side.

• Cons: Startup weight; library compatibility landmines; still maturing.

• Use when: The “run entirely in browser” constraint outweighs the rough edges.

9) Voilà (turn notebook → web app)

• What it is: Serves a Jupyter notebook as an app (hides code, shows widgets).

• Pros: Very quick from an existing notebook; ipywidgets work well.

• Cons: App structure tied to a notebook; not as clean for long-term maintenance.

• Use when: We already have a notebook prototype we want to share behind a clean UI.

Performance notes (for a simulation)

• Keep the simulation loop off the main UI thread. For web stacks, use background threads/processes or async tasks. For desktop Qt, use QThread/signals.

• For live plots, prefer incremental updates (streaming) instead of redrawing from scratch.

• If runs are long, add a progress bar and a “stop” control.

• Consider a “headless engine” module (pure Python) that the UI calls, so we can swap front-ends later without touching the core logic.

Deployment / sharing

• Streamlit/Dash/Panel/Gradio: run locally with one command; can containerize for sharing; easy to host on Render/Fly/etc.

• Qt/Kivy: bundle with PyInstaller for each OS.

• FastAPI+JS: standard Docker deploy; CDN for assets.

• PyScript/Pyodide: static hosting (no server compute), but watch bundle size.

Shortlist + recommendation

If the priority is speed to something useful and our app is mostly sliders/buttons/plots: Streamlit.

If we need more structure (multiple pages, tighter control) but want to stay Python-only: Dash.

If we decide on a native desktop app: PyQt6/PySide6.

My suggestion: Start with Streamlit as the first spike. It’ll let us validate the UX and performance quickly, and we can keep the simulation logic clean so moving to Dash or a full FastAPI+React stack later is painless if we outgrow it.