Fact-checked by Grok 2 weeks ago

Notebook interface

A notebook interface, also known as a computational notebook, is an interactive digital environment that integrates executable code, explanatory text, visualizations, and multimedia elements within a single document, enabling users to perform literate programming, data analysis, and reproducible computations.^[1] This format facilitates the creation of dynamic narratives where code can be executed incrementally, with outputs—such as plots, tables, or equations—embedded directly alongside the source material, promoting exploration and communication in fields like data science and scientific computing.^[2] The origins of notebook interfaces trace back to the late 1980s, when Wolfram Mathematica introduced the concept as a closed-source system to emulate traditional lab notebooks digitally, separating a front-end interface for input and output from a computational kernel for execution.^[3] Influenced by Donald Knuth's 1984 literate programming paradigm, which emphasized intertwining code with human-readable documentation, early implementations like Mathematica and Maple established the core architecture of front-end editors and backend kernels.^[3] By the early 2000s, open-source advancements such as IPython (2001) and SageMath (2005) expanded accessibility, culminating in the 2011 release of IPython's notebook interface and its evolution into Project Jupyter in 2014, which broadened support for languages like Python, R, and Julia.^[3]^[1] Key features of notebook interfaces include support for over 40 programming languages through interchangeable kernels, real-time interactive execution via protocols like JSON over WebSockets, and export options to formats such as PDF, HTML, or Markdown for sharing and reproducibility.^[1] These systems excel in environments requiring iterative experimentation, such as machine learning and geospatial analysis, by allowing seamless integration with big data tools like Apache Spark while maintaining version control compatibility through text-based formats.^[1]^[2] With nearly 10 million public notebooks on GitHub as of 2021, notebook interfaces are widely used in data-driven workflows but face challenges like dependency management and execution order dependencies, spurring innovations in next-generation tools such as JupyterLab.^[4]

Fundamentals

Definition and characteristics

A notebook interface is a form of literate programming environment that enables the creation of interactive documents combining executable code cells, richly formatted text using markup languages like Markdown, and dynamic outputs such as visualizations, tables, and multimedia elements, all within a unified, executable file format.^[5]^[6] This approach treats computational work as a narrative, where code serves both as a functional component and an illustrative element integrated with explanatory prose, facilitating human-readable explanations alongside machine-executable instructions.^[6] Pioneered conceptually by Donald Knuth's literate programming paradigm, modern notebook interfaces extend this idea into practical, web-based tools for exploratory and reproducible computing.^[6] Key characteristics of notebook interfaces include their cell-based structure, which separates content into distinct code cells for programming logic and text cells for documentation, allowing modular editing and execution.^[7] Execution occurs sequentially, with a computational kernel maintaining persistent state—such as variable values and data structures—across cells to support iterative development without restarting the environment.^[8] These interfaces support multiple programming languages by leveraging interchangeable kernels, enabling seamless switching between languages like Python, R, and Julia within the same document.^[9] Additionally, notebooks are designed for portability, with built-in export capabilities to static formats including PDF, HTML, and Markdown, preserving both code and rendered outputs for sharing and archiving.^[10] In contrast to traditional scripts, which consist of linear code files run in a single pass without embedded interactivity or visuals, or integrated development environments (IDEs) that prioritize comprehensive editing, debugging, and version control tools, notebook interfaces foreground narrative coherence, reproducibility through explicit execution histories, and multimedia integration to blend computation with storytelling.^[11] This distinction promotes workflows where results are immediately visible and contextualized, reducing the separation between analysis, documentation, and presentation.^[5] The term "notebook" originates from its deliberate analogy to physical laboratory notebooks used in scientific research, where observations, methods, and findings are recorded chronologically to capture the exploratory process and enable computational storytelling.^[11] For example, the Jupyter Notebook illustrates this paradigm as a widely adopted implementation.^[5]

Core components

The notebook interface is structured around cells as its fundamental units, which encapsulate content in a modular, sequential format to facilitate interactive document creation. Code cells contain executable snippets of code in a specified language, such as Python, and are designed to capture inputs and generate outputs upon execution. Markdown cells support formatted text using GitHub-flavored Markdown syntax, enabling the inclusion of headings, lists, links, and embedded media for documentation and narrative purposes. Raw cells store unprocessed content, such as plain text or data, which remains unmodified during rendering or conversion processes, often used for metadata or configuration that should not be interpreted by the interface.^[12] Notebook files, typically saved in the .ipynb extension, adopt a JSON-based format that organizes the document's structure and state. This includes top-level metadata such as the kernel specification (e.g., language name and version), notebook version details via nbformat and nbformat_minor fields, and a list of cells with their types, source content, and associated metadata like tags or collapse states. Cell-specific metadata can include execution counts for code cells and source formats for raw cells, while execution order is tracked implicitly through sequential cell indices and explicit counts in outputs to maintain reproducibility across sessions. This JSON schema ensures the file is human-readable and machine-parsable, supporting version control and programmatic manipulation.^[12]^[13] Outputs from code cells are rendered inline directly beneath the corresponding cell, integrating results seamlessly into the document flow. These outputs support rich media through MIME-type bundles, including text (e.g., plain or HTML), images (e.g., PNG or SVG formats), LaTeX equations for mathematical expressions, and interactive elements like widgets represented as JSON model states. For instance, a plotted graph or interactive slider appears embedded without requiring external viewers, enhancing the exploratory nature of the interface. This mechanism aligns with the literate programming paradigm by intertwining code, results, and explanations in a single, executable artifact.^[12]^[14] To aid navigation and organization in longer notebooks, markdown cells can define headings (e.g., using # for H1), which form the basis for hierarchical sections. Many implementations generate a dynamic table of contents from these headings, displayed in a sidebar for quick jumping between sections, with features like collapsible outlines and numbering for better structure. This promotes readability in complex documents, such as those used for data visualization reports.^[15] Standardization of the notebook format is advanced through specifications like Jupyter's NBFormat, which defines a backward-compatible evolution via minor version increments for new optional fields and major versions for breaking changes. This ensures interoperability across tools, allowing notebooks to be shared, converted (e.g., to HTML or PDF), and executed in diverse environments without loss of structure or content fidelity. The format's JSON foundation and schema validation further support ecosystem-wide adoption.^[12]^[16]

Historical development

Early origins

The rise of personal computing in the 1970s and 1980s, driven by affordable microcomputers like the Apple II and IBM PC, created demand for tools that integrated computation with documentation in scientific and engineering workflows, moving beyond batch processing to interactive environments.^[17] One early precursor was VisiCalc, released in 1979 by Dan Bricklin and Bob Frankston for the Apple II, which introduced interactive electronic spreadsheets allowing users to enter formulas that automatically recalculated across cells, simulating a dynamic computational notebook for financial and data analysis. This innovation influenced later interfaces by demonstrating the value of immediate feedback in mixed input-output documents.^[18] In the late 1980s, what-you-see-is-what-you-get (WYSIWYG) systems emerged to handle mathematical computations alongside text and graphics. Milo, developed by Ron Avitzur in 1987 for the Macintosh, provided a direct-manipulation interface for symbolic mathematics, blending editable equations with explanatory prose in a document-like format targeted at students.^[19] Similarly, Mathcad, first released in 1987 by MathSoft, offered WYSIWYG editing of numerical and symbolic expressions integrated with narrative text and plots, enabling engineers to create self-documenting worksheets.^[19] Mathematica, launched in 1988 by Wolfram Research, advanced this paradigm with its notebook interface for symbolic computation, featuring dynamic documents that combined input cells for code, immediate output rendering, and embedded text for literate programming-style explanations.^[20] In 1992, Maple V Release 2 from Waterloo Maple introduced worksheet interfaces that supported multiple computational kernels, allowing seamless integration of text, math, graphics, and execution across different mathematical domains within a single document.^[21] These developments laid the groundwork for modern notebook systems like Jupyter, emphasizing reproducible and interactive scientific computing.^[22]

Key milestones and modern advancements

The development of notebook interfaces gained momentum in the early 2000s with the creation of IPython in 2001 by Fernando Pérez, initially as an enhanced interactive shell for Python to facilitate exploratory computing and debugging. This project evolved to include a web-based notebook component by 2011, emphasizing literate programming and reproducible workflows. In 2014, Project Jupyter emerged as a spin-off from IPython, expanding support to multiple languages beyond Python through a decoupled architecture of kernels and frontends, enabling broader adoption in data science and scientific computing.^[23] Cloud-based and reactive notebook platforms marked further advancements in the mid-2010s. Wolfram Cloud, launched on June 23, 2014, introduced seamless browser access to interactive notebooks powered by the Wolfram Language, supporting dynamic computations and visualizations without local installations. Similarly, Observable, developed by Mike Bostock and others, debuted in 2017 with a focus on reactive, JavaScript-centric notebooks that automatically update outputs in response to code changes, revolutionizing data visualization and sharing in web environments.^[24] Post-2020 innovations addressed scalability, extensibility, and integration challenges in notebook ecosystems. JupyterLab, first released in beta in 2018 and reaching stable version 1.0 in June 2019, matured significantly with version 3.x releases by 2022 that introduced advanced theming, real-time collaboration, and a plugin system positioning it as a full-fledged extensible IDE alternative to traditional notebooks. The release of JupyterLab 4.0 in June 2023 further enhanced AI integration, debugging, and performance for large-scale workflows. The rise of AI-integrated notebooks accelerated in 2023, exemplified by Google Colab's addition of AI-powered code completions, natural language-to-code generation, and a dedicated coding chatbot, enhancing productivity for machine learning workflows directly in the browser.^[25] In 2024, JupyterAI was introduced, enabling generative AI capabilities like code generation and data analysis directly within notebooks using models such as Gemini and GPT. Concurrently, the Executable Books Project advanced standards for reproducible science through tools like MyST Markdown and Jupyter Book, enabling the creation of executable, publication-ready documents that integrate narratives with live code outputs.^[26] A shift toward web standards further democratized notebook execution. The adoption of HTML5 and WebAssembly enabled client-side computation, with Pyodide's 2020 releases allowing full Python environments—including libraries like NumPy and Pandas—to run natively in browsers without server dependencies, supporting offline and secure interactive applications.^[27] In June 2025, advancements in browser-based kernels extended support to interpreted C++ via Xeus-Cpp and LLVM in emscripten-forge, broadening language accessibility in web environments.^[28] Community-driven milestones solidified the ecosystem's sustainability. Project Jupyter has received fiscal sponsorship from NumFOCUS since the early 2010s, supporting open-source maintenance and events like the inaugural JupyterCon in 2017.^[29] In October 2024, Project Jupyter transitioned its fiscal sponsorship to LF Charities, enhancing funding mechanisms and community governance to sustain growth in data science and open-source innovation.^[30] By 2020, deep integration with Visual Studio Code via Microsoft's Jupyter extension enabled native notebook editing, debugging, and kernel management within the popular IDE, broadening accessibility for developers.^[31]

Technical architecture

Kernels and execution model

In notebook interfaces, a kernel is defined as a separate, independent process responsible for executing code in a specific programming language, interacting with the frontend through a standardized protocol to enable interactive computing.^[9] For example, the ipykernel provides Python support, while IRkernel handles R and IJulia supports Julia, allowing users to select language-appropriate execution environments.^[9] These kernels maintain isolation from the user interface, ensuring that computational tasks do not interfere with display or input handling.^[9] The execution model in notebook interfaces operates on a cell-by-cell basis, where each code cell is sent to the kernel for evaluation, and the kernel preserves a shared global state across executions to retain variables, functions, and data structures defined in prior cells.^[32] This persistent state facilitates iterative development, as outputs and modifications from one cell remain accessible in subsequent ones without reloading the entire environment.^[32] Sessions are restartable, enabling users to reset the kernel and clear all variables to a clean initial state, which is useful for troubleshooting or ensuring reproducibility. Communication between the frontend and kernel relies on a ZeroMQ-based messaging protocol, utilizing socket patterns such as ROUTER/DEALER for reliable transport and PUB/SUB for broadcasting outputs.^[33] Key request/response patterns include the execute_request for running code cells, returning an execute_reply with status, results, or errors; the complete_request for autocompletion suggestions based on partial code; and the inspect_request for retrieving documentation or type information at a cursor position.^[33] This asynchronous, message-driven architecture supports non-blocking interactions, allowing the frontend to handle multiple requests while the kernel processes computations.^[33] Multi-kernel support is achieved through kernel specifications (kernel specs), which are JSON files detailing the executable, language, and display names for each kernel, enabling dynamic selection and switching of languages within a notebook via a kernel selector interface.^[34] For instance, users can install kernels in isolated virtual environments using tools like conda or venv, ensuring dependency separation without affecting the base system.^[34] This modularity allows a single notebook to incorporate diverse languages, such as combining Python for data analysis with R for statistical modeling, by changing kernels mid-document.^[35] Error handling in the kernel involves capturing exceptions during execution and returning them via the messaging protocol in an execute_reply with status 'error', including the exception name, value, and a full traceback for inline display within the notebook cell.^[33] Tracebacks are rendered directly below the offending cell to provide immediate context, aiding rapid debugging without external tools.^[36] Supported kernels, such as ipykernel, integrate debugging hooks through libraries like debugpy, allowing breakpoints, step-through execution, and variable inspection via frontend debuggers when enabled.^[37]

Interactivity and output rendering

Notebook interfaces support interactive widgets that allow users to create dynamic user interfaces within documents, such as sliders, buttons, and dropdowns, facilitating real-time parameter adjustment and exploration of data or models. These widgets, exemplified by the ipywidgets library introduced in 2015, enable the embedding of controls like sliders for numeric inputs or buttons for triggering actions directly in notebook cells, promoting an interactive workflow where changes propagate immediately to downstream computations and visualizations.^[38] For instance, a slider can adjust a variable in a mathematical function, updating an associated plot in real time without rerunning the entire notebook. Output rendering in notebook interfaces relies on multi-format support through MIME types, allowing rich displays such as HTML for formatted text, SVG for scalable vector graphics, and JSON for structured data, which are automatically rendered in the frontend upon execution.^[39] This mechanism integrates seamlessly with visualization libraries like Matplotlib, where plots generated in code cells are displayed inline as interactive or static images, enhancing the interpretability of computational results without requiring external viewers.^[39] The rendering prioritizes the most suitable MIME type available, falling back to plain text if needed, to ensure compatibility across diverse output types. Versioning and collaboration features in modern notebook environments, such as JupyterLab, include real-time editing capabilities enabled by extensions like jupyter_collaboration, which synchronize changes across multiple users in a shared session. Additionally, Git integration via the jupyterlab-git extension supports versioning by allowing commits, branches, and pull requests directly within the interface, facilitating collaborative development while maintaining a history of notebook modifications.^[40] Accessibility in notebook interfaces incorporates keyboard navigation enhancements, where users can traverse elements like cells and menus using arrow keys and Tab, with Enter or Space for activation, as improved in JupyterLab 4.1 and Notebook 7.1.^[41] Screen reader compatibility is supported through WAI-ARIA attributes and HTML standards, enabling tools like VoiceOver or NVDA to interpret outputs and structures on compatible browsers, though community extensions may introduce inconsistencies. Export and sharing options utilize tools like nbconvert to convert notebooks to static formats such as HTML or PDF, preserving interactivity for widgets when widget state is explicitly stored during execution.^[42] For example, exporting with the --ExecutePreprocessor.store_widget_state=True flag embeds the final widget configurations into the output, allowing viewers to see interactive elements in a rendered HTML document without needing the full notebook environment.^[43] This approach balances portability with the retention of dynamic features for broader dissemination.^[42]

Applications and uses

In research and education

Notebook interfaces have become integral to research workflows, particularly as electronic lab notebooks for data analysis in fields like genomics. For instance, Bioconductor, an open-source project for analyzing genomic data, utilizes Jupyter notebooks to enable interactive exploration of high-throughput biological data, allowing researchers to integrate R code, visualizations, and documentation in a single document for streamlined analysis of gene expression and sequencing results.^[44] This approach supports reproducible computational workflows, exemplified by Binder, introduced in 2016, which allows sharing of executable notebook environments via cloud-based instantiation of dependencies, ensuring that collaborators can run analyses without local setup issues.^[45] In educational settings, notebook interfaces facilitate teaching computational thinking by combining code execution with explanatory text and outputs, as advocated by Stephen Wolfram in 2016 for using Wolfram Language notebooks to build problem-solving skills across disciplines. Platforms like DataCamp incorporate interactive notebook-style tutorials to guide learners through data manipulation and visualization, enabling hands-on practice in programming concepts without requiring separate environments.^[46]^[47] Case studies highlight widespread adoption in specific domains. Similarly, in statistics courses, universities like UC Berkeley employ Jupyter for large-enrollment classes, where notebooks structure lessons on hypothesis testing and regression analysis, promoting active learning through embedded datasets and auto-graded exercises.^[48] To uphold reproducibility standards, notebook interfaces often integrate with containerization tools like Docker, which captures the full computational environment—including libraries and system configurations—enabling precise replication of research pipelines without dependency conflicts.^[49] Surveys indicate high adoption in data science curricula, with approximately 70% of professionals using Jupyter notebooks for core tasks like exploratory analysis by 2023, reflecting their entrenched role in academic training.^[50]

In industry and development

Notebook interfaces have become integral to data science pipelines in industry, particularly for prototyping machine learning models. In platforms like Kaggle, these interfaces enable rapid experimentation and iterative development during competitions, allowing data scientists to test algorithms on large datasets in a collaborative, cloud-based environment.^[51] This approach supports the full lifecycle of model development, from data exploration to validation, fostering reproducibility and version control essential for team-based projects.^[52] Integration with extract, transform, and load (ETL) tools further enhances their utility in industrial workflows. For instance, notebook interfaces connect seamlessly with Apache Spark, enabling distributed data processing for large-scale ETL operations directly within interactive sessions.^[53] This allows practitioners to prototype data transformations and pipelines interactively before deploying them in production environments.^[54] In software development, particularly within DevOps practices, notebook interfaces facilitate exploratory coding for big data applications. Databricks notebooks, for example, support collaborative development of data pipelines, incorporating version control and testing to align with agile methodologies.^[55] These tools enable developers to iterate on code for data-intensive tasks, such as processing petabyte-scale datasets, while maintaining integration with CI/CD processes.^[56] For business intelligence, notebook interfaces power hybrid solutions that combine scripting with visualization tools. Tableau's integration with Python via TabPy allows users to embed custom scripts within flows for advanced analytics and automated reporting.^[57] This enables the creation of dynamic dashboards that incorporate machine learning predictions or complex data manipulations, streamlining the transition from analysis to actionable insights.^[58] Enterprise adoption of notebook interfaces has been driven by scalable cloud services, with AWS SageMaker, launched in 2017, providing managed Jupyter environments that handle training and deployment at scale for thousands of users.^[59] These platforms support horizontal scaling across GPU clusters, reducing infrastructure overhead for industrial ML workflows. Security considerations are paramount in such deployments, including kernel isolation to prevent unauthorized code execution and data exfiltration.^[60] In Databricks, enhanced security features like workspace-level access controls and encryption ensure compliance in multi-tenant environments.^[61] Recent trends indicate widespread enterprise use of notebook interfaces for AI prototyping, accelerating development cycles amid rising generative AI investments. For example, the Jupyter AI extension, released in 2023, integrates generative AI models directly into notebooks, enabling code generation, error fixing, and data summarization to enhance productivity in AI workflows.^[62] By 2024, 78% of respondents working in software development reported using generative AI tools.^[63]

Benefits and limitations

Advantages

Notebook interfaces offer significant advantages in reproducibility by encapsulating code, execution results, and explanatory text within a single, self-contained document, which minimizes environment-specific issues often summarized as "it works on my machine." This structure allows users to lock dependencies explicitly, such as through environment files like Conda’s environment.yml or pip’s requirements.txt, ensuring that analyses can be rerun consistently across different systems without unexpected variations due to software versions or configurations.^[64] The interactivity of notebook interfaces enables rapid iteration on experiments through live outputs and cell-based execution, where users can modify and rerun individual code blocks incrementally to test hypotheses and visualize changes immediately. This approach supports faster prototyping in data analysis and development workflows, as evidenced by studies showing that notebooks facilitate quick adjustments and real-time feedback, enhancing exploratory processes compared to traditional script-based programming.^[65] Accessibility is a key strength, as notebook interfaces lower barriers for non-programmers by integrating narrative text with executable code, allowing domain experts to engage with computational tasks without deep programming knowledge. They support diverse programming languages via interchangeable kernels, enabling users from various fields to incorporate tools like Python, R, or Julia seamlessly into a unified document, thus broadening participation in technical workflows.^[66] Collaboration benefits from the shareable, document-like format of notebooks, which can be distributed easily for team reviews and joint editing, akin to collaborative tools like Google Docs but tailored for code and outputs. Synchronous editing features create shared contexts that encourage exploration and reduce communication overhead, with research indicating that teams using such interfaces explore more alternatives, though balanced participation may require strategic coordination to avoid interference during pair authoring sessions.^[67] Empirical evidence underscores these advantages in educational settings, particularly in STEM fields, where a 2022 study on engineering undergraduates using computational notebooks for data science concepts like K-means clustering found that approximately 89% of participants reported improved understanding through integrated visualizations, with 75% accurately identifying key algorithmic goals such as creating groups by minimizing distances to centroids. Surveys and reflections in this context highlight enhanced engagement and accurate grasp of algorithmic goals, demonstrating notebooks' role in fostering deeper learning outcomes.^[68]

Challenges and criticisms

Notebook interfaces, while popular for interactive computing, face significant reproducibility challenges due to unversioned environments that lead to "dependency hell," where conflicting package versions and installation issues prevent consistent execution across different machines or over time.^[69]^[70] Additionally, non-deterministic outputs arise in parallel execution scenarios, such as when using libraries like joblib for concurrent tasks, where the order of results depends on worker concurrency and can vary across runs, complicating verification of computational results.^[71] Maintainability issues stem from the "notebook smell" phenomenon, where code becomes tangled across cells with mixed narrative, exploration, and logic, making refactoring difficult and leading to brittle structures that resist modularization or reuse. This is exacerbated by practices akin to "YOLO programming," a 2017 critique highlighting reckless, exploratory coding styles in notebooks that prioritize quick iteration over structured development, resulting in unmaintainable artifacts unsuitable for long-term evolution.^[72] Performance limitations include substantial overhead in large-scale computations, as the interactive kernel and cell-based execution introduce latency compared to traditional scripts, particularly for iterative or distributed workloads.^[73] Version control with tools like Git is hindered by binary outputs embedded in notebook files, which bloat repositories, complicate diffs, and prevent meaningful merges without manual clearing of results.^[74] Security risks are prominent due to arbitrary code execution in shared kernels, enabling potential exploitation; for instance, CVE-2023-49080 in Jupyter Server exposed sensitive path information in error responses to authenticated users, highlighting risks of information disclosure in notebook environments.^[75] Recent analyses as of 2024 show that the number of security vulnerabilities reported for Jupyter notebooks has doubled compared to 2023, underscoring ongoing risks in deployment.^[76] Misconfigurations in deployed servers further expose systems to root-level privileges on Linux environments.^[77] Critics argue that notebooks are not software in the traditional sense, lacking the rigor for production deployment as they blend ad-hoc experimentation with executable code, leading to unreliable pipelines that require complete rewrites for scalability.^[78]

Notable implementations

Open-source examples

One of the most prominent open-source notebook implementations is Jupyter Notebook and its successor interface, JupyterLab. Jupyter Notebook, initially released in 2014 as an evolution from the IPython project, supports over 40 programming languages through interchangeable kernels, enabling interactive computing in environments like Python, R, and Julia.^[1] JupyterLab, released in 2018, extends this with a flexible, modular interface that includes a rich ecosystem of extensions for tasks such as version control integration, variable inspection, and theme customization, fostering widespread adoption in data science workflows. R Markdown and its successor Quarto represent key open-source tools emphasizing literate programming, particularly for R users. R Markdown, developed by RStudio and released in 2012, allows seamless integration of R code, results, and narrative text to produce dynamic documents in formats like HTML, PDF, and Word.^[79] Quarto, released in 2022 as a multi-language extension of R Markdown, enhances this with support for Python, Julia, and Observable JavaScript, enabling multi-format publishing—including websites, books, and presentations—while maintaining reproducibility through executable code chunks. Polynote, developed and open-sourced by Netflix in 2019, focuses on Scala and Java for big data applications, integrating natively with Apache Spark to provide runtime insights like symbol tables and error highlighting across polyglot notebooks.^[80] Its design supports mixing languages such as Scala, Python, and SQL in a single notebook, with shared data structures and advanced editing features like autocomplete, making it suitable for large-scale data processing at organizations handling petabyte-scale datasets.^[81] nteract, first released in 2017, offers a desktop application built with React for offline notebook execution and editing, compatible with Jupyter formats and emphasizing portability across platforms without requiring a server.^[82] It includes libraries for headless notebook management and reporting, allowing users to run interactive computations locally while supporting extensions for visualization and collaboration. The open-source notebook community thrives on collaborative governance, exemplified by Project Jupyter, which operates under a neutral foundation with steering council oversight and has amassed numerous contributors across its core GitHub repositories as of 2025, driving continuous enhancements through community proposals and hackathons.

Proprietary and commercial examples

One prominent proprietary notebook interface is Wolfram Notebooks, part of Mathematica, which has supported symbolic computation since its introduction in 1988 as the primary interface for version 1.0.^[83] These notebooks enable interactive documents that integrate executable code, rich text, and dynamic visualizations, with symbolic manipulation allowing algebraic and mathematical expressions to be handled analytically alongside numerical results.^[84] Cloud integration via the Wolfram Cloud facilitates seamless sharing, deployment, and computation in a hybrid desktop-cloud environment, enhancing accessibility for enterprise users.^[85] A key feature is Dynamic content, which supports real-time updating elements like interactive controls and autoupdating outputs within notebooks, improving interactivity for complex workflows.^[86] MATLAB Live Scripts, introduced in 2016 with MATLAB R2016a, represent a commercial notebook system optimized for numerical computing and engineering applications.^[87] These scripts combine executable MATLAB code with formatted text, equations, images, and outputs in an interactive executable document, focusing on high-performance numerical simulations and data analysis.^[88] Deep integration with MathWorks toolboxes—such as Signal Processing Toolbox or Parallel Computing Toolbox—allows users to leverage specialized functions for tasks like signal analysis or distributed computing directly within the notebook environment, streamlining development for technical professionals.^[89] Enterprise features include version control compatibility and sharing options, making Live Scripts suitable for collaborative team-based projects in industries like aerospace and automotive. Databricks Notebooks provide a proprietary platform tailored for big data processing, built on Apache Spark and optimized for distributed computing at scale. These notebooks support real-time coauthoring in languages like Python, Scala, R, and SQL, with automatic versioning and built-in visualizations to facilitate rapid iteration on large datasets.^[90] Designed for enterprise environments, they integrate natively with cloud providers such as Azure and AWS, enabling collaborative workflows where multiple users can edit and execute code simultaneously while managing Spark clusters for efficient big data analytics.^[91] Security and governance features, including role-based access control, ensure compliance in production settings for data engineering and machine learning pipelines. SAS Studio offers a web-based, analytics-focused notebook interface with proprietary extensions for enterprise data analysis. It provides an intuitive environment for writing and executing SAS code, emphasizing statistical modeling and business intelligence tasks through interactive code execution and results viewing.^[92] Visual programming is supported via built-in tasks—point-and-click wizards that generate SAS code for common operations like data ranking, correlation analysis, or chart creation—reducing the need for manual coding in complex analytics workflows.^[93] Enterprise security is a core strength, with features like secure file system access, authentication integration, and data privacy controls to protect sensitive information in regulated industries such as finance and healthcare.^[94] Recent evolutions in these systems highlight ongoing enhancements for AI and collaboration; for instance, Wolfram Notebooks in Mathematica 14 (released in 2024) introduced AI-powered features like improved natural language input and generative tools for code and visualization assistance, building on their foundational dynamic capabilities.^[95]

References

[1]
Jupyter Notebook
The Jupyter Notebook is a web-based interactive computing platform. The notebook combines live code, equations, narrative text, visualizations, ...
[2]
Computational Notebook - Martin Fowler
Nov 18, 2020 · A computational notebook is an environment for writing a prose document that allows the author to embed code which can be easily executed with the results also ...Missing: interface | Show results with:interface
[3]
The Past, Present, And Future of The Data Science Notebook
Jul 7, 2022 · This article looks at the past, present, and future of data science notebooks, from their original development to exciting new innovations.
[4]
[CP-05-027] GIS&T and Computational Notebooks
To digitally emulate the benefits of traditional lab notebooks, Mathematica first developed the computational notebook interface in the 1980s as a closed source ...
[5]
The Jupyter Notebook — IPython
It is an interactive computational environment, in which you can combine code execution, rich text, mathematics, plots and rich media.
[6]
[PDF] Literate Programming - Department of Computer Science
My original idea was that WEB would be merely a tool for documentation, but submitted to THE COMPUTER JOURNAL 11. Page 12. D. E. KNUTH. I actually found that my ...
[7]
Introduction - Jupyter Notebook Documentation - Read the Docs
Notebook documents contains the inputs and outputs of a interactive session as well as additional text that accompanies the code but is not meant for execution.User interface components · Configuration · Jupyter
[8]
What is Jupyter Notebook? Why It's essential for AI and data science
Sep 15, 2025 · Jupyter Notebook is a browser-based tool for interactive coding, data exploration and documentation. It lets you run code step by step while ...
[9]
Kernels (Programming Languages) - Jupyter Documentation
Kernels are programming language specific processes that run independently and interact with the Jupyter Applications and their user interfaces.Missing: state persistence
[10]
Exporting Notebooks — JupyterLab 4.4.10 documentation
JupyterLab allows you to export your jupyter notebook files ( .ipynb ) into other file formats such as: Asciidoc .asciidoc. HTML .html. LaTeX .tex. Markdown .md.
[11]
4.3. Jupyter Notebooks — How to Think Like a Data Scientist
The interface is a virtual environment that resembles a real-life research notebook. A form of literate programming, a Jupyter Notebook allows for the ...
[12]
The Notebook file format — nbformat 5.10 documentation
Cell Types#. There are a few basic cell types for encapsulating code and text. All cells have the following basic structure: { "cell_type": "type", "metadata ...Missing: components | Show results with:components
[13]
https://github.com/jupyter/nbformat/blob/master/nbformat/v4/nbformat.v4.schema.json
[14]
https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data
[15]
Table Of Contents — JupyterLab 4.5.0rc0 documentation
In the sidebar panel, you can number headings, collapse sections, and navigate into the file. Here is an animation showing the table of content use with a ...
[16]
https://github.com/jupyter/enhancement-proposals/blob/master/62-cell-id/cell-id.md
[17]
1970s - Early 1980s | Selling the Computer Revolution
The early 1980s saw the first mass market advertising of computers. Computers were available for personal use due to the diminishing costs of machines.Missing: integrated | Show results with:integrated
[18]
A vision of computing's future - Harvard Gazette
Mar 22, 2012 · In 1978, while a student at Harvard Business School, Dan Bricklin conceived of VisiCalc, the first electronic spreadsheet program for personal ...
[19]
[PDF] A Survey of User Interfaces for Computer Algebra Systems
Mathematical assistants like Milo or Theorist achieve direct manipulation by mixing the editing and the simplification process within a single software ...
[20]
The Mathematica Story: A Scrapbook - Wolfram
Celebrating Mathematica's launch three decades ago. Stephen Wolfram shares his thoughts on the anniversary. Visual history shows Mathematica's evolution.
[21]
Maple Product History - Maplesoft
Maple gets better every year. See the history of improvements and features that were added to earlier releases of Maple.Missing: 1992 | Show results with:1992
[22]
The New World of Notebook Publishing - Stephen Wolfram Writings
Oct 24, 2019 · We invented notebooks in 1988 as the main interface for Mathematica Version 1.0, and over the past three decades, many millions of Wolfram ...Missing: introduction | Show results with:introduction
[23]
Project Jupyter | About Us
Project Jupyter is a non-profit, open-source project, born out of the IPython Project in 2014 as it evolved to support interactive data science and scientific ...Missing: history | Show results with:history
[24]
Our mission and our values | Observable
### Summary of Observable Launch Date and Description (2017 Milestones)
[25]
New AI coding features are coming to Google Colab - The Keyword
May 17, 2023 · We're announcing that Colab will soon add AI coding features like code completions, natural language to code generation and even a code-assisting chatbot.Missing: enhancements | Show results with:enhancements
[26]
The Executable Books Project
An international collaboration to build open source tools that facilitate publishing computational narratives using the Jupyter ecosystem.
[27]
What is Pyodide? — Version 0.29.0
Pyodide was created in 2018 by Michael Droettboom at Mozilla as part of the Iodide project. Iodide is an experimental web-based notebook environment for ...
[28]
[PDF] NumFOCUS Annual Report 2017
Mar 23, 2018 · Jupyter. 2017 was a year of exciting growth within the Jupyter community. One of the highlights was JupyterCon, our first international user ...
[29]
Python in Visual Studio Code – January 2020 Release
Jan 7, 2020 · This release includes many improvements to the performance of Jupyter in VS Code in both the Notebook editor and the Interactive Window.<|control11|><|separator|>
[30]
What is Jupyter?
Jupyter is a large umbrella project that covers many different software offerings and tools. That includes Jupyter Notebook and JupyterLab, which are both ...What Is A ``computational... · How Do The Jupyter... · A (partial) Tour Of The...
[31]
Messaging in Jupyter — jupyter_client 8.6.3 documentation
This document explains the basic communications design and messaging specification for how Jupyter frontends and kernels communicate. The ZeroMQ library ...
[32]
Manage Jupyter Kernels in VS Code
Descriptions of kernel selection options and tutorials on managing different types of kernels when working with Jupyter Notebooks in Visual Studio Code.
[33]
Making kernels for Jupyter — jupyter_client 8.6.3 documentation
You can use the xeus library that is a C++ implementation of the Jupyter kernel protocol. Kernel authors only need to implement the language-specific logic in ...Missing: support | Show results with:support
[34]
What to do when things go wrong - Jupyter Notebook Documentation
If Jupyter gives an error that it can't find ... These issues are usually evident by carefully analyzing the traceback produced in the notebook error or the ...
[35]
Debugger — JupyterLab 4.4.10 documentation
For the debugger to be enabled and visible, a kernel with support for debugging is required. Here is a list of kernels that are known to be supporting the ...
[36]
jupyter-widgets/ipywidgets: Interactive Widgets for the ... - GitHub
ipywidgets, also known as jupyter-widgets or simply widgets, are interactive HTML widgets for Jupyter notebooks and the IPython kernel.
[37]
Custom mimetypes (MIME types) - Jupyter Documentation
A mimetype, also referred to as MIME type, identifies how the content that is being returned should be handled or used, based on type, by the application and ...
[38]
A Git extension for JupyterLab - GitHub
If you would like to contribute to the project, please read our contributor documentation. JupyterLab follows the official Jupyter Code of Conduct. Development ...Issues 114 · Security · Discussions · Actions
[39]
Recent keyboard navigation improvements in Jupyter
Dec 16, 2023 · A recent audit of the JupyterLab UI highlighted significant gaps in keyboard navigation, posing obstacles to usability and accessibility.Keyboard Navigation In... · Future Accessibility... · Acknowledgments
[40]
nbconvert: Convert Notebooks to other formats — nbconvert 7.16.6 documentation
### Summary of nbconvert Tool
[41]
Jupyter Ipywidgets & Static Pages - nbconvert
Jan 22, 2020 · I am trying to generate a static page with interactive elements from a Jupyter Notebook. I am able to use nbconvert to export an HTML version of a Jupyter ...
[42]
Reproducible Bioconductor workflows using browser-based ... - NIH
We present four different interactive Jupyter notebooks using R and Bioconductor workflows to infer differential gene expression, analyze cross-platform ...
[43]
[PDF] Jupyter Notebooks—a publishing format for reproducible ...
By pointing the Binder web service at the repository, a temporary environment is automatically created with the notebooks and any libraries and data required to ...
[44]
How to Teach Computational Thinking - Stephen Wolfram Writings
Sep 7, 2016 · Stephen Wolfram explains the importance of educating students to think computationally and how knowledge-based Wolfram Language is the first ...What Is Computational Thinking? · Nuts and Bolts · Where Does Computational...Missing: advocacy | Show results with:advocacy
[45]
How to Use Jupyter Notebooks: The Ultimate Guide - DataCamp
Mar 10, 2023 · Jupyter Notebooks are documents for technical and data science content. This tutorial provides an overview of Jupyter notebooks, their components, and how to ...
[46]
Chapter 7 Usage case studies | Teaching and Learning with Jupyter
7.1 Jupyter notebooks in support of scaling for large enrollments. 7.1.1 Supporting large enrollment courses at UC Berkeley. The University of California at ...Missing: statistics | Show results with:statistics
[47]
Reproducible Jupyter Notebooks with Docker - General
Oct 23, 2019 · Reproducible Jupyter Notebooks with Docker. Reproducing the computational steps in your own or somebody else's notebook is fraught with perils.Missing: integration | Show results with:integration
[48]
Data Science - The State of Developer Ecosystem in 2023 Infographic
Approximately 40% of data science professionals use Jupyter notebooks to present their work results, but, interestingly, many (almost 50%) spend only 10%–20% of ...
[49]
How to use Kaggle Notebooks
Explore and run machine learning code with Kaggle Notebooks, a cloud computational environment that enables reproducible and collaborative analysis.
[50]
Gallery of the best notebooks for ML and Data Science TOP 25
Gallery of the best notebooks for ML and Data Science TOP 25 · 1) An introductory notebook on uncertainty quantification and sensitivity analysis - https:// ...
[51]
How to Use Jupyter Notebooks With Apache Spark - BMC Software
Nov 8, 2024 · Use Apache Spark in Jupyter Notebook for interactive analysis of data. This guide covers setup, configuration, and tips for running Spark ...
[52]
Build an ETL pipeline with Apache Spark on the Databricks platform
Apr 3, 2025 · This tutorial shows you how to develop and deploy your first ETL (extract, transform, and load) pipeline for data orchestration with Apache Spark.
[53]
Software Engineering Best Practices With Databricks Notebooks
Jun 25, 2022 · Learn best practices for software engineering with Databricks Notebooks, focusing on collaboration, version control, and reproducibility.
[54]
DevOps for Delta Live Tables | Databricks Blog
Apr 28, 2023 · Apply software development and DevOps best practices to Delta Live Table pipelines on Databricks for reliable, scalable data engineering ...
[55]
Use Python scripts in your flow - Tableau Help
To include Python scripts in your flow, you need to configure a connection between Tableau and a TabPy server. Then you can use Python scripts to apply ...Prerequisites · Create Your Python Script · Connect To Your Tableau...
[56]
How to build advanced analytics applications with TabPy - Tableau
Jan 24, 2017 · TabPy makes it possible to use Python scripts in Tableau calculated fields. When you pair Python's machine-learning capabilities with the ...<|separator|>
[57]
Amazon SageMaker Named as the Outright Leader in Enterprise ...
Jun 9, 2021 · In November 2017, we launched Amazon SageMaker to help ML Engineers and Data Scientists not only build the best models, but also operate them efficiently.
[58]
Evaluating the Security of Jupyter Environments - NVIDIA Developer
Feb 13, 2023 · The NVIDIA AI Red Team has developed a JupyterLab extension called jupysec to automatically assess the security of Jupyter environments.Missing: sandboxing | Show results with:sandboxing
[59]
Security best practices for the Databricks Data Intelligence Platform
Sep 18, 2024 · The Databricks Data Intelligence Platform provides an enterprise-grade defense-in-depth approach for protecting data and AI assets. For ...
[60]
State of Generative AI in the Enterprise 2024 | Deloitte US
The State of Generative AI in the Enterprise. 2024 year-end Generative AI report. Explore the complete findings—including Q4 results—from the Deloitte AI ...Missing: notebooks prototyping
[61]
Enterprise Generative AI in 2024: The future of work | Altman Solon
Today, 78% of respondents working in software development cite using generative AI tools, up from 23% in 2023. This rapid adoption suggests that generative AI ...
[62]
[PDF] Ten Simple Rules for Reproducible Research in Jupyter Notebooks
Oct 4, 2018 · Jupyter Notebooks lower many barriers to reproducibility and were designed to support reproducible research by enabling scientists to craft ...
[63]
What Makes a Well-Documented Notebook? A Case Study of Data ...
May 8, 2021 · ... notebook can weave code and documentation together (computational narrative), and support rapid iteration on code experiments. However, it ...
[64]
[PDF] From Computational to Conversational Notebooks - arXiv
Jun 15, 2024 · As mentioned, both conversational interfaces and computational notebooks are means of making programming more accessible. Therefore, one.<|control11|><|separator|>
[65]
How Data Scientists Use Computational Notebooks for Real-Time ...
Computational notebooks give data scientists a convenient interactive solution for sharing and keeping track of the data exploration process.
[66]
Data science knowledge integration: Affordances of a computational ...
Oct 30, 2022 · Computational notebooks have been used extensively with different learning goals [5, 44, 53]. Preliminary results suggest that students find ...
[67]
Making Jupyter Notebooks Reproducible with ReproZip
However, Jupyter Notebooks are subject to dependency hell like any other application – just the Notebook is not enough for full reproducibility. We have ...Missing: issues | Show results with:issues
[68]
Creating Reproducible and Interactive Analyses with JupyterLab ...
May 6, 2019 · ... Reproducibility. 1. Dependency hell –installation and versioning issues. 2. Imprecise documentation –can be overly complex,. incorrect, or not ...
[69]
Embarrassingly parallel for loops — joblib 1.6.dev0 documentation
In this case the order of the outputs depends on the concurrency of workers and is not deterministic, meaning the results can be yielded with a different order ...
[70]
Structure, Coding Style, and Refactoring Jupyter Notebooks
Jul 1, 2020 · Second of all, we can always use metrics for non-deterministic workloads - think to measure the F1 score after fitting a binary classifier. The ...
[71]
Scaling Notebooks as Re-configurable Cloud Workflows
Apr 1, 2022 · The approach must provide scalable solutions for large-scale scientific experimental analysis, especially for large datasets or complicated ...
[72]
How to Version Control Jupyter Notebooks - Nextjournal
The simplest solution is to always clear the output before committing. Cell → All Output → Clear → Save. This removes any binary blobs that have been generated ...
[73]
CVE-2023-49080 Detail - NVD
Dec 4, 2023 · ... arbitrary execution permissions already in the same environment. A fix has been introduced in commit `0056c3aa52` which no longer includes ...Missing: code | Show results with:code
[74]
https://nextjournal.com/schmudde/how-to-version-control-jupyter
[75]
Don't put data science notebooks into production - Martin Fowler
Putting a notebook into a production pipeline effectively puts all the experimental code into the production code base. Much of that code isn't relevant to the ...
[76]
Polynote: Home
Polynote is a different kind of notebook. It supports mixing multiple languages in one notebook, and sharing data between them seamlessly.Using Polynote with Python · Using Polynote with Spark · Code Cells · Installation
[77]
GitHub - polynote/polynote: A better notebook for Scala (and more)
- **Unique Features**:
[78]
nteract: write your next code-driven story.
The nteract ecosystem provides a set of libraries for headlessly executing notebooks, managing your team's notebooks, using notebooks for reporting and more.Kernels · Nteract · Core SDK · LibrariesMissing: features React offline
[79]
The New World of Notebook Publishing - Stephen Wolfram Writings
Oct 24, 2019 · The Story of Notebooks We invented notebooks in 1988 as the main interface for Mathematica Version 1.0, and over the past three decades, many ...
[80]
Symbolic Computation - Wolfram Video Archive
Sep 19, 2019 · One of the important features of Mathematica is that it can do symbolic, as well as numerical, calculations. This means it can handle algebraic formulas as well ...Missing: history 1988 Dynamic
[81]
Wolfram Mathematica: Modern Technical Computing
Mathematica uses the Wolfram Notebook Interface, which allows you to organize everything you do in rich documents that include text, runnable code, dynamic ...Mathematica Pricing · Download a Free Trial · Mathematica Resources
[82]
Put Autoupdating Dynamic Content in a Notebook
Notebooks can contain dynamic content that updates automatically. Put the content that you want to autoupdate inside Dynamic and specify an UpdateInterval:
[83]
A Brief History of MATLAB - MathWorks
Live Editor. The Live Editor was introduced in 2016 and is still evolving rapidly. Descriptive text and MATLAB input, output, and graphics are combined in a ...Missing: integration | Show results with:integration
[84]
Live Scripts and Functions - MATLAB & Simulink - MathWorks
MATLAB live scripts and live functions are interactive documents that combine MATLAB code with embedded output, formatted text, equations, and images in a ...<|control11|><|separator|>
[85]
Create Live Scripts in the Live Editor - MATLAB & Simulink
To create a live script in the Live Editor, go to the Home tab and click New Live Script. You also can use the edit function in the Command Window.
[86]
Databricks notebooks | Databricks on AWS
Sep 3, 2025 · Databricks notebooks provide real-time coauthoring in multiple languages, automatic versioning, and built-in data visualizations for developing code and ...
[87]
Azure Databricks
Azure Databricks is a fast, easy, and collaborative Apache Spark-based data and AI platform optimized for Microsoft Azure. It provides a unified environment for ...Missing: AWS | Show results with:AWS
[88]
SAS Studio
SAS Studio provides a web browser-based programming environment so writing and interacting with your SAS code has never been easier or faster, wherever you ...Missing: features | Show results with:features
[89]
Overview of SAS Studio Tasks
Dec 15, 2021 · For example, tasks enable users to create a bar chart, run a correlation analysis, or rank data. When a user selects a task option, SAS code is ...Missing: visual | Show results with:visual
[90]
Overview of Security in SAS Studio
Apr 24, 2025 · This support includes the ability to read and write from file systems, save their work locally, import code, analyze data sets, and ...
[91]
New in 14: Notebooks & User Interface - Wolfram Blog
Jan 16, 2024 · We first introduced Wolfram Notebooks with Version 1.0 of Mathematica, in 1988. And ever since then, we've been progressively polishing the ...