For a reactive Python notebook, the strongest matches are marimo-team/marimo (Marimo is a reactive Python notebook that automatically tracks), juliapluto/pluto.jl (Pluto) and jupyterlab/jupyterlab (JupyterLab is a full-featured notebook environment for interactive computing). jupyter/notebook and jupyterlite/jupyterlite round out the shortlist. Each is ranked by relevance to your query, popularity and recent activity.
Interactive development environments that automatically re-execute dependent code cells when upstream data or variables change.
Marimo is a reactive Python notebook environment and data science integrated development environment. It functions as a scripting tool that maintains state consistency by automatically tracking variable dependencies and re-executing downstream code blocks whenever upstream inputs are modified. The platform distinguishes itself by storing notebooks as standard, portable Python scripts rather than proprietary formats, ensuring compatibility with version control systems. It integrates artificial intelligence to assist with code generation and debugging based on the current execution context, whi
Marimo is a reactive Python notebook that automatically tracks variable dependencies and re-executes downstream cells on change, providing exactly the automatic cell re-execution, notebook interface, and built-in data visualization you are looking for.
Pluto.jl is a reactive computing environment for Julia that functions as a programmable document format. It serves as an interactive data science IDE and a polyglot computational notebook that stores Julia code and environment dependencies as versionable source files. The system is distinguished by its reactive execution model, which uses a directed acyclic graph to track variable dependencies and automatically re-evaluate affected downstream cells when a value changes. It ensures reproducibility by integrating isolated package environments directly within the notebook file and persisting con
Pluto.jl is a reactive notebook environment with automatic cell re-execution based on dependencies, but it uses Julia instead of Python, so it does not match the specific language requirement for a Python notebook.
JupyterLab is a web-based development environment designed for interactive data science, collaborative research, and computational notebook authoring. It provides a unified workspace where users can execute code, manage computational kernels, and create documents that integrate live code, rich data visualizations, and narrative text. The platform is built on a modular architecture that supports extensive customization through a plugin system. This framework allows for the dynamic loading of extensions, enabling users to define custom file viewers, interface themes, and keyboard shortcuts. By
JupyterLab is a full-featured notebook environment for interactive computing, but it lacks built-in automatic cell re-execution based on dependency changes—you would need to manually run cells or add extensions to get that reactive behavior.
This project is a browser-based interactive computing environment and data science IDE. It serves as a literate programming tool that allows users to create documents combining live code, mathematical equations, visualizations, and narrative text. As a polyglot notebook interface, it connects to various language kernels to execute code and render output within a single interface. The application distinguishes itself by separating the frontend interface from a remote compute engine through a language-agnostic kernel interface. This allows it to support multiple programming languages while main
Jupyter Notebook is a classic interactive notebook environment but does not automatically re-execute cells based on dependency changes — that reactive behaviour is the core feature you need and this tool lacks it.
JupyterLite is a WebAssembly-based interactive notebook environment that enables browser-based computing without a backend server. It provides a client-side data science sandbox where users can execute programming language kernels and run interactive notebooks entirely within the web browser. The project allows for the creation of tailored distributions by pre-installing specific language packages, bundling custom wheels, and applying environment configurations. It supports the generation of static sites that can be deployed to any standard HTTP host, including the ability to package the envi
JupyterLite brings the standard Jupyter notebook interface to the browser via WebAssembly, but it does not track cell dependencies or automatically re-execute cells when they change — it runs as a classic notebook where each cell must be re-run manually.
Jupyter is an interactive computing platform and data science workspace designed for creating documents that combine live code, equations, visualizations, and narrative text. It provides a polyglot notebook interface that connects a frontend user interface to various backend language engines through a standardized kernel protocol for real-time code evaluation. The system enables polyglot programming workflows, allowing multiple different programming languages to run within a single interface. It supports computational document authoring and data science exploration by allowing users to execut
Jupyter is a general notebook interface and interactive computing platform, but it does not automatically re-execute cells based on dependency changes—that reactive feature requires additional extensions or tools, so it's not a fit for a reactive notebook environment on its own.
Kotlin Jupyter is an interactive computing environment that enables the execution of Kotlin code within Jupyter notebooks. It functions as a kernel for the Java Virtual Machine, providing a platform for data analysis, rapid prototyping, and scientific computing research. The system manages the evaluation of code snippets by compiling them dynamically at runtime, allowing for real-time interaction and variable inspection. The project distinguishes itself through a sophisticated code transformation pipeline that intercepts and modifies user input to support custom syntax and automated logic. It
This is a Jupyter kernel for Kotlin, not Python, so it doesn't match the core language requirement; while it offers an interactive notebook environment, it lacks the reactive dependency-based re-execution and the Python kernel you're looking for.
MobX is a reactive state management library and fine-grained reactivity engine. It provides an observable data store that automatically triggers updates in the user interface when data structures change, functioning as a transparent functional reactive store to maintain a consistent source of truth. The system utilizes a dependency-graph mapping and proxy-based object observation to track data dependencies. This ensures that only the specific components dependent on changed data are updated, which reduces unnecessary re-renders and optimizes frontend performance. The library supports decoupl
MobX is a reactive state management library for JavaScript/TypeScript frontends, not a Python notebook environment — it automatically re-renders UI components on data changes but lacks a notebook interface, a Python kernel, and cell-level caching.
Altair is a declarative data visualization library for Python based on the Vega-Lite grammar. It allows users to create statistical visualizations by mapping data fields to visual properties rather than writing imperative drawing code. The library focuses on interactive charting through a system of linked selections and filters that update multiple visualizations based on user input. It renders charts as JSON and HTML for display in web browsers and interactive notebooks. The project covers statistical data analysis and interactive data exploration, providing capabilities to export visuals a
Altair is a Python data visualization library that works inside notebook environments like Jupyter, but it is not a notebook environment itself and does not provide automatic cell re-execution or a reactive Python kernel.
This project is a collection of pre-configured Docker images that provide ready-to-run environments for interactive computing and data science. It functions as a scientific computing stack and a polyglot notebook server, bundling language interpreters and libraries for Python, R, and Julia within a containerized system to ensure reproducible research environments. The collection uses a layered image hierarchy to provide versioned software dependencies and support for hardware acceleration across different CPU architectures. It allows for the creation of custom images based on a foundation of
This is a collection of Docker images pre-configured with Jupyter and common data-science libraries, but it is not a reactive notebook environment that automatically re-executes cells based on dependencies—it simply provides containerized Jupyter setups without the dynamic execution engine you are looking for.
Azure Data Studio is a cross-platform SQL database management IDE used for writing queries, managing schemas, and administering relational databases. It functions as a comprehensive environment for relational database management, providing a structured interface for executing SQL queries and browsing database objects. The platform is distinguished by its interactive data notebooks, which combine executable code cells, narrative text, and visualizations for data analysis. It also includes specialized tools for database migration, allowing users to assess and transfer schemas and data from on-p
Azure Data Studio is a SQL database management IDE with interactive notebooks, but its notebooks are SQL-centric, not a Python reactive environment with automatic cell re-execution based on dependencies.
Positron is a data science integrated development environment and AI-powered code editor designed for polyglot development, specifically supporting Python and R. It functions as a remote compute workspace that separates the user interface from the execution kernel via SSH or container integration. The environment features a deep integration of large language models that provide context-aware suggestions and automated data analysis by accessing real-time interpreter state, in-memory objects, and plot outputs. It distinguishes itself through a polyglot runtime bridge that enables cross-language
Positron is a polyglot data science IDE, not a reactive notebook environment — it lacks the automatic cell re-execution and dependency-tracking behaviour you are looking for, though it may support notebooks as one of many features.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| marimo-team/marimo | 21.5K | Python | Apache-2.0 | |
| juliapluto/pluto.jl | 5.3K | JavaScript | MIT | |
| jupyterlab/jupyterlab | 15.2K | TypeScript | BSD-3-Clause | |
| jupyter/notebook | 13.2K | Jupyter Notebook | BSD-3-Clause | |
| jupyterlite/jupyterlite | 4.8K | TypeScript | BSD-3-Clause | |
| jupyter/jupyter | 15.3K | Python | BSD-3-Clause | |
| kotlin/kotlin-jupyter | 1.2K | Kotlin | Apache-2.0 | |
| mobxjs/mobx | 28.2K | TypeScript | MIT | |
| altair-viz/altair | 10.4K | Python | BSD-3-Clause | |
| jupyter/docker-stacks | 8.4K | Python | BSD-3-Clause |