panel

Panel implements a reactive programming model built on top of param.Parameterized, where changes to parameter objects automatically trigger UI updates through bidirectional communication. The framework uses pn.bind() to establish dependencies between Python parameters and frontend widgets, with automatic dependency tracking that ensures efficient updates without manual event handling. This is achieved through Bokeh model synchronization where parameter changes propagate to the browser and frontend events flow back to Python models.

Panel's pane system provides automatic object-type detection and rendering for 20+ visualization libraries including Matplotlib, Plotly, Bokeh, Altair, Folium, PyVista, and ipywidgets. When a visualization object is passed to Panel, the framework inspects its type and routes it to the appropriate pane class (e.g., panel.pane.Matplotlib, panel.pane.Plotly) which handles conversion to Bokeh models for browser rendering. This eliminates boilerplate conversion code and allows developers to mix visualization libraries seamlessly in a single dashboard.

Panel applications render inline in Jupyter notebooks using IPython's display system, enabling interactive dashboards in notebook cells without external servers. The framework detects the notebook environment and uses Jupyter's comm protocol for bidirectional communication between Python and JavaScript. Developers can mix Panel components with notebook cells, creating hybrid notebooks that combine code, visualizations, and interactive controls. The same code renders in notebooks and web servers without modification.

Panel's DataFrameViewer and DataFrame widgets provide interactive table rendering for Pandas and Polars DataFrames with built-in sorting, filtering, pagination, and column selection. The widgets are implemented as Bokeh ColumnDataSource models that efficiently handle large datasets through server-side pagination. Users can click column headers to sort, use filter inputs to search, and select rows for further analysis. The selected rows are accessible as a parameter that can be used in downstream computations.

Panel includes pre-built templates (Bootstrap, Material Design, Fast) that provide consistent styling, navigation, and page structure without CSS knowledge. Templates are Python classes that inherit from BaseTemplate and define header, sidebar, and main content areas. Developers populate template areas with Panel components, and the template handles responsive layout, navigation, and theming. Templates compile to Bokeh models and render as styled HTML in the browser, providing production-ready UI without design overhead.

Panel supports async/await patterns in callbacks and widget event handlers, enabling non-blocking operations and concurrent request handling. Developers can define async callback functions that yield control back to the event loop, allowing other requests to be processed while waiting for I/O (database queries, API calls, file operations). The framework uses Tornado's async event loop to manage concurrent connections and execute async callbacks. This is particularly useful for streaming LLM responses and long-running computations.

Panel enables linking between components through parameter synchronization, where changes to one component's parameters automatically update linked components. This is implemented through param.Parameterized watching and Bokeh's property system, allowing developers to create cross-filtered dashboards without explicit callbacks. For example, selecting a row in a table can filter a plot, or changing a slider can update multiple visualizations. Linking is declarative and works through shared parameter references.

Panel provides a hierarchical layout system built on Bokeh's GridBox model, enabling developers to compose dashboards using Row, Column, and Grid containers that automatically handle responsive sizing and alignment. Layouts are defined in Python as nested objects (e.g., pn.Column(pn.Row(widget1, widget2), plot)) and compile to Bokeh layout models that render responsively in the browser. The framework also includes pre-built templates (Bootstrap, Material Design, etc.) that provide consistent styling and navigation patterns without CSS knowledge.

Panel provides 30+ interactive widgets (sliders, text inputs, dropdowns, date pickers, tables, progress indicators) that inherit from param.Parameterized and automatically sync with Python state. Widgets are implemented as Bokeh models on the frontend with Python parameter objects on the backend, enabling two-way binding where user interactions update Python values and parameter changes update the UI. Table widgets support Pandas and Polars DataFrames with built-in sorting, filtering, and pagination without additional configuration.

Panel applications are written in pure Python and execute identically in Jupyter notebooks, web servers (via panel serve), and batch scripts without code changes. The framework achieves this through param.Parameterized abstraction which decouples application logic from deployment context. When deployed as a web app, Panel runs a Bokeh server that maintains Python state and handles bidirectional communication with the browser, while in notebooks the same code renders inline using Jupyter's display system.

Panel provides ChatInterface and ChatMessage components that enable building conversational UIs with streaming support for LLM responses. The chat system handles message history management, automatic scrolling, and token-aware rendering. Developers can integrate OpenAI, Anthropic, or custom LLM APIs by providing a callback function that receives the message history and returns a response (string or async generator for streaming). The framework handles rendering, state management, and message persistence without requiring manual DOM manipulation.

Panel's Markdown and HTML panes enable rendering formatted text with embedded Python expressions that update reactively. Developers can write Markdown/HTML strings with f-string-like syntax (e.g., f'Current value: {param_obj.value}') and Panel automatically updates the rendered output when parameters change. This is implemented through string parsing and parameter watching, allowing dynamic content generation without explicit callbacks. Supports both static HTML and reactive Markdown with LaTeX math rendering.

Panel applications are deployed using a Bokeh server backend that maintains Python state and handles bidirectional WebSocket communication with the browser. The panel serve command starts a Bokeh server that loads the Panel application, creates a new Python session per client connection, and synchronizes parameter changes between the browser and Python through Bokeh's protocol. This enables stateful applications where each user has isolated state, unlike stateless frameworks like Streamlit.

Panel enables developers to create custom components by subclassing the Viewable base class and implementing a _get_model() method that returns a Bokeh model. This allows wrapping custom Bokeh models, JavaScript libraries, or complex UI logic as reusable Panel components. The framework handles parameter synchronization, event propagation, and lifecycle management automatically. Developers can also use Panel's IPyWidget pane to embed Jupyter widgets without creating custom components.

Panel implements state management through param.Parameterized parameter watching and explicit callback registration. Developers can use @pn.depends decorator to create reactive functions that re-execute when dependencies change, or use .watch() to register callbacks on parameter changes. The framework also provides caching mechanisms through param's @param.depends decorator with cache_on argument, enabling memoization of expensive computations. State is maintained in Python memory and synchronized with the browser through Bokeh models.