Observable

Executes JavaScript code in browser-isolated cells with automatic reactive dependency graph computation. When a variable changes, Observable's runtime automatically identifies and re-executes all dependent cells in topological order without manual refresh. Uses a declarative cell-based model where each cell declares its inputs and outputs, enabling fine-grained reactivity similar to spreadsheet formulas but for arbitrary code.

Provides a declarative, mark-based charting library (Observable Plot) that composes visualizations from primitive marks (dots, lines, cells, bars) with data encoding specifications. Plot uses a functional composition pattern where marks are combined with data transformations (grouping, normalization, windowing) to create complex charts. Supports 20+ mark types and integrates with D3 for custom visualization needs, rendering to SVG with automatic axis/legend generation.

Open-source static site generator that compiles Observable notebooks into standalone HTML/JavaScript applications deployable to any static hosting (Vercel, Netlify, GitHub Pages, etc.). Supports multiple pages, navigation, and integration with JavaScript/TypeScript for custom logic. Notebooks are pre-executed at build time, generating static HTML with embedded data, reducing runtime dependencies and improving performance.

Manages team access at the workspace level (Pro tier only), allowing workspace owners to invite guests with specific roles and permissions. Supports different access levels: editors (can create/edit notebooks), viewers (read-only access to published notebooks), and potentially other roles. Guest access is managed separately from notebook-level sharing, enabling organization-wide permission hierarchies.

Separate product (limited details available) that combines collaborative whiteboards with embedded data queries, tables, charts, sketches, and notes. Allows teams to mix structured data analysis (queries, visualizations) with unstructured collaboration (sketches, text notes) in a single canvas. Real-time collaboration enables multiple users to work on the same canvas simultaneously.

Provides direct access to D3.js library within notebooks, enabling custom visualization development beyond Observable Plot's mark-based API. Developers can write imperative D3 code to create specialized charts, interactive graphics, and data-driven animations. D3 selections, scales, axes, and transitions are fully available, with Observable's reactive system automatically re-running D3 code when dependencies change.

Enables multiple users to edit the same notebook simultaneously with real-time synchronization of code changes, cell execution, and outputs. Uses operational transformation or CRDT-like mechanisms (implementation details not disclosed) to merge concurrent edits without conflicts. Changes from one editor appear instantly to others, and cell re-execution is coordinated across all collaborators to maintain consistent state.

Runs notebooks on a server-side schedule (frequency/timing unspecified) to automatically refresh data, recompute analyses, and persist results. Triggered execution fetches fresh data from connected sources (databases, APIs, cloud files), re-executes all cells, and stores outputs for later retrieval. Enables automation of recurring analyses without manual intervention, such as daily dashboards or weekly reports.

Executes SQL queries directly against connected databases (drivers/providers unspecified) from within notebook cells, returning results as JavaScript arrays/objects for further processing. Supports parameterized queries where cell variables can be interpolated into SQL, enabling dynamic queries based on user inputs or upstream computations. Results are materialized into memory for visualization and analysis.

Fetches data from cloud storage (S3, GCS, Azure Blob — providers unspecified) and web APIs, automatically detecting and parsing formats (CSV, JSON, Parquet, etc.). Caches fetched data within the notebook session to avoid redundant network requests. Supports both one-time imports and reactive data fetching where changes to parameters trigger fresh API calls.

Provides a library of UI input components (Observable Inputs: sliders, text inputs, dropdowns, date pickers, tables, buttons) that bind directly to notebook variables. When a user interacts with an input component, the bound variable updates and triggers reactive re-execution of dependent cells. Supports two-way binding where cell values can update input state.

Maintains a version history of notebook changes (commits) with the ability to view, compare, and rollback to previous versions. Each save creates a snapshot of the notebook state. Provides a timeline view showing who made changes and when, enabling audit trails and recovery from accidental edits. Implementation uses Observable's proprietary version control (not Git).

Publishes notebooks as embeddable HTML snippets that can be inserted into external websites or documents. Embeds include an Observable watermark by default (removable on Pro tier). Supports public sharing (anyone with link can view) and private sharing (access control via Observable accounts). Viewer tier allows read-only access without edit permissions, enabling sharing at scale without giving edit access.

Provides an 'AI Assist' feature that generates code suggestions and completions within notebook cells. The AI model (provider and name unknown) analyzes notebook context (previous cells, data types, imports) to suggest relevant code. Supports both inline completions and full cell generation from natural language descriptions. Available on both free and Pro tiers.