Streamlit

Transforms imperative Python scripts into reactive web UIs by executing the entire script on each state change, capturing all st.* API calls into a DeltaGenerator that builds a Protocol Buffer message stream (ForwardMsg), which is serialized and sent via WebSocket to a React frontend that reconstructs the UI. Uses a singleton Runtime managing AppSession instances per user, with script re-execution triggered by widget interactions or file changes, enabling developers to write linear Python code without explicit event handlers.

Manages widget state across script re-executions using st.session_state, a dictionary-like object that persists for the duration of a user session (WebSocket connection). Widget values are automatically keyed and stored; developers can also manually manage state by assigning to session_state[key]. State is maintained in memory per AppSession instance and survives script reruns but is lost on page refresh unless explicitly persisted to external storage (database, file, etc.).

Provides st.connection() API for managing connections to databases (SQL, MongoDB, Snowflake) and external services (HTTP APIs, Hugging Face, etc.). Built-in connectors handle authentication, connection pooling, and query execution. Developers call st.connection('connection_name') to get a connection object, then use methods like .query() or .execute() to interact with the service. Connections are cached per session and reused across script reruns, reducing connection overhead. Secrets are automatically injected into connection strings.

Provides OAuth and OIDC integration for authenticating users via third-party providers (Google, GitHub, Azure AD, etc.). Streamlit Cloud handles OAuth flow automatically; self-hosted deployments require manual OAuth configuration. st.experimental_user provides access to authenticated user information (email, name, etc.). Authentication state is stored in session and persists across script reruns. Developers can gate app functionality behind authentication checks.

Streamlit Community Cloud is a free hosting platform that automatically deploys Streamlit apps from GitHub repositories. Developers push code to GitHub, connect the repo to Streamlit Cloud, and the app is deployed automatically with a public URL. Cloud handles server infrastructure, SSL certificates, and app scaling. Supports environment variable injection via web UI, automatic app reloading on Git pushes, and integrated secrets management. No Docker or server configuration required.

Provides AppTest class for programmatically testing Streamlit apps by simulating script execution and widget interactions. Tests instantiate AppTest with app script path, call methods like .run() to execute the script, and interact with widgets via .button[0].click(), .text_input[0].set_value(), etc. AppTest captures script output, widget state, and exceptions, enabling assertions on app behavior without running a browser. Tests run in Python and integrate with pytest.

Provides st.set_page_config() for setting app metadata (title, icon, layout, theme) and .streamlit/config.toml for global configuration (server settings, logging, caching behavior). The Configuration System reads config files at startup and applies settings to the app, with st.set_page_config() allowing per-page overrides. Supports theme customization (light/dark mode, color schemes) and layout modes (wide, centered), with configuration changes requiring app restart.

Provides two-tier caching system: @st.cache_data caches function outputs (serialized to disk) and reuses them if inputs haven't changed (detected via hash of function arguments), while @st.cache_resource caches expensive objects like database connections or ML models (stored in memory, not serialized). Both decorators intercept function calls, compute a hash of inputs, check an in-memory cache, and skip execution if cache hit occurs. Cache is scoped per AppSession and cleared on script changes or explicit st.cache_data.clear().

Enables multi-page applications by organizing Python files in a pages/ directory; Streamlit automatically discovers pages, generates a sidebar navigation menu, and routes user clicks to the corresponding script. Each page is a separate Python file that executes independently with its own session_state namespace, but shares global session_state across pages. Navigation is handled client-side via URL routing (e.g., ?page=page_name) with server-side script selection based on the current page.

Provides native rendering of popular Python visualization libraries through st.plotly_chart(), st.matplotlib_figure(), st.altair_chart(), and st.vega_lite_chart(). These functions serialize chart objects to JSON (for Plotly/Altair) or PNG (for Matplotlib) and embed them in the React frontend. Charts are interactive (Plotly, Altair) or static (Matplotlib), and support features like selection, hover tooltips, and responsive sizing. Streamlit also provides high-level charting functions (st.line_chart, st.bar_chart, st.area_chart) that wrap Altair for quick prototyping.

Renders a spreadsheet-like UI for editing Pandas DataFrames or lists of dictionaries in-place, with support for column type specification, validation, and cell-level editing. The st.data_editor component captures user edits, returns the modified data structure, and allows developers to react to changes via callbacks or by checking if the data changed. Supports column types (int, float, string, datetime, checkbox), column configuration (width, disabled, hidden), and validation rules. Edited data is returned as a new DataFrame/dict, not mutated in-place.

Provides st.file_uploader() for accepting file uploads from users and st.download_button() for serving files to download. Uploaded files are stored in temporary directories (cleaned up after session ends) and accessible as BytesIO objects or file paths. Download button generates a client-side download link with specified filename and MIME type. Both functions handle file I/O automatically without requiring developers to manage temporary files or HTTP headers.

Provides st.chat_message() context manager for rendering chat messages with role-based styling (user, assistant, etc.) and st.chat_input() for accepting user text input in a chat-like interface. Messages are rendered in a scrollable container with automatic styling and avatar support. Developers manage conversation history manually via st.session_state and re-render messages on each script rerun. Integrates with LLM APIs (OpenAI, Anthropic, etc.) via manual API calls within the chat loop.

Enables developers to build custom React components that communicate with Python via a BidiComponent (bidirectional component) pattern using Protocol Buffers. Components v2 uses a TypeScript/React SDK that wraps component logic and handles serialization of data between Python and JavaScript. Developers define component props in Python, render React components on the frontend, and receive user interactions back as Python objects. Communication is event-driven via WebSocket, allowing real-time updates without page reloads.

Provides st.secrets for accessing secrets stored in .streamlit/secrets.toml (local development) or Streamlit Cloud's secrets manager (production). Secrets are injected as environment variables and accessible via st.secrets[key] or st.secrets.get(key). Supports TOML syntax for nested secrets and automatic reloading on file changes. Streamlit Cloud integrates with its web UI for managing secrets without exposing them in code or version control.