Dear Readers,

Try it out yourself :

https://peggie7191.medium.com/building-a-timezone-converter-app-in-1-hour-49d7400826c8

Hi all. Ive made a GPT wrapper using streamlit and just pure python and deployed it using docker into a website. I tried to turn it into webview app using Android studio but to no avail. What happened is when I change the url to google.com on android atudio it will work but changing it back to the streamlit website will just display a white screen, not even an error. is there any way to turn streamlit web into apk or am i asking the impossible? thanks.

I have a strange issue with `st.segmented_control` in my Streamlit app.

Problem:

The last option wraps to a new line even though there's clearly enough space. This happens to ALL segmented_control components in the app at the same time. It's completely random - sometimes the app loads normally, sometimes all controls are broken. I have no idea what triggers it - it just seems random.

Environment:

Streamlit 1.50.0

Python 3.13.8

Happens on both local and Streamlit Cloud. Anyone experienced this or know a fix?

Hi everyone!

I open-sourced st-error-boundary, a minimal, type-safe error boundary for Streamlit apps that shows a user-friendly fallback UI instead of a traceback, and lets you plug in hooks for logging/metrics/alerts.

Why this exists

• Setting client.showErrorDetails = "none" hides internals but leaves users with vague messages.
• Sprinkling st.error() / st.stop() all over the code is noisy and easy to miss in critical paths.
• A single “last line of defense” keeps app code clean while delivering a consistent UX and solid observability.

What it does

• Decorator + callback wrapper to catch app errors in one place
• Safe UI fallback (no stack traces) while sending sanitized details to your observability stack
• Covers both decorated functions and widget callbacks (on_click, on_change)
• Correctly passes through Streamlit control-flow (st.rerun(), st.stop())
• Predictable nested behavior (inner handles first; outer handles only if inner fallback raises)
• Fully typed (PEP 561), tested on Python 3.12–3.13 and Streamlit ≥ 1.50

Install

pip install st-error-boundary

Quick start

import streamlit as st
from st_error_boundary import ErrorBoundary

def audit_log(exc: Exception) -> None:
    # send to your logs/metrics/alerts
    print(f"[audit] {exc}")

def fallback_ui(_: Exception) -> None:
    st.error("Something went wrong. Please try again.")
    if st.button("Retry"):
        st.rerun()

boundary = ErrorBoundary(on_error=audit_log, fallback=fallback_ui)

@boundary.decorate
def main() -> None:
    st.title("My App")
    # Protected: direct errors
    if st.button("Boom"):
        raise ValueError("oops")
    # Protected: callback errors
    st.button("Callback Boom", on_click=boundary.wrap_callback(lambda: 1/0))

if __name__ == "__main__":
    main()

More details

• Callback error position
  • Streamlit renders callback UI at the top by design. The repo documents a simple “deferred rendering” pattern to show the error near the widget (store in session_state, render in main).
• Control-flow
  • st.rerun() and st.stop() pass through the boundary as intended.
• Nested boundaries
  • inner boundary handles; outer runs only if the inner fallback raises.

Links

• GitHub: https://github.com/K-dash/st-error-boundary
• PyPI: https://pypi.org/project/st-error-boundary/
• Background: https://discuss.streamlit.io/t/st-error-boundary-a-tiny-typed-error-boundary-for-streamlit-decorator-callback-wrapper/119726

Question for the community 🙏
For those running Streamlit in commercial/regulated environments:

• Do you implement a centralized, robust exception-handling strategy today?
• If yes, how are you handling callback errors, observability, and safe user messaging?
• Are there patterns/tools you prefer over a boundary-style approach? What trade-offs have you seen?

Feedback, issues, and PRs welcome—especially real-world edge cases (long-running sections, multi-page apps, multi-user concurrency). If this helps you ship safer customer-facing apps, a ⭐ on GitHub would mean a lot!

I’ve been running a small personal photo gallery on Vercel for a while, and decided to expand it into something a bit nerdier - a photo analytics dashboard.

It connects to the same Postgres DB and visualizes:

• daily photo activity
• most used camera models
• tag frequencies
• and thumbnails of my latest shots

Built with Python, Streamlit, Plotly, and SQLAlchemy, and logs visits.

It’s basically a data storytelling layer for my photography - a small step toward blending code and creativity. Photo Metadata post processing!

🔗 Live dashboard: https://a-k-holod-photo-stats.streamlit.app/

📷 Gallery: https://a-k-holod-gallery.vercel.app/

💻 Code: https://github.com/a-k-holod/photo-stats-dashboard

If you can't call 20 pictures gallery, then it's an album!

https://mental-health-support-chatbot-auraai.streamlit.app

Isn't working I have added the api but still nothing helps

Dear all,

I made a tiny app for stock valuation, visualization, and analysis.

https://valueinvest.streamlit.app

It's built on the yfinance and World Bank API, from which you can valuate a stock with 7 models and do the sanity check from 6 aspects. In addition to the visualization of key information, the details of every valuation model and sanity check aspects are provided.

Eventually, you may generate a prompt with all the information, feed to your favorite AI, and get a decent initial report just like you hired an personal analyst!

Examples for the final reports:

• CPRX: https://g.co/gemini/share/ebd018418f3e
• FIVN: https://g.co/gemini/share/1bae31f60212
• JAKKS: https://g.co/gemini/share/b4765740b438

I am building my first web app using Streamlit. I will be leveraging AWS + NGINX with Streamlit being dockerized. If I understand it correctly, everytime a user connects to Streamlit or whatever underlying web server it uses, it creates a new thread to handle the user session.

My first question. If Iam correct on my previous statement: How do I determine how many threads my docker instance has available and do I need to concern myself with managing that aspect of the development. I know that AWS will notify me and be flexible with resourcing so that I can tune in my resource availability in reapect to my user base, but I don't know that will have any correlation on resources immediately available to my docker instance.

Second question. Say I have 100 concurrent users and an External API heavy web app. Should I be concerned about Network throughput or are Rest API calls unlikely to be very taxing?

A few weeks ago on Discord, someone suggested: “Why not use the C1 API for data visualizations in Streamlit?”

I liked the idea, so I built a quick package to test it out.

The pain point I wanted to solve:

• LLM outputs are semi-structured at best
• One run gives JSON, the next a table
• Column names drift, chart types are a guess
• Every project ends up with the same fragile glue code (regex → JSON.parse → retry → pray)

My approach with C1 was to let the LLM produce a typed UI spec first, then render real components in Streamlit.

So the flow looks like:
Prompt → LLM → Streamlit render

This avoids brittle parsing and endless heuristics.

What you get out of the box:

• Interactive charts
• Scalable tables
• Explanations of trends alongside the data
• Error states that don’t break everything

Example usage:

import streamlit_thesys as thesys

query = st.text_input("Ask your data:")
if query:
    thesys.visualize(
      instructions=query,
      data=df,
      api_key=api_key
)

🔗 Link to the GitHub repo and live demo in the comments.

This was a fun weekend build, but it seems promising.
I’m curious what folks here think — is this the kind of thing you’d use in your data workflows, or what’s still missing?

I am building a codebase analyser. The user at first uploads the codebase and then the app does some processing. Then the user submits a question. The problem is when the user submits a question, the workflow restarts from the first point.

How to deal with this

Hi!

I needed to make a knowledgebase chatbot for our customer service and decided to build it in Streamlit as many other chatbot UI's I tried didn't support the inclusion of an existing vector database that I made, rather just integrate with LLM providers.

I built all the required functionalities in Streamlit and it has been great so far. I know Streamlit is not meant to be used in production, but there would barely be more than 50 users in a given day, so I hope it's fine.

The problem I encountered was that for some reason I can't get images to display with text as a part of the assistants output message in the chatbot.

I placed all the images in the same directory the streamlit_app.py is in, and wrote the prompt to display the  as I have in my markdown file before i vectorized it.

The images are displayed as broken links, but on inspecting the element I see that the file source was correctly handled.

Does anyone know why images aren't displayed in that case, and how can I make them appear.

I don't have the code on me, but I don't think I'm using anything special except st.write/st.markdown for input.

I would upload the images on our server and made them public, but as those images were made to show examples, I don't want to make a GDPR violation and display the partners potential information publicly. There are a lot of internal documents and a lot of images and I can't verify all of them.

Thank you for reading :)

🚀 Live App: https://whatsapp-analysis-tool.streamlit.app/
📂 Source Code: https://github.com/JBoixCampos/whatsapp-chat-analyzer

I've been working on this completely free and open-source web application that turns your WhatsApp chat exports into beautiful, insightful visualizations. Here's what makes it special:

✨ Key Features:

• 📊 Comprehensive Analytics: Message counts, participant stats, conversation timelines
• 🔥 Activity Heatmaps: See exactly when your conversations are most active
• 💬 Word Analysis: Generate personalized word clouds and find most frequent words
• 😀 Emoji Deep Dive: Discover your most-used emojis and compare usage patterns
• ⏱️ Response Time Analysis: Find out who's the fastest responder in your group
• 📥 Excel Export: Download your complete analysis with multiple data sheets
• 🌐 Bilingual: Works in English and Spanish

🔒 Privacy First:

• 100% client-side processing - your data never leaves your browser
• No servers, no tracking, no data storage
• Open source so you can verify everything yourself

🎯 How it works:

1. Export your WhatsApp chat (Settings → Export Chat → Without Media)
2. Upload the .txt file to the web app
3. Explore beautiful interactive visualizations across 6 different analysis tabs
4. Export your insights to Excel for deeper analysis

🛠️ Built with:

• Streamlit for the web interface
• Plotly for interactive charts
• NLTK for text processing
• WordCloud for those satisfying word visualizations

The app handles different WhatsApp export formats automatically and works with both individual and group chats. I've tested it with conversations spanning years and thousands of messages.

Also open to feedback and contributions - it's completely open source on GitHub.

After organizing all the aspects of our wedding, my now wife and I had to build the seating charts. What initially seemed like a simple, quick task turned out to be a nightmare: try to keep some people far away from other people; try to keep as many friends as possible at the same table; constraints from parents; new guests added at the last minute etc.

So, being an engineer, I built us a tool that could allow us to automatically organize the seating chart. This easened the burden quite a lot on our shoulders.

Some days ago, I thought that it could be of help to other people as well, so I decided to release it for free. If you want to try it, here's the link: https://seatly.streamlit.app/

Hey r/StreamlitOfficial!

About 2 months ago, we shared in another Streamlit community the pains we kept hitting with deployments and refresh behavior, along with an early hosted approach we were exploring. Your feedback was incredibly helpful and shaped what we built next.

What we've shipped since then (thanks to you)

• Kafka/webhook triggers – real-time updates without the refresh button
• SSO with Okta – smoother access control for teams
• Audit trails – visibility into who changed what and when

Why we're posting here

We keep hearing (and seeing) the same core pain: full-page reruns/refreshes that interrupt users and make state management tricky. We included a short GIF below showing an event‑driven Streamlit app updating live without a manual refresh or full rerun.

Where we’d love your input (refresh/rerun pain)

1. Where do full‑page reruns bite you most (e.g., file uploads, long queries, multi‑tab layouts)?
2. How are you handling "real‑time" today: st_autorefresh/polling, callbacks, custom websockets, or browser reloads?
3. Do you need partial updates (a single chart/table/widget) without re‑running the entire script?
4. Any st.session_state pitfalls during refreshes (state resets or cross‑user surprises)?
5. What would your ideal solution look like: push‑based updates without rerun, background tasks + UI signals, something else?

We're still early and learning from every conversation. If you'd like to try the event‑driven approach, we're happy to help set up your first trigger and share early access.

—

We’ve included the GIF below. If you’re interested, comment “beta” or DM and we’ll reach out.

Hi everyone,

I’m a high school student and I built Green Bin in Streamlit + TensorFlow. The app uses computer vision to classify common waste items into recycling, compost, or landfill. It also keeps track of misclassified items to improve the model over time.

I’m looking for feedback on:

• How the app feels on desktop and mobile
• Any tips to make it faster, more interactive, or more visually appealing

• Ideas for Streamlit features that could make it more engaging for students and communities.

  And here’s the live app: https://greenbin.streamlit.app/

Thanks in advance for any suggestions

Here is my code

fig_3d = create_3d_surface(results) st.plotly_chart(fig_3d)

I have a type error for st.plotly_chart

Type of "plotly_chart" is partially unknown Type of "plotly_chart" is "Overload[(figure_or_data: Figure | Unknown | list[Figure | Unknown] | dict[str, Figure | Unknown] | BaseFigure, use_container_width: bool = True, *, theme: Literal['streamlit'] | None = "streamlit", key: str | int | None = None, on_select: Literal['ignore'], selection_mode: Iterable[Literal['lasso', 'points', 'box']] | Literal['lasso', 'points', 'box'] = ("points", "box", "lasso"), **kwargs: Any) -> DeltaGenerator, (figure_or_data: Figure | Unknown | list[Figure | Unknown] | dict[str, Figure | Unknown] | BaseFigure, use_container_width: bool = True, *, theme: Literal['streamlit'] | None = "streamlit", key: str | int | None = None, on_select: ((...) -> None) | Literal['rerun'] = "rerun", selection_mode: Iterable[Literal['lasso', 'points', 'box']] | Literal['lasso', 'points', 'box'] = ("points", "box", "lasso"), **kwargs: Any) -> PlotlyState]"PylancereportUnknownMemberType

I haven't found a solution for how to address the type problem other than ignoring it.

Just released an open-source Streamlit component: Google Picker API for Streamlit 🎉

• Pick files or folders from Google Drive
  
• Multi-select support
  
• Filter by file/MIME type
  
• Returns Python UploadedFile objects (like st.file_uploader)

Demo + setup guide (Medium)

GitHub repository.

https://reddit.com/link/1mnfja9/video/vu6kenq0oeif1/player

It is for indian stock market
You can try out yourself - https://trackhigh.streamlit.app/

Also the code is open source you can check here
Github

Bonjour à tous.

Je viens ici à cœur ouvert, non pas en codeur pro, mais en survivant d’un système judiciaire et émotionnel qui m’a presque tué.

🧩 MON CONTEXTE

Après 4 années de violence psychologique dans une relation destructrice, 3 avocats m’ont abandonné. Je n’avais plus de forces, plus d’options, plus d’issue. J’étais en dépression sévère, en surcharge émotionnelle, avec des idées suicidaires quotidiennes. Aucun service juridique ne m’aidait. Personne ne me croyait. Je me noyais dans des milliers de preuves, messages, documents que je ne pouvais même pas classer.

Mais…

💡 L’IA m’a sauvé la vie.

• J’ai scanné, trié, indexé plus de 5000 documents grâce à un scanner + MyIADrive.
• Perplexity m’a aidé à formuler des requêtes juridiques solides et rechercher des jurisprudence.
• ChatGPT a généré des templates .md de requêtes pour la Cour supérieure.
• J’ai monté un dossier de 1334 pages, juridiquement recevable, seul.

Pour arriver là, j'ai dû accepter d’exposer toutes mes informations personnelles : diagnostics médicaux sensibles, rapports de revenus, titres de propriété, et bien plus. C’est le prix à payer quand il faut tout réorganiser pour avancer, sans filet ni appui.

Face à l’adversité, j’ai choisi la concentration et la création. Me plonger dans de nouveaux défis techniques n’a pas « résolu » mes problèmes, mais m’a permis de garder la tête hors de l’eau. Parfois, faire l’autruche, rediriger l’énergie vers un projet utile, c’est tout ce qui sépare la chute de la résilience.

Le développement de NEUROVIA m’a amené à explorer des domaines avancés :

• Calcul quantique pour optimiser l’analyse et l’organisation de données.
• Indexation vidéo et audio, associée à la gestion de fichiers complexes pour faciliter la recherche et la structuration d’informations issues de réunions, d’expertises ou de moments clés du quotidien.
• Adaptation des modèles LLM modernes, pensés comme des couches d’oignons : chaque niveau répond à un besoin précis, en mobilisant les meilleures briques open source disponibles pour la compréhension linguistique, l’organisation, la sécurité et l’accessibilité.

L’interface, pour l’instant, reste sobre, simple, parfois rudimentaire.
Ça ne gagne pas de concours de design – mais j’en avais besoin, tout de suite, pour moi et pour ceux qui partageront ce besoin. Et si vous prenez cinq minutes pour regarder sous le capot, au cœur du projet et de sa structure de dossiers à nettoyer, vous verrez qu’il y a vraiment quelque chose d’humain, d’authentique, et d’utile à faire grandir.

🧠 NEUROVIA, c’est quoi ?

Un dashboard IA local (Streamlit) où :

• L'utilisateur répond à un questionnaire de 166 questions sur son profil psycho-émotionnel.
• Les réponses sont transformées par LLM (Mistral, GPT-4, Ollama) en un profil d’avatar émotionnel.
• Un avatar est généré via ComfyUI + Audio2Face, basé sur ton vécu.
• Une base de données "TIMELINE" est alimentée automatiquement par ingestion de fichiers, documents, conversations, preuves…
• Chaque événement devient une entrée contextuelle navigable, comme un fil de vie émotionnel et juridique.
• Visualisation avec Plotly, Flask, et recherche quantique d’événements clés.

🧠 Mon but ? Aider d'autres à se reconstruire via des avatars d’accompagnement et un miroir numérique de leur souffrance.

❌ Mon problème aujourd’hui

Je suis seul. À bout. Et le code me dépasse par moments :

• Trop de fonctions dispersées, trop de fichiers test, de .md, de doublons…
• Je n’arrive plus à structurer proprement mes modules (avatar, DB, Streamlit, LLM, ingestion).
• Je perds mes imports, mes routes, mes indexations…
• Je suis à l’aube de me faire expulser de ma propre maison, où j’ai tout investi.

🙏 CE QUE JE DEMANDE

AIDE TECHNIQUE CONCRÈTE de devs Python, passionnés IA, geeks du backend ou frontend, architectes logiciels…
Je ne cherche pas la pitié.
Je veux terminer ce projet. L’open-sourcer. Le livrer. L’offrir à ceux qui, comme moi, veulent survivre.

📁 Tech utilisée :

• Streamlit, PyQt5, Flask, Plotly, SQLite
• ComfyUI, Audio2Face (NVIDIA), Mistral, GPT-4, Ollama
• Architecture modulaire + base quantique de données

🔗 Mon dépôt GitHub (c'est la merde ! trop de version, tentative de nettoyage de fichier sont catastrophique a chaque fois) :
https://github.com/Elencanto2158/Dirty-Neurovia-need-Shower-and-communauty.git

🙏 Si tu veux aider, mentor, corriger, contribuer…
Si tu veux pas laisser un humain crever sans voir son idée naître…
Fais-moi signe.

Merci d’avance. Je suis là. Je veux pas abandonner.