pyodide/pyodide

Features

• Python Runtimes - Runs Python code and scientific libraries directly in the browser by leveraging WebAssembly.
• Browser-Based Runtimes - Provides a platform for running Python code and scientific libraries directly in the browser.
• Foreign Function Interfaces - Provides a foreign function interface for bidirectional data exchange and function calling between Python and JavaScript.
• Python-JavaScript Bridges - Enables bidirectional data exchange, object proxying, and function calling between Python and JavaScript.
• WebAssembly - Runs a full language interpreter inside a sandboxed WebAssembly binary environment for native-speed execution.
• Interactive Data Science - Enables interactive data analysis and computational notebooks that perform heavy processing locally.
• Python Package Managers - Manages the fetching, installation, and dependency resolution of Python packages within isolated web environments.
• Virtualized Filesystem Layers - Provides an isolated in-memory virtual filesystem that bridges host and runtime data access.
• Package Installers - Provides core utilities for installing and managing Python packages from remote repositories within the runtime.
• Language Interoperability - Provides mechanisms and bridges that allow different programming languages to communicate and share data.
• Sandboxed Code Execution Environments - Executes code strings within a sandboxed environment to bridge logic between the host language and the embedded interpreter.
• Web APIs - Enables code to manipulate document elements, handle browser events, and access native platform features directly from the execution environment.
• Full-Stack Web Applications - Enables full-stack application development by executing business logic and data processing entirely on the client side.
• Language Implementations - Runs Python in the browser via WebAssembly.
• Shared Memory Buffers - Enables high-performance data processing by transferring raw memory buffers and typed arrays between language runtimes.
• Interactive Consoles - Executes code within a managed environment that captures input and output streams through customizable callbacks.
• Interactive Notebooks - Supports browser-based computational environments for live code execution and literate programming.
• Virtual Environments - Creates isolated local workspaces to manage project-specific dependencies without global system impact.
• Asynchronous Request Handlers - Executes non-blocking network calls using a promise-based interface that leverages the native browser networking stack.
• Web Applications - Integrates Python logic into web applications to manipulate document elements and access native browser APIs.
• Serverless Frameworks - Deploys web frameworks and dashboarding tools entirely in the client browser without requiring a backend server.
• Browser Runtimes - Runs code and packages directly within browser environments by bridging synchronous code and asynchronous web APIs.
• DOM Manipulation - Provides methods and interfaces for dynamically updating the structure and content of web pages directly from code.
• Request Interception Middleware - Replaces standard socket-based networking with browser-native fetch capabilities to allow packages to perform HTTP operations.
• In-Memory File Systems - Provides a POSIX-compliant file system layer that maps memory buffers to file paths for standard I/O.
• Synchronous - Performs blocking input and output operations within the browser to ensure compatibility with standard libraries that expect synchronous behavior.
• Asynchronous Runtime Adapters - Provides abstraction layers that enable libraries to operate natively across different asynchronous event loops.
• ES Module Integrations - Registers external objects as importable modules to allow code to access and interact with native browser APIs.
• Runtime Execution Environments - Hosts and manages the lifecycle of running applications while enabling direct manipulation of browser or system APIs.
• Exception Handling Strategies - Implements patterns for catching and converting errors across language boundaries to ensure correct exception propagation.
• Binary Module Loaders - Resolves and links compiled binary modules at runtime to allow loading of native extensions on demand.
• Event Loop Managers - Coordinates long-running animation or game loops by yielding control to the browser event loop.
• Server-Side Runtimes - Executes code within server-side environments by integrating the interpreter into applications or command-line sessions.
• Persistent Storage Management - Attaches external filesystem backends to the virtual environment to enable data persistence across sessions.
• Project Lockfile Management - Generates and updates dependency lockfiles to ensure consistent package versions and integrity across environments.
• Event Loop Integrations - Yields control to the browser event loop during long-running computations to maintain UI responsiveness.
• Installation Integrity Verification - Validates the authenticity of downloaded packages by comparing file hashes against known records to ensure secure execution.
• Task Interruption Policies - Defines logic to handle interrupt signals and poll for cancellation requests during long-running operations.
• Standard Stream Interfaces - Configures custom handlers for standard input, output, and error streams to capture or provide data programmatically.
• Component Integrity Verifiers - Verifies the integrity and correctness of components and ensures type definitions are accurate and compliant.
• Global Scope Exporters - Exposes variables and functions to the host environment for reading, writing, and bidirectional data exchange.
• Execution Control - Provides logic gates and tools to manage the flow of program execution and enforce constraints during compilation.
• Proxy Lifecycle Management - Manages the creation and destruction of proxies for cross-language objects to ensure resources are cleaned up after use.
• Vector Graphics Renderers - Configures canvas elements to support libraries requiring graphical output and rendering capabilities.
• Background Processing Workers - Runs heavy computation in background threads to keep the main application thread responsive.

Star history