Panel Documentation

Panel can be run directly in the web browser using WebAssembly (WASM) via technologies like Pyodide or PyScript. This approach allows you to execute Python code and render Panel applications entirely on the client side, eliminating the need for a separate Python/Bokeh server process.

Key capabilities include:

• Running Python libraries and manipulating the DOM from Python in the browser.
• Converting existing Panel applications into WASM-based applications.
• Manually installing Panel in the browser to render components.
• Embedding live Panel components in Sphinx documentation.
• Using JupyterLite to render interactive Panel output.

Panel is an open-source Python library for developing robust tools, dashboards, and complex web applications entirely within Python. It integrates with the PyData ecosystem and supports both high-level reactive APIs and lower-level callback-based APIs.

Key capabilities include:

• Developing in editors or Jupyter notebooks.
• Combining PyData tools and plotting libraries.
• Adding bi-directional communication to data apps.
• Creating interactive big data applications with cross-filtering.
• Building high-performing, streaming, or browser-only applications.
• Creating production-ready web applications.

Panel offers several ways to customize the appearance of your applications and components. You can:

• Apply a Design: Switch between different design systems.
• Toggle themes: Switch between themes like 'light' and 'dark'.
• Apply CSS: Use custom CSS for specific styling needs.
• Customize a Design: Use CSS variables to modify existing designs and themes.
• Customize Loading Icon: Change the appearance of the loading indicator.
• Control Visibility: Manage when components are visible in the UI.
• Style Plotting Libraries: Apply specific styling to integrated libraries including Altair, ECharts, Matplotlib, Plotly, and Vega Lite.

Panel provides an admin dashboard to help diagnose performance bottlenecks and track application issues. This dashboard allows you to:

• Monitor resource usage and user behavior via the Admin Panel.
• Profile application performance using tools like snakeviz or memray to identify bottlenecks.
• View application logs directly within the admin dashboard for better visibility than standard server logs.

Panel applications are built using three primary component types:

• Pane: Wraps a user-supplied object (of almost any type) into a renderable view. It automatically updates the view when the wrapped object or its parameters change.
• Widget: A control component used for user input (e.g., clicking or editing in a browser). Widgets can be controlled via the browser or from within Python.
• Panel: A hierarchical container used to layout multiple components (panes, widgets, or other Panels) into an organized app or dashboard.

Panel provides three primary API approaches depending on your project's complexity and requirements:

1. Reactive API: Use pn.bind or the pn.depends decorator to link functions directly to widgets. This is the recommended approach for most users and projects as it is efficient, explicit, and maintainable.
2. Declarative API: Use Parameterized classes to declare parameters and their ranges. This is ideal for writing libraries or core code that needs to support an optional GUI interface, as it provides automatic GUI generation and value checking.
3. Callbacks API: Manually declare callbacks to update panels or panes. Use this when you need low-level, arbitrary event handling or want to implement custom logic alongside other API approaches.

Panel supports several deployment modes:

• Web Server: Run as a web application using Tornado (default), Flask, Django, or FastAPI.
• Client-side (WASM): Deploy as a standalone client-side application using Pyodide or PyScript via the panel convert command.
• Notebook: Use as an interactive component within a Jupyter notebook.
• Static: Export as a static .html page, .gif video, or .png image.

Panel facilitates communication between Python code and JavaScript/HTML objects in a web browser. The level of interactivity available depends on the communication type supported by your environment:

1. One-time Python->JS: Basic one-way communication (e.g., exporting to a static .html file). No Python process remains running.
2. Ongoing Python->JS synchronization: Python sends updates to JS when Python attribute values change. Required for dynamic updates in notebooks.
3. Ongoing JS->Python synchronization: JS sends updates back to Python when users interact with widgets.

Full bidirectional (JS<->Python) synchronization requires all three types and is typically achieved using a standalone server (via panel serve) or specific integration libraries.

Explore the following resources for inspiration and learning:

• Awesome Panel: A curated list of resources and tools (awesome-panel.org).
• Social Media: Follow Panel on X and LinkedIn for announcements and showcases.