livebook-dev/livebook

Livebook is an interactive Elixir notebook application that enables users to write, execute, and share code across multiple languages including Elixir, Python, and Erlang. It provides a collaborative web interface with real-time editing, intellisense, and rich media outputs, supporting persistent deployment of notebooks as standalone web applications. The system manages data through local, Git, and S3 storage backends and facilitates team collaboration via a dedicated Teams hub with Zero Trust authentication.

50 changes.

This period marks the initial release of Livebook v0.20 as a standalone web application, featuring a complete migration to Phoenix LiveView, Vite, and Tailwind CSS. The work established the core notebook architecture, including persistent app deployments, multiple runtime backends, and Git/S3 file system support. Comprehensive test coverage was added to validate the new web layer, session synchronization, and collaboration features.

41 changes.

This period focused on establishing the core infrastructure for Livebook Teams, including a unified Hub abstraction, Protobuf-based WebSocket communication, and deployment group management for distributed environments. Concurrently, the project introduced a standalone desktop application via Tauri, enhanced the iframe widget runtime for security and capability, and modernized the frontend with CodeMirror 6 and Phoenix 1.8.

23 changes.

This period focused on building foundational infrastructure for real-time collaborative editing, including a CodeMirror 6 migration and operational transformation backend. It also introduced comprehensive intellisense support for Elixir and Python, alongside new capabilities for permanent app deployment, Kubernetes runtime, and Git-based file storage.

A new Ecto type, Livebook.EctoTypes.HexColor, has been introduced to handle hex color values. This type validates that input strings conform to the standard six-digit hexadecimal format (e.g., \#112233) and provides a utility function to generate random valid hex colors, allowing users to exclude specific colors from the selection.

_lib/livebook/ecto\types · high confidence

Introduced a new set of modules in the \lib/livebook/text\ directory to support collaborative editing features. This includes \Livebook.Text.Delta\ for representing and compacting text changes, \Livebook.Text.Delta.Transformation\ for resolving conflicts between concurrent edits using Operational Transformation, \Livebook.Text.JS\ for handling string lengths and offsets consistent with JavaScript's UTF-16 encoding, and \Livebook.Text.Selection\ for managing and transforming text selections. These components form the backend foundation for real-time collaboration in the code editor.

lib/livebook/text · high confidence

Users can now export Livebook notebooks as standalone Elixir source files (.exs). The new \Livebook.Notebook.Export.Elixir\ module converts notebook sections and cells into valid Elixir code, including a prelude for running via \iex\. It handles various cell types: Markdown cells are converted to comments, Python and pyproject.toml cells are embedded as string literals within Elixir sigils or blocks, and code cells are preserved as executable Elixir code (with parent section code commented out if nested). This allows notebooks to be shared, version-controlled, or run directly as Elixir scripts.

lib/livebook/notebook/export · high confidence

This change introduces the first native desktop application for Livebook, built on the Tauri framework. It provides platform-specific installers for macOS (DMG), Windows (NSIS), and Linux (AppImage), along with built-in automatic updates via GitHub releases. The application integrates with the operating system by registering file associations for .livemd files, supporting deep links via the livebook:// scheme, and providing a system tray for quick access to notebook actions. It also includes proper code signing configurations for Windows and macOS entitlements for camera and microphone access.

rel/app/src-tauri · high confidence

This entry marks the initial release of Livebook v0.20, introducing the project as a standalone web application for interactive Elixir notebooks. The release includes a new Dockerfile supporting both default and CUDA variants, enabling containerized deployment with health checks and configurable ports. The project has moved to the Apache 2.0 license, replacing previous terms. Configuration is now managed via environment variables (e.g., LIVEBOOK\_IP, LIVEBOOK\_HOME) and the code editor has been migrated to CodeMirror for improved autocompletion and documentation support. The formatter configuration has been updated to include Ecto and HEEx files, and the changelog has been rewritten to follow the Keep a Changelog format.

(repo-wide) · high confidence

Livebook now supports Git repositories as a persistent file storage backend, allowing users to connect to a Git repo (specifying URL, branch, and authentication key) to read and stream notebook files. This change introduces a new \Livebook.FileSystem.Git\ module and updates the core file system abstraction (\Livebook.FileSystem.File\, \Livebook.FileSystem.Mounter\) to handle mounting, unmounting, and event-driven lifecycle management for these new global file systems alongside existing local and S3 backends. The local file system implementation has also been updated to use synchronous writes and handle cross-partition copies more robustly.

_lib/livebook/file\system · high confidence

Livebook now supports storing notebooks and files in a Git repository. This change adds a new \Livebook.FileSystem.Git.Client\ module that handles cloning bare repositories, fetching branches, and reading file contents via Git commands. It enables users to sync their Livebook data with a remote Git source, including support for SSH key authentication to access private repositories.

_lib/livebook/file\system/git · high confidence

The \lib/livebook/hubs\ directory now implements a unified Hubs architecture that replaces the previous local-only storage model. This change introduces a \Livebook.Hubs.Provider\ protocol to standardize interactions with hub backends, with concrete implementations for \Personal\ hubs (local storage for secrets and file systems) and \Team\ hubs (remote synchronization via WebSocket using \TeamClient\). The new structure includes \Broadcasts\ for pub/sub events (CRUD, connection status, secrets, file systems), \Dockerfile\ generation logic for app deployments, and \Metadata\ handling. This refactoring enables Livebook to manage secrets, file systems, and deployment configurations across both local and team-based environments.

lib/livebook/hubs · high confidence

Livebook now supports running notebooks on Kubernetes clusters. This change adds the core infrastructure for the K8s runtime, including modules to define and validate Pod manifests (with support for custom image registries, environment variables, and PVC mounting) and to generate PersistentVolumeClaim manifests for persistent storage.

lib/livebook/k8s · high confidence

Livebook now supports saving and loading notebooks as standard Markdown files (\.livemd\) via the new \LiveMarkdown\ module. This feature allows users to export notebooks to a human-readable format that preserves structure, code cells, and metadata, and import them back into Livebook. The implementation includes helpers for parsing and rendering Markdown ASTs, handling specific Livebook annotations for cells and sections, and managing notebook metadata such as app settings and file entries.

_lib/livebook/live\markdown · high confidence

Adds a new release target (\rel/app\) that packages Livebook as a standalone desktop application using Tauri. This includes shell and batch scripts (\env.sh.eex\, \env.bat.eex\) to configure the runtime environment, vendor Elixir, OTP, Hex, and Rebar3 directly into the release bundle, and a \standalone.exs\ script to handle the copying and downloading of these dependencies. A \tauri.sh\ helper script manages the build and development workflow across Linux, macOS, and Windows, while \vm.args.eex\ configures the VM to run without EPMD and optimize resource usage.

rel/app · high confidence

This change adds a new authentication backend for Livebook Teams, implemented in the \Livebook.ZTA.LivebookTeams\ module. It enables users to sign in using their Microsoft Teams identity through a Zero Trust Architecture (ZTA) flow, including handling identity callbacks, managing access tokens, and enforcing version compatibility with the Teams service. The implementation also supports secure logout by redirecting to the Teams logout endpoint and clears session data to prevent CSRF attacks.

lib/livebook/zta · high confidence

This change adds the foundational data models and communication layer for Livebook Teams hubs. It introduces Ecto schemas for managing deployment groups, agents, app deployments, and authorization groups, enabling users to organize and deploy apps within a team context. A new WebSocket-based connection module handles real-time communication with the Teams server, supporting features like agent management, deployment status updates, and notifications. Additionally, deployment group instructions are provided for generating Docker, Fly.io, and Kubernetes deployment configurations.

lib/livebook/teams · high confidence

Adds a new S3-backed file system implementation for Livebook, including the \Livebook.FileSystem.S3.Client\ module for handling S3 API operations (listing, getting, putting, deleting objects) and the \Livebook.FileSystem.S3.XML\ module for encoding and decoding XML responses. This enables users to store and retrieve notebook data from S3-compatible storage.

_lib/livebook/file\system/s3 · high confidence

Users can now start the Livebook web application and deploy notebooks directly from the command line. The new \livebook server\ command launches the web interface with configurable options (such as port, IP, and node name) and supports opening a browser to a specific notebook, URL, or directory. The new \livebook deploy\ command allows users to deploy notebooks to Livebook Teams using organization tokens and deployment group IDs, with support for dry-run checks and handling of unchanged apps.

_lib/livebook\cli · high confidence

This change introduces the core data structures and synchronization mechanisms for Livebook sessions. It adds \Livebook.Session.Data\ to define the shared session state (including notebook, runtime, and cell information) and \Livebook.Session.DataSync\ to compute diffs and generate operations when a notebook is updated, ensuring consistent state across clients. Additionally, \Livebook.Session.FileGuard\ provides a locking mechanism for notebook files to prevent concurrent edits, and \Livebook.Session.Worker\ offloads runtime event broadcasting to a separate process.

lib/livebook/session · high confidence

A new \JSViewChannel\ and associated \Socket\ configuration have been added to handle communication between the server and JavaScript-based widgets. This channel manages session authentication via tokens, tracks multiple client connections per widget reference, and streams event data (including binary payloads) to the frontend. It also implements error handling for serialization failures, ensuring that users receive specific error messages if widget data cannot be encoded, rather than encountering silent failures or generic timeouts.

_lib/livebook\web/channels · high confidence

Users can now create and manage deployment groups directly within the Hub interface. This change adds new LiveView components that provide forms to configure groups as either 'Online' (requiring connected app servers) or 'Airgapped' (manual Dockerfile deployment). The interface displays group status, agent counts, and deployed app metrics, and includes a dedicated modal for setting up app server instances with step-by-step instructions for Docker, Fly.io, and Kubernetes environments.

_lib/livebook\web/live/hub/teams · high confidence

Livebook now includes a dedicated user model to represent ephemeral client identities rather than persistent web accounts. This model stores collaboration-specific data such as display name, email, avatar URL, and a randomly assigned hex color to improve visibility during collaborative sessions. It also supports access type restrictions (full or apps-only), authorization groups, and an extensible payload field for identity provider data, enabling features like real-time presence and team-based access control.

lib/livebook/users · high confidence

Livebook now supports connecting to external Elixir nodes via the new Attached runtime, running code in the current process via the Embedded runtime, and launching isolated nodes on Fly.io or Kubernetes via the Fly and K8s runtimes. The system also includes a custom EPMD module to bypass the OS epmd daemon for standalone connections, a centralized definitions module listing required smart cells (such as Database connection, Chart, Map, and Slack message) with their dependencies, and a dependencies module that automatically injects Mix.install calls into notebook code to manage these packages.

lib/livebook/runtime · high confidence

The intellisense system now supports multiple languages through a new dispatch architecture. Elixir intellisense is fully implemented, providing code formatting, completion (including variables, map fields, modules, functions, and types with documentation), and signature help. Python intellisense is also introduced, offering completion for imports, variables, and module members by leveraging the Pythonx runtime, though code formatting is not supported. Erlang intellisense is added as a stub, implementing the interface but returning nil for all requests as features are not yet implemented.

lib/livebook/intellisense · high confidence

Livebook now supports deploying notebooks as persistent, long-running applications. This change introduces a new app lifecycle managed by \Livebook.App\ and \Livebook.Apps\, allowing users to configure app settings (such as access type, multi-session mode, and automatic shutdown) directly within notebooks. Apps are tracked via a global registry and a dedicated \Livebook.Tracker\, with support for permanent apps loaded from a configured directory or connected hubs. The system includes authorization checks for team-based access, session management for single and multi-session apps, and integration with the existing hub and file system abstractions to handle deployment bundles and file ownership.

lib/livebook · high confidence

Added new modules (\Livebook.Proxy.Server\, \Livebook.Proxy.Handler\, and \Livebook.Proxy.Adapter\) that enable Livebook to delegate HTTP request handling to a separate runtime node. This infrastructure allows the Livebook server to forward incoming connections to the runtime, where a custom Plug adapter translates \Plug.Conn\ operations into inter-process messages, ensuring that request context (including the new \request\_path\ field) is accurately maintained across the boundary.

lib/livebook/proxy · high confidence

This change adds a new set of foundational JavaScript modules to the \assets/js/lib\ directory, establishing the client-side infrastructure for the application. The new files include \app.js\ for managing application-specific authentication tokens, \attribute.js\ for parsing HTML data attributes into component props, and \cache\_lru.js\ for in-memory data caching. It also introduces \codec.js\ to handle binary encoding (such as PCM audio to WAV conversion) and annotated buffers, \delta.js\ to implement a text-delta format for collaborative editing and document synchronization, and \emitter.js\ / \pubsub.js\ for event-driven communication patterns. Additional libraries cover user state persistence via cookies (\user.js\), local storage management (\storage.js\), and a reactive \LiveStore\ (\live\_store.js\). The update also brings in \markdown.js\ for rendering Markdown with support for syntax highlighting, math, and Mermaid diagrams, \notebook.js\ for cell type validation, \settings.js\ for managing user preferences (like editor theme and font size), and \utils.js\ for common helpers including viewport detection, scrolling, and cryptographic hashing.

assets/js/lib · high confidence

Livebook now defines distinct data structures for notebook cells, separating code, markdown, and smart cells into their own modules. Code cells now support multiple languages (Elixir, Erlang, Python), automatic re-evaluation, and error continuation settings. Smart cells are introduced as a new cell type that allows users to perform tasks via a dedicated UI while generating underlying code, with support for dynamic attributes and editor views provided by the runtime.

lib/livebook/notebook/cell · high confidence

The live cell editor has been upgraded to support real-time collaboration, allowing multiple users to edit code cells simultaneously with changes synchronized via a new client-server delta protocol. Additionally, code snippets are now rendered with syntax highlighting that respects the user's selected editor theme (light or dark), improving readability in documentation and previews.

_assets/js/hooks/cell\_editor/live\editor · high confidence

Added three new modules to the Elixir intellisense subsystem: \Livebook.Intellisense.Elixir.Docs\ for extracting and normalizing module documentation, signatures, and specs; \Livebook.Intellisense.Elixir.IdentifierMatcher\ for resolving identifiers (variables, functions, modules, etc.) based on code context and runtime binding; and \Livebook.Intellisense.Elixir.SignatureMatcher\ for finding matching function signatures and determining the active argument during completion. These modules provide the core logic for enhanced code completion and documentation lookup in Livebook.

lib/livebook/intellisense/elixir · high confidence

Livebook introduces a new backend for connecting to remote Erlang nodes, enabling code evaluation and smart cell execution on separate machines. This change adds core processes including a NodeManager to handle node lifecycle and multiple runtime connections, a RuntimeServer to manage evaluation containers and intellisense, and specialized IO forwarding devices (IOForwardGL, SmartCellGL) to route standard output and error streams back to the Livebook UI. It also includes a custom logger handler to capture logs from processes outside the main supervision tree and filter noisy compiler warnings, ensuring that remote evaluation behaves consistently with local execution.

_lib/livebook/runtime/erl\dist · high confidence

The Learn section now includes several new interactive notebooks: a guide to building a chat application using Kino controls and frames, a tutorial on implementing distributed data portals with Elixir, a notebook for tracking GitHub repository stars via the GitHub API, and an introduction to running Python code alongside Elixir using the pythonx library. These additions expand the available learning resources for building interactive apps, leveraging Elixir distribution, and integrating Python data science tools within Livebook.

lib/livebook/notebook/learn · high confidence

Added four new interactive notebooks in the Learn section that guide users through the Kino ecosystem. The 'Intro to Kino' notebook demonstrates built-in components like inputs, controls, data tables, and ETS viewers. 'Custom Kinos' provides step-by-step examples for creating static HTML outputs and bidirectional live counters using Kino.JS and Kino.JS.Live. 'Smart Cells' explains how to build custom UI-driven code generators, including collaborative editors. 'VM Introspection' shows how to visualize process communication, supervision trees, and remote node connections using Mermaid and VegaLite, with the dependency requirement updated to Kino \~\> 0.19.0.

lib/livebook/notebook/learn/kino · high confidence

This change introduces two new LiveView components within the app session interface: \CellOutputsComponent\ and \SourceComponent\. The \CellOutputsComponent\ manages the rendering of cell outputs using Phoenix streams and \phx-update="stream"\ for efficient DOM updates, while also exposing the output size via a data attribute. The \SourceComponent\ provides a dedicated view for the app's notebook source, fetching the notebook data, converting it to LiveMarkdown (excluding outputs and stamps to avoid unnecessary processing), and displaying it in a code preview with a copy function.

_lib/livebook\_web/live/app\_session\live · high confidence

The Settings page now includes dedicated LiveView components to handle the display and editing of environment variables. A new table view lists existing variables with options to edit or delete them, while a separate form component allows users to add new variables or modify existing ones, providing a structured interface for managing global environment settings.

_lib/livebook\_web/live/settings\live · high confidence

The Livebook web interface now includes dedicated LiveViews and components to handle app access control. A new AppAuthLive screen prompts users for a password when accessing password-protected apps, while AppLive and AppSessionLive enforce authorization checks and display 'Not authorized' errors for unpermitted users. The AppsLive dashboard now supports filtering apps by folder and includes a logout option, and the AppsDashboardLive provides a detailed view of deployed apps with session management capabilities.

_lib/livebook\web/live · high confidence

This change introduces a suite of new JavaScript hooks in the \assets/js/hooks\ directory to support new interactive features and settings. The \app\_auth\ hook manages the persistence of app authentication tokens, while \audio\_input\ and \image\_input\ hooks enable client-side processing for microphone recording, file uploads, and camera capture for audio and image data. The \image\_output\ hook adds support for rendering custom pixel-based image formats. Additionally, \editor\_settings\ and \custom\_view\_settings\ hooks provide the UI logic for persisting user preferences for the code editor (such as theme, font size, and ligatures) and custom notebook views. Supporting infrastructure includes \dropzone\ for drag-and-drop highlighting, \focus\_on\_update\ and \scroll\_on\_update\ for UI state management, and \keyboard\_control\ for handling custom keybindings within controls.

assets/js/hooks · high confidence

The session interface now includes dedicated components for adding files from local storage, unlisted directories, uploads, and URLs, giving users more granular control over notebook attachments. Additionally, new views and components for app settings, Docker deployment, and Livebook Teams deployment have been added, allowing users to configure app access, manage deployment groups, and deploy apps directly from the session UI.

_lib/livebook\_web/live/session\live · high confidence

This change introduces four new helper modules in the web layer: \ANSIHelpers\ converts terminal ANSI escape codes into styled HTML for display; \CodecHelpers\ provides utilities for encoding PCM audio to WAV format and handling annotated binary data with JSON metadata; \HTMLHelpers\ adds functions for generating valid HTML IDs, pluralizing text, formatting relative dates, and mapping upload errors to user-friendly messages; and \SessionHelpers\ manages session lifecycle operations including creation, forking, opening notebooks, and updating session lists based on events.

_lib/livebook\web/helpers · high confidence

A new dedicated service has been added to serve iframes used by Livebook apps. This service runs as a standalone Elixir/Plug application, containerized via Docker and configured for deployment on Fly.io. It provides a landing page and serves static assets, acting as the backend for iframe content. This separation allows the iframe content to be hosted on a dedicated domain (livebookusercontent.com) to avoid adblocker issues and enables local development by serving iframes on a separate port when running over HTTP.

iframe · high confidence

The Open Live page now supports three additional ways to import notebooks: uploading a .livemd file directly, pasting a trusted URL (including GitHub or Gist links), or pasting the live markdown source text. These new components replace or supplement the previous file-system-only import flow, giving users more flexibility in how they bring notebooks into Livebook.

_lib/livebook\_web/live/open\live · high confidence

This change introduces a new system for deploying and managing permanent apps across the Livebook cluster. It adds a \Livebook.Apps.AppSpec\ protocol to define how app blueprints (such as local path, Teams, or preview specs) are loaded, along with a \Deployer\ GenServer that handles sequential app deployment and warmup to prevent race conditions. A \Manager\ process orchestrates cluster-wide synchronization of permanent apps, ensuring they are running and up-to-date, while a \DeploymentSupervisor\ manages the underlying supervision tree including the deployer and app supervisor. This provides the backend foundation for the new Apps page and permanent app features.

lib/livebook/apps · high confidence

This change introduces the core data models for the notebook system, including \Livebook.Notebook.Cell\ (supporting code, markdown, and smart cells with output sizing), \Livebook.Notebook.Section\ (with support for branching sections), and \Livebook.Notebook.AppSettings\ (defining deployment settings like slug, access type, and output type). It also adds \Livebook.Notebook.ContentLoader\ for fetching notebook content from files and URLs, and \Livebook.Notebook.Learn\ for managing example notebooks. These models form the foundation for the new notebook architecture and app deployment features.

lib/livebook/notebook · high confidence

This change introduces a suite of new LiveView components in the output area to support richer interaction and display types. Users can now provide input via audio, image, and file uploads, as well as standard form controls (text, datetime, range, etc.) and custom keyboard/button controls. The output display has been expanded to include dedicated components for images, markdown, plain text, and terminal text, along with layout containers for grids and tabs. These components handle streaming updates, file uploads, and client-side previews, enabling a more interactive notebook experience.

_lib/livebook\web/live/output · high confidence

The home page now uses a dedicated SessionListComponent to display running sessions, introducing the ability to download notebook source files directly from the session menu and sort the list by date, title, or memory usage. This component also integrates memory information visualization and supports bulk actions for managing multiple sessions simultaneously.

_lib/livebook\_web/live/home\live · high confidence

This change introduces several new utility modules in lib/livebook/utils. Livebook.Utils.ANSI provides a parser for ANSI escape codes, converting them into structured modifiers (such as bold, italic, colors) and text segments. Livebook.Utils.Time adds functions to format time differences into human-readable relative strings (e.g., "5 minutes ago"), specifically handling clock drifts by accepting future timestamps. Livebook.Utils.UniqueTask offers a supervisor-based mechanism to run functions in separate processes, ensuring that only one instance of a task with a given key runs at a time, with other callers waiting for the result. Additionally, Livebook.Utils.Graph provides utilities for traversing and reducing paths in a bottom-up graph structure, and Livebook.Utils.SupervisionStep allows synchronous execution of functions during supervision tree startup.

lib/livebook/utils · high confidence

This change introduces a new set of Phoenix controllers in the web layer to handle core user interactions. The AuthController manages login flows for both password and token-based authentication, including redirection after successful login. The UserController provides logout functionality, supporting both standard session clearing and ZTA (Zero Trust Architecture) logout via identity providers. The SessionController exposes endpoints for downloading notebook sources (in Live Markdown or Elixir formats), serving static files and assets with caching support, and handling input media streams. Additionally, new error handling templates (ErrorHTML/ErrorJSON) provide user-friendly error pages, and a DevController offers internal endpoints for syncing and stamping notebooks during development.

_lib/livebook\web/controllers · high confidence

This change introduces Python code completion and context awareness within Livebook notebooks. It adds a new Python script (\intellisense.py\) that analyzes Python objects to provide completion suggestions for variables, module imports, and attribute access, including documentation and signatures. This is paired with a new Elixir module (\code.ex\) that parses Python code snippets to determine the cursor context (such as whether the user is typing an import statement or a variable name) to feed into the Python analysis engine.

lib/livebook/intellisense/python · high confidence

The server release now supports running Livebook as a distributed runtime node in containerized environments (Fly.io and Kubernetes) and via the FLAME architecture. The main server script detects environment variables to launch either a FLAME child process, a remote Livebook runtime node (connecting to a parent via Erlang distribution), or the standard standalone server. This enables users to deploy Livebook workloads in scalable, distributed infrastructures where the UI and computation are separated.

rel/server/overlays/bin · high confidence

The LivebookProto module now provides a centralized \build\_event/1\ function that wraps specific protobuf message types (such as Agent, AppDeployment, FileSystem, Secret, DeploymentGroup, and User events) into a generic \LivebookProto.Event\ structure. This change simplifies event creation by automatically mapping the specific message struct to its corresponding event type, ensuring consistent event formatting across the system.

proto/lib · high confidence

The \ErrorHelpers\, \ErrorView\, \LayoutView\, and \PageView\ modules in the \lib/live\_book\_web/views\ directory have been removed. These files, which previously handled error message translation, status code rendering, and layout/page view definitions, are no longer part of the application, indicating a shift away from the standard Phoenix view-based rendering approach for these components.

_lib/live\_book\web/views · high confidence

The legacy Phoenix web layer scaffolding has been removed from the application. This includes the deletion of the \PageController\, the \Endpoint\ configuration, the \Router\, and the default \app.html.eex\ layout and \index.html.eex\ page templates. This change eliminates the default Phoenix welcome page and associated HTTP request handling infrastructure, indicating a shift away from the standard Phoenix controller/view architecture for this location.

_lib/live\_book\web · high confidence

A .gitkeep file has been added to the priv directory to ensure the directory is tracked by version control even when empty, preventing it from being ignored or removed by tools that do not track empty directories.

priv · high confidence

The release environment scripts (env.sh.eex, env.bat.eex) and VM arguments have been updated to improve boot robustness and enable automatic clustering on Fly.io and AWS ECS. The system now generates a random release cookie from /dev/urandom on Unix and a timestamp-based value on Windows, ensuring the release can boot even on read-only filesystems where writing a cookie file would fail. For Fly.io deployments, the release automatically detects the environment, sets the node name using the deployment image hash, and configures DNS-based clustering via the FLY\_APP\_NAME. AWS ECS environments are similarly supported with automatic node naming and clustering. The VM arguments now use a custom EPMD module to avoid port conflicts and disable the default EPMD listener, while also limiting the maximum number of ports to 65536 to prevent resource exhaustion.

rel/server · high confidence

The iframe widget runtime has been updated across versions v1 through v6 to support new capabilities and refine event handling. New context methods have been added: \importJS\ (v4+) allows widgets to dynamically load external JavaScript modules, \selectSecret\ (v4+) enables widgets to request secret selection from the parent, and \setSmartCellEditorIntellisenseNode\ (v5+) provides a hook for editor intellisense integration. Additionally, v3 introduced a \handleSync\ mechanism for source synchronization before evaluation, and v6 restricts DOM event forwarding to only user-initiated interactions to prevent widget scripts from synthesizing events that could trigger parent keyboard shortcuts.

iframe/priv/static/iframe · high confidence

This change establishes the core Protobuf message definitions used for cross-backend communication over WebSocket. It introduces messages for managing Deployment Groups (including secrets, agent keys, and authorization groups), App Deployments, Agents, File Systems, and Secrets. It also defines event messages for user and agent connection states, billing status updates, and deployment lifecycle events, replacing or supplementing previous communication mechanisms with a structured, versioned schema.

proto · high confidence

The secrets system now uses a dedicated \Livebook.Secrets.Secret\ schema to manage secret metadata, specifically adding \hub\_id\ and \deployment\_group\_id\ fields. This allows secrets to be explicitly associated with specific hubs or deployment groups, enabling features like filtering secrets by selected hub and tracking their origin. The model enforces that secret names are uppercase and contain only alphanumeric characters and underscores.

lib/livebook/secrets · high confidence

This change adds four new LiveView hooks in the \lib/livebook\_web/live/hooks\ directory to centralize and improve how the application handles authentication, user state, and UI updates. \AppAuthHook\ manages per-app password authentication by validating tokens via connect params and storing hashed tokens in browser local storage, setting assigns for app authentication and authorization status. \AuthHook\ enforces global server authorization, redirecting unauthorized users and handling server-side authorization updates. \UserHook\ builds the current user context from session and connect parameters, subscribes to user changes and team broadcasts, and updates user metadata based on ZTA/Teams events. \SidebarHook\ manages sidebar-specific state including hubs and notifications, subscribes to various broadcast channels (CRUD, connection, teams, pubsub), and handles shutdown and logout confirmations. Together, these hooks replace or supplement previous inline logic, providing a more structured approach to auth flows, real-time updates, and user session management.

_lib/livebook\web/live/hooks · high confidence

JS views are now rendered in a sandboxed iframe loaded from a separate origin (livebookusercontent.com or a local proxy) rather than inline, ensuring that browser APIs like camera, microphone, Bluetooth, and serial remain accessible while preventing the JS view from accessing the parent app's cookies or context. The iframe source is integrity-verified using a SHA-256 checksum to prevent tampering, and a dedicated Phoenix channel handles all communication between the JS view and the server with binary-encoded payloads.

_assets/js/hooks/js\view · high confidence

The markdown library now includes a dedicated module for rendering Mermaid diagrams. This change introduces LRU caching to avoid redundant rendering of identical definitions and adds specific error handling that displays Mermaid error messages directly in the UI rather than failing silently. It also ensures Font Awesome icons are dynamically loaded when required by the diagram definitions.

assets/js/lib/markdown · high confidence

The application's styling has been refactored from a legacy SCSS setup (including Phoenix default styles) to a modular Tailwind v4 architecture. The main entry point is now \assets/css/app.css\, which imports specialized modules for ANSI terminal colors, Markdown rendering, notebook layout, LiveView interactions, and tooltips. This change introduces a comprehensive design system with custom color palettes (e.g., \--color-brand-pink\), editor theme variables (light/dark mode support for code blocks), and utility classes for animations and custom scrollbars, replacing the previous global styles with a more maintainable, component-scoped structure.

assets/css · high confidence

The cell editor in the LiveEditor has been replaced with a new implementation based on CodeMirror 6. This change introduces a modern, modular editor engine that supports features such as real-time collaboration markers, doctest result overlays, per-language intellisense dispatch, and configurable keymaps (including VS Code, Vim, and Emacs modes). Users will experience improved editing performance, better syntax highlighting, and enhanced interactive features like hover documentation with inline math rendering and go-to-definition capabilities within the notebook cells.

_assets/js/hooks/cell\editor · high confidence

The code cell editor has been rebuilt on CodeMirror 6, replacing the previous implementation. This migration introduces a new set of editor extensions including collaborative editing support with remote cursor markers, syntax highlighting for multiple languages (Python, SQL, Elixir, Shell, etc.), and enhanced interactive features such as hover details, signature help, and doctest result decorations. The new editor also supports code formatting via Ctrl/Cmd+Shift+F, read-only mode hints, and improved visual theming consistent with the application's design system.

_assets/js/hooks/cell\_editor/live\editor/codemirror · high confidence

The application's configuration system has been modernized by replacing the deprecated Mix.Config module with the standard import Config syntax, affecting all environment files (dev, test, prod, and runtime). The HTTP server adapter has been switched from the previous implementation to Bandit (Bandit.PhoenixAdapter), which requires updated endpoint configuration including explicit HTTP/1 options and a configurable drainer shutdown time. Additionally, the build tooling for static assets has moved from Webpack to Bun, reflected in the new bun configuration and asset watcher setup in the development environment.

config · high confidence

The root layout template has been updated to align with Phoenix 1.8 and LiveView 1.0 conventions. This includes adopting the new \.heex\ extension, utilizing the \\<.live\_title\>\ component for dynamic page titles, and implementing conditional asset loading that serves Vite dev server assets in development mode while falling back to compiled assets in production. The layout also now injects configuration variables for base URL paths and feature flags directly into the window object and body attributes, ensuring the frontend has access to necessary runtime configuration.

_lib/livebook\web/components/layouts · high confidence

The JavaScript frontend has been migrated from a standard Phoenix Socket connection to Phoenix LiveView, introducing a new architecture for client-server communication. This change includes a new confirmation modal system that respects user opt-out preferences, global event handlers for clipboard copying and focus management, and a topbar progress indicator for page loads. Additionally, the application now detects when it is running in a cross-origin iframe where browser security policies block third-party cookies; in such cases, it displays an overlay prompting the user to open the app in a new tab to ensure full functionality, rather than failing silently or entering a reload loop.

assets/js · high confidence

The Hub editing interface has been refactored into two distinct LiveView components: \PersonalComponent\ for local workspaces and \TeamComponent\ for Livebook Teams workspaces. The Personal workspace view now allows users to manage secrets, file storages, and secret keys (for notebook stamping) directly. The Team workspace view introduces organization-specific features, including deployment group management, agent status tracking, environment variable configuration, and billing status indicators. It also enforces version compatibility checks that can disable editing if the Livebook version is incompatible with the Teams server, and provides controls to set a default hub or display the Teams key.

_lib/livebook\web/live/hub/edit · high confidence

Livebook now uses a new set of dedicated plugs in lib/livebook\_web/plugs to handle security and routing. AuthPlug manages session-based authentication for token and password modes, enforcing full access authorization and redirecting unauthenticated users. UserPlug initializes user identity (including Zero Trust Authentication support) and manages client-side user data cookies. ProxyPlug exposes a /proxy namespace to forward requests to Livebook sessions and apps, allowing external systems to interact with running notebooks. ConfiguredPlug provides a hook for running custom user-defined plugs.

_lib/livebook\web/plugs · high confidence

Livebook now presents a dedicated authentication screen when access is required, supporting both password and token-based login modes. The new page displays specific instructions for users depending on their authentication method: password users are prompted to enter their password, while token users receive guidance on copying the URL from the desktop app taskbar or checking the console for the authentication URL. The interface includes error handling for invalid credentials and adapts its messaging based on whether the application is running in desktop mode or as a standalone server.

_lib/livebook\_web/controllers/auth\html · high confidence

The evaluator runtime now includes dedicated modules to manage client presence, object garbage collection, and doctest reporting. ClientTracker monitors connected clients and broadcasts join/leave events, allowing the UI to reflect real-time connectivity. ObjectTracker manages references to evaluation results, ensuring memory is reclaimed when processes terminate or references are explicitly removed. Doctests are now executed automatically when modules are defined, with results reported back to the editor via line/column markers for success or failure. Tracer captures module and alias usage during compilation to support dependency tracking and side-panel listings, while IOProxy handles output formatting for Elixir, Erlang, and Python cells, integrating with Kino for rich rendering when available.

lib/livebook/runtime/evaluator · high confidence

This change introduces the complete set of generated Elixir protobuf modules in \proto/lib/livebook\_proto\ to support real-time communication via WebSocket instead of GraphQL. The new schema defines messages for managing deployment groups (including secrets, agent keys, clustering, and ZTA deprecation), app deployments (with status tracking, authorization groups, and folder assignment), and user/agent lifecycle events (connected, joined, left, deleted). It also adds support for billing status updates, file system changes, and topbar notifications, enabling the Livebook Teams client to receive and process these structured events.

_proto/lib/livebook\proto · high confidence

The application's user interface has been refactored to use a new, modular component architecture. This change introduces dedicated component modules for apps, forms, file systems, notebooks, and user profiles, replacing previous inline or scattered implementations. Key visual updates include a redesigned confirmation modal system that supports opt-out preferences and togglable options, a new app status indicator with specific states (e.g., Shutting down, Executing, Error), and a unified layout system with a responsive sidebar and topbar. The UI now supports displaying file system icons for Disk, S3, and Git, and includes a new apps banner component. These changes standardize the look and feel across the application, improving consistency and maintainability of the frontend.

_lib/livebook\web/components · high confidence

The Livebook web interface has been restructured to support running inside iframes, introducing a dedicated \IframeEndpoint\ for serving static assets with CORS headers and adjusting session cookie settings (SameSite=None, Secure) when embedded. The main \Endpoint\ now conditionally loads the Tidewave plug, enforces SSL via configuration, and purges excess cookies to prevent header limit issues. Routing is organized into distinct pipelines for browser, API, authentication, and user contexts, with new scopes for public health checks, session assets, and a dedicated \/apps\ namespace for app-specific LiveViews and authentication flows. The router also includes a custom verified routes module to handle separate base paths for public and private endpoints, and telemetry has been renamed from \LiveBookWeb\ to \LivebookWeb\.

_lib/livebook\web · high confidence

The Hub interface has been restructured to use a centralized \EditLive\ view that dynamically renders either a Personal or Team workspace form, replacing the previous separate pages. This change introduces a new File Storage configuration system, allowing users to attach S3 buckets or Git repositories to their workspace via a dedicated form and list component. Additionally, the Secret management UI has been updated to enforce a read-only, uppercase \LB\_\ prefix for secret names and requires explicit confirmation before deletion.

_lib/livebook\web/live/hub · high confidence

The \LiveBook.Application\ module, which previously defined the OTP supervision tree for the application, has been removed. This change eliminates the automatic startup of core infrastructure components such as the Telemetry supervisor, the Phoenix PubSub system, and the HTTP/HTTPS Endpoint, indicating that the library is no longer responsible for managing its own application lifecycle or web server processes.

_lib/live\book · high confidence

The application module has been renamed from \LiveBook\ to \Livebook\, and the web interface module from \LiveBookWeb\ to \LivebookWeb\. This change migrates the web stack from the legacy Phoenix.View-based architecture to Phoenix LiveView, introducing new macros for controllers, live views, and components in \lib/livebook\_web.ex\ while removing the old view and channel definitions. The rename also includes the addition of new core modules such as \Livebook.EPMD.NodePool\ for node management, \LivebookCLI\ for command-line operations, and \LivebookApp\ for desktop integration, establishing the new structural foundation for the Livebook product.

lib · high confidence

The iframe serving logic has been refactored to run as a standalone HTTP application using the Bandit server on port 4000, rather than being embedded within the main application. This new service exposes static iframe assets with CORS headers enabled, allowing Livebook to fetch and verify content integrity from this separate local endpoint.

iframe/lib · high confidence

A new custom compiler task, \Mix.Tasks.Compile.EnsureLivebookPriv\, has been added to handle asset compilation when Livebook is used as a dependency (e.g., in \nerves\_livebook\ or when installing the escript from GitHub). This compiler ensures that the \priv/static\ assets are built and available by symlinking the deps directory and running the Bun asset build process, resolving issues where assets were previously missing in these specific installation scenarios.

lib/mix · high confidence

Added Teams integration test infrastructure; Added comprehensive test coverage for Livebook core modules; Added comprehensive test coverage for Livebook runtime components; Added controller tests for dev, session, user, and error handling; Added integration tests for Hub workspace and deployment group management; Added integration tests for LiveView UI components; Added integration tests for Livebook Teams hubs, apps, and deployment groups; Added integration tests for Livebook Teams web interface; Added test coverage for Elixir and Python intellisense features; Added test coverage for the Livebook file system abstraction; Added test fixtures for notebook structure and cell types; Added test support assets for static file handling; Added test support modules for inspect error handling and module visibility; Added tests for ANSI and HTML helper functions; Added tests for ANSI parsing, time utilities, and unique task execution; Added tests for Elixir notebook export functionality; Added tests for ErlDist runtime components; Added tests for Hub editing, secrets, and file storage; Added tests for JS View Channel; Added tests for Live Markdown import and export; Added tests for LiveMarkdown import behavior with app folders; Added tests for Livebook Hub Dockerfile generation and secret management; Added tests for Livebook Teams ZTA authentication flow; Added tests for Livebook Teams connection resilience and deployment instruction escaping; Added tests for Livebook text delta operations and JavaScript string handling; Added tests for TeamClient WebSocket event handling; Added tests for authentication, proxy, and user plugs; Added tests for collaborative editing, cursor history, and core utility libraries; Added tests for evaluator client tracking, IO proxy, and object lifecycle management; Added tests for plain text output component styling; Added tests for session data synchronization, state management, and file locking; Added tests for the Livebook Apps deployment and management system; Added tests for user changeset validation; Expanded test infrastructure and configuration for Livebook; Integration tests for CLI notebook deployment; New test support infrastructure for Livebook Teams and app deployments; Removed obsolete Phoenix generator test files.

This release upgrades core Elixir dependencies to Phoenix 1.8, Phoenix LiveView 1.1, Plug 1.16, and Bandit 1.0, while raising the minimum Erlang/OTP requirement to 27 and Elixir to 1.18. The frontend build system has migrated from Webpack to Vite with Bun, introducing a new asset lockfile and updated JavaScript dependencies. Additionally, new subprojects are introduced: \iframe\ (a lightweight Bandit-based space server), \proto\ (Protobuf code generation), and \rel/app/src-tauri\ (the Rust/Tauri 2 bindings for the desktop application).

(dependencies) · high confidence

The frontend build system has switched from Webpack to Vite, replacing the deleted \webpack.config.js\ and \.babelrc\ with a new \vite.config.js\. This change updates the asset pipeline to use Vite plugins for Tailwind CSS and gzip compression, configures the build output to \../priv/static\, and sets the development server to port 4432. The \bun.lock\ file confirms the adoption of Bun as the package manager and includes Vite 7.3.1 as a dev dependency.

assets · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 53 → 56 (+3.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 58 → 60 (+1.7)
• Architecture 96 → 97 (+0.9)
• Maturity 79 → 79 (+0.0)
• Readiness 42 → 50 (+7.8)
• Security 57 → 67 (+9.7)
• Accessibility 71 → 56 (-14.9)

• Boundary-crossing change coupling: deployment_group.ex ↔ deployment_group_created.pb.ex (lib/livebook/teams/deployment_group.ex)
• Boundary-crossing change coupling: embedded.ex ↔ session_live.ex (lib/livebook/runtime/embedded.ex)
• Boundary-crossing change coupling: requests.ex ↔ deployment_group_created.pb.ex (lib/livebook/teams/requests.ex)
• Boundary-crossing change coupling: team_client.ex ↔ deployment_group_created.pb.ex (lib/livebook/hubs/team_client.ex)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (assets/bun.lock)
• Critical CVE: [GHSA redacted] (assets/bun.lock)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (lib/livebook/k8s_api.ex)
• Duplicated block (10 lines × 2) (lib/livebook_web/live/hub/edit/personal_component.ex)
• Duplicated block (10 lines × 2) (lib/livebook_web/live/session_live/add_file_entry_file_component.ex)
• Duplicated block (14 lines × 2) (lib/livebook/runtime/fly.ex)
• Duplicated block (16 lines × 2) (lib/livebook_web/live/session_live/attached_runtime_component.ex)
• Duplicated block (17 lines × 2) (lib/livebook_web/live/output/audio_input_component.ex)
• Duplicated block (22 lines × 2) (lib/livebook/intellisense/elixir.ex)
• Duplicated block (6 lines × 2) (lib/livebook/session/data.ex)
• Duplicated block (7 lines × 2) (lib/livebook/session.ex)
• Duplicated block (8 lines × 2) (lib/livebook/intellisense/elixir/identifier_matcher.ex)
• Duplicated block (8 lines × 2) (lib/livebook_web/live/session_live.ex)
• Duplicated block (9 lines × 2) (lib/livebook_web/live/app_session_live.ex)
• …and 91 more

• Boundary-crossing change coupling: team_client.ex ↔ event.pb.ex (lib/livebook/hubs/team_client.ex)
• Change coupling: attached.ex ↔ standalone.ex (lib/livebook/runtime/attached.ex)
• Change coupling: deployment_group.pb.ex ↔ deployment_group_updated.pb.ex (proto/lib/livebook_proto/deployment_group.pb.ex)
• Change coupling: dev.exs ↔ prod.exs (config/dev.exs)
• Change coupling: livebook_proto.ex ↔ event.pb.ex (proto/lib/livebook_proto.ex)
• Change coupling: settings.js ↔ settings_live.ex (assets/js/lib/settings.js)
• Change-coupling hub: embedded.ex → attached.ex, standalone.ex, session.ex (lib/livebook/runtime/embedded.ex)
• Coverage not measured — JavaScript/TypeScript suite
• Critical CVE: [GHSA redacted] (assets/bun.lock)
• Critical CVE: [GHSA redacted] (assets/bun.lock)
• Dependency source pinned to a moving git ref
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (lib/livebook_web/live/session_live.ex)
• Duplicated block (10 lines × 2) (lib/livebook_web/live/session_live/add_file_entry_file_component.ex)
• Duplicated block (10 lines × 2) (lib/livebook_web/live/session_live/add_file_entry_upload_component.ex)
• Duplicated block (12 lines × 2) (lib/livebook_web/live/output/markdown_component.ex)
• Duplicated block (13 lines × 2) (lib/livebook_web/live/hub/edit/personal_component.ex)
• Duplicated block (14–19 lines × 2) (lib/livebook/k8s_api.ex)
• Duplicated block (18 lines × 2) (lib/livebook_web/live/session_live/attached_runtime_component.ex)
• …and 183 more

• 7 commits — 7 feature/other, 0 fixes

• lib/livebook — 2 commits
• assets/bun.lock — 1 commit
• assets/css — 1 commit
• assets/js — 1 commit
• lib/livebook_cli.ex — 1 commit
• rel/app — 1 commit

• change: Add macOS keybindings for completion navigation in LiveEditor (#3210)
• change: Add request_path to Proxy Handler Conn (#3211)
• change: Optimise cell source diffing (#3215)
• change: Remove quotes from generic font family (#3213)
• change: Update Mermaid
• change: Validate extracted escript assets with a hash (#3207)
• change: rel/app: Improve setup

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

livebook-dev/livebook was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.