Pluto.jl

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 content as pure executable source files.

The platform covers a wide range of capabilities, including interactive data visualization, the creation of guided educational assignments, and the generation of static documentation websites. It supports diverse output modes such as slideshow presentations and web applications, and provides tools for exporting notebooks to HTML, PDF, and reproducibility-focused scripts.

The environment can be launched via a web interface on localhost or accessed through remote servers and cloud compute hosting.

Features

Interactive Data Science Environments - Provides a browser-based environment for iterative data analysis combining code, visualization, and narrative.
Reactive Programming - Implements a reactive programming environment where downstream cells automatically re-execute when upstream dependencies change.
Reactivity Dependency Graphs - Implements a reactive dependency graph to trigger precise updates of downstream cells when variables change.
Markdown Structural Formatting - Uses markdown syntax to provide structural formatting, headings, and lists for documentation within cells.
Application State Serialization - Converts notebook data and binary states into a compact MsgPack format for efficient storage.
Notebook Cell Execution - Provides the ability to execute code in discrete notebook cells while preserving state.
Dependent Cell Refresh - Triggers re-evaluation of downstream cells when a value changes to ensure consistent system state.
Reactive Cell Synchronization - Automatically executes code cells whenever a dependency changes to maintain a consistent environment state.
Interactive Data Exploration Tools - Provides a reactive environment for exploring and visualizing data where outputs update automatically as variables change.
Script-Based Notebooks - Persists notebook content as standard executable Julia source files to ensure version control compatibility.
Embedded Environment Control - Provides controls to reset, update, or activate the embedded package environment and dependency files within a notebook.
Computational Notebooks - Functions as a programmable document format storing code and environment dependencies as versionable source files.
Interactive Notebook Environments - Serves notebooks on a web server allowing visitors to interact with inputs through isolated sessions.
Isolated Environment Managers - Integrates with a package manager to maintain dedicated project files and automate dependency isolation.
Notebook Dependency Managers - Declares and installs required packages directly within the notebook file to ensure a reproducible execution environment.
Package Dependency Management - Integrates package version tracking directly into notebook files to ensure perfectly reproducible execution environments.
Embedded Package Environments - Integrates isolated package environments directly within notebook files to ensure exact library versioning and reproducibility.
Interactive Assignment Frameworks - Builds interactive exercises with text explanations and placeholders that provide immediate feedback via reactive execution.
Interactive Textbooks - Creates interactive textbooks and guided programming assignments with live sliders and widgets for exploration.
Interactive Software Education - Combines theory with hands-on coding by providing an interactive environment for students to explore scientific models.
Notebook Source Persistence - Saves notebooks as pure source files that can be imported into other scripts.
Reactive Notebooks - Implements a reactive computing environment that automatically updates dependent cells when variables change.
Reproducible Notebook Storage - Saves notebook content as executable source files to ensure the environment is reproducible and versionable.
Scientific Computing Workflows - Supports scientific computing workflows for developing mathematical models and simulations with integrated package management.
Dependency Tracking - Automatically identifies and tracks variable dependencies, including those emerging after macro expansion, to drive reactive execution.
Directed Acyclic Graph Engines - Uses a directed acyclic graph engine to track variable dependencies and automatically re-evaluate affected downstream cells.
Reactive Execution Models - Uses a reactive execution model to propagate updates through the notebook automatically.
Reproducible Scripts - Saves notebook state and exact package versions into a script file to ensure identical execution results.
Reproducible Package Tracking - Automatically installs and tracks specific versions of required libraries to ensure reproducible execution across different machines.
MIME Type Renderers - Renders cell outputs by mapping the data's MIME type to specialized frontend components.
HTML Exports - Generates standalone HTML files from notebooks including outputs and source code for offline viewing.
Multi-Format Exports - Generates shareable versions of notebooks in multiple formats including HTML, PDF, and source files.
PDF Exports - Converts notebooks into printable PDF documents while managing page breaks to keep cells intact.
Technical Documentation - Generates static websites and HTML reports from executable notebooks to share research and technical guides.
Interactive State Sharing - Distributes notebook state and computations so others can interact with and explore the same results.
Reactive Website Publishing - Hosts notebooks as live websites that maintain reactivity by connecting the frontend to a backend process.
Notebook-Based Publishing - Publishes reactive notebooks to a public gallery for exploring models and demonstrated workflows.
Dynamic Documentation Generation - Converts reactive notebooks into static websites, HTML pages, or PDFs for distribution.
Static Site Generators - Compiles notebooks, markdown files, and images into complete static sites for web hosting.
Web-Based Notebook Publishing - Publishes notebook content to the web via HTML export or cloud hosting for URL access.
Execution Control Guards - Prevents specific code blocks from running automatically during dependency changes to isolate workflows.
Reactivity Toggles - Prevents specific cells from updating automatically, keeping them static regardless of dependency changes.
Interactive Visualization Rendering - Generates static or interactive plots and charts that update in response to variable changes.
Browser-Based Execution Environments - Launches interactive sessions via cloud environments to enable code execution without local installation.
Static Site Documentation - Transforms notebooks into professional static documentation websites with integrated search and custom layouts.
Shareable Notebooks - Enables uploading notebook exports to a web service to generate shareable public links for zero-setup execution.
Notebook Lifecycle Management - Manages the full lifecycle of interactive notebooks, including creation, saving, and shutdown.
Multi-notebook Session Management - Enables running several notebooks simultaneously within a single session to switch between projects.
Notebook Loading - Provides the ability to load notebooks from local paths, web URLs, or the system clipboard.
Cloud Hosting - Provides the ability to host notebooks on remote servers to access high-performance compute resources like GPUs.
Interactive Learning Platforms - Serves as a platform for creating guided programming assignments and interactive textbooks with live feedback.
Macroexpansion Dependency Tracking - Tracks variable dependencies that emerge during execution by analyzing code after macroexpansion.
Two-Way - Synchronizes browser-based UI widgets with backend program variables to trigger immediate reactive re-evaluation.
Interactive Content Controls - Provides embedded sliders, buttons, and scrubbable numbers to control plots and numerical outputs.
Slideshow Mode - Transforms notebook content into a full-screen presentation using Markdown header levels to define slides.
Visual Layout Reorganization - Allows arranging cells in any visual order while maintaining execution based on variable dependencies.
Web App View Modes - Provides a minimalistic view that hides the editor, allowing notebooks to function as simple web applications.
Widget Data Bindings - Connects browser-based input widgets directly to program variables to trigger immediate code re-evaluation.
Polymorphic Output Renderers - Displays cell outputs by matching the data type of the result to a specialized frontend component using MIME types.

marimo-team/marimo

21,468View on GitHub

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

NixOS/nix.dev

3,630View on GitHub

This project provides a functional package manager and a reproducible build system designed to ensure identical build inputs always produce the same outputs. It serves as the foundation for a declarative Linux distribution where the entire system state is defined in a configuration file, enabling predictable deployments and full-system rollbacks. The system uses a deterministic functional language and a lazy-evaluation expression engine to manage software dependencies and isolate build environments. It distinguishes itself through a content-addressable store that allows multiple versions of s

jupyterlab/jupyterlab

15,210View on GitHub

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

jupyter/notebook

13,204View on GitHub

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

JuliaPlutoPluto.jl

Features