Open-source interactive notebook platform and embeddable .NET execution engine.
Website · Gallery · Documentation · VS Code extension · Release notes
In VS Code, install the extension from the Marketplace, then open any .verso, .ipynb, or .dib file:
code --install-extension Datafication.verso-notebookIn the browser, install the CLI as a .NET global tool and launch the editor:
dotnet tool install -g Verso.Cli
verso serveRequirements: the VS Code extension needs the .NET runtime, version 8.0 or later and offers to install it for you if it is missing; the verso CLI needs the .NET SDK for dotnet tool install. Node.js 18+ and Python 3.8 or newer are optional; they enable the JavaScript/TypeScript and Python kernels (JavaScript falls back to the pure .NET Jint interpreter when Node.js is absent).
Microsoft deprecated Polyglot Notebooks on February 11, 2026, and .NET Interactive, the engine that powered it, followed the same path. Together they were the primary way to run interactive C#, F#, PowerShell, and SQL in a notebook. Their deprecation left a gap in the .NET ecosystem: no maintained notebook platform, and no maintained embeddable execution engine.
Verso fills both roles.
As a notebook platform, Verso runs in VS Code or any browser, ships with IntelliSense and variable sharing across every language it supports, and imports existing .ipynb and .dib files. If you used Polyglot Notebooks, the experience will feel familiar.
As an engine, the core is a headless .NET library with no UI dependencies. It provides multi-language execution, an extension host, a variable store, and a layout manager through a clean set of public interfaces. If you embedded .NET Interactive in a tool, service, or workflow, the Verso engine serves the same purpose with a fully extensible architecture. Reference the NuGet package, wire up a Scaffold, and you have a programmable notebook runtime in any .NET application.
The architecture is built on one principle: every feature is an extension, and every extension uses the same public interfaces available to anyone. The C# kernel, the dark theme, and the dashboard layout all ship as extensions with no special access to engine internals. If a built-in feature needs an internal API to work, the interfaces are incomplete.
Every language kernel answers completions and hover from a real language service rather than by text matching: Roslyn for C#, FSharp.Compiler.Service for F#, a live runspace for PowerShell, and your own interpreter for Python. Kernels also compute diagnostics ahead of execution, which hosts and tools reach through ILanguageKernel.GetDiagnosticsAsync; errors from a run are reported as cell output.
NuGet packages are referenced inline with #r "nuget: PackageName/Version", and custom package sources are supported with #i "nuget: <url>". Python uses #!pip for package management, and JavaScript uses #!npm for npm packages. State persists across cells within each kernel, and variables are shared across kernels through a central variable store.
The same notebook can be read as a linear document, rearranged into a 12-column grid dashboard, or presented as a read-only flow with the editor chrome stripped away. Switch between them at runtime; the arrangement is saved in the .verso file, so a notebook opens the way you left it.
In the dashboard, drag cells to reposition them, resize with handles, and hide the plumbing so only the result is on screen.
Presentation mode shows the same cells as a document: source and result, no run buttons, no badges, nothing to click by accident.
Layouts are an extension point like everything else. Custom layout engines plug in through the same public interfaces as the built-ins.
A sidebar of panels sits beside the notebook, each opened from a pill in the toolbar: Metadata, Extensions, Variables, Settings, Properties, View, and Compare. Only the open panel shows its label, so the row stays out of the way.
Panels are an extension point too. An extension implements INotebookPanel and contributes its own panel next to the built-ins, with the same vocabulary and the same styling as everything that ships.
The Extensions panel doubles as a marketplace. Search NuGet, install into the notebook, pin a version, or sideload a package from disk, then see what each installed package actually contributed. See the managing extensions guide.
Compare the open notebook, unsaved edits included, against the last saved file, git HEAD, any branch, tag, or commit, or another notebook file on disk. Because every cell in a .verso file has a stable identity, the diff distinguishes an edited cell from a removed-plus-added pair and recognizes cells that merely moved. Modified cells show side-by-side source comparison, and when outputs changed, the old and new rendered outputs (tables, charts, HTML) appear next to each other. Notebook-level settings changes such as the active layout, theme, and parameters are summarized at the top.
Comparison runs from the Compare panel and stays on while you keep working, so changed cells stay marked in the notebook after the panel is closed. See the comparing notebooks guide.
A parameters cell declares typed inputs with defaults, rendered as a form at the top of the notebook. The same notebook then runs unattended with verso run pipeline.verso --param region=us-east, which is what makes one file work both interactively and in a scheduled job. See the notebook parameters guide.
Python cells run in a separate process against a CPython installation already on your machine, 3.8 or newer, so an active virtual environment or conda environment is picked up and its packages are simply there. #!python reports what was found and switches interpreters for the session, and --python <path> pins one for verso run, verso repl, and verso serve. matplotlib figures and ipywidgets-based visualizations render inline. See the Python interpreters guide and the Python packages guide.
Verso.Ado provides provider-agnostic SQL connectivity through ADO.NET. Connect to any supported database, execute queries with paginated result tables, inspect schema, and scaffold EF Core DbContext classes at runtime. SQL results are shared to the variable store for use in C#, F#, and other cells. See the database connectivity guide for connection setup, provider support, EF Core scaffolding, and CI/CD pipeline examples.
Verso.Http uses .http file syntax (the same format supported by VS Code REST Client and JetBrains HTTP Client). Features include variable interpolation, dynamic variables, named request chaining, and cross-kernel integration where response data is shared to C#, F#, and other cells.
Verso.JavaScript provides full JavaScript and TypeScript execution in notebook cells. When Node.js is available, cells run in a persistent subprocess with access to require(), dynamic import(), top-level await, and npm packages installed via the #!npm magic command. In environments without Node.js, the JavaScript kernel falls back to Jint, a pure .NET ES2024 interpreter with no external dependencies. TypeScript cells are automatically transpiled using the TypeScript compiler API (auto-installed on first use) and share the same execution environment and variable scope as JavaScript cells.
Markdown (rendered via Markdig), raw HTML, and Mermaid diagram cells all support @variable substitution from the shared variable store, enabling dynamic documents that update when data changes. See the Mermaid diagrams guide for diagram types, variable-driven charts, and theming.
Three built-in themes (Light, Dark, High Contrast) are hot-swappable at runtime. The High Contrast theme meets WCAG 2.1 AA contrast requirements. In VS Code, the notebook theme automatically follows your editor theme.
The notebook interface, the toolbar and panels, the kernel messages that land in cell output, and the CLI are translated into German, Spanish, Japanese, and Simplified Chinese. Verso follows the system or the editor on its own; verso.language and --language override it, and VERSO_LANGUAGE sets it once for a container or a pipeline. Only the words change: numbers and dates keep the machine's own formatting, so a language never alters what a cell computes. See the interface language guide.
In VS Code, a @verso chat participant answers questions about the notebook in front of you, and twenty language model tools let agent mode create, edit, run, and inspect cells directly. Copilot works against the real notebook rather than a text approximation of it.
Open any .ipynb or .dib file and Verso converts it automatically. Polyglot Notebook patterns like #!fsharp, #!connect, and #!sql are mapped to native Verso cells during import. By default, saving writes to a sibling .verso file and leaves the original untouched. To save .ipynb notebooks back to .ipynb (cell outputs preserved), enable the verso.preserveOriginalFormat setting in VS Code, or pass --preserve-format to verso repl / verso serve.
A plain .md file is a notebook. Fenced code blocks tagged with a language Verso recognizes become executable cells; prose, untagged fences, and code samples in other languages stay as prose. Saving writes plain Markdown back to the same file, preserving your fence style exactly, so the document still renders on GitHub and reviews cleanly in a pull request. Cell outputs are not persisted in this format. See Markdown Notebooks.
| Language | IntelliSense | Variable Sharing |
|---|---|---|
| C# | Yes | Yes |
| F# | Yes | Yes |
| JavaScript | Yes* | Yes |
| TypeScript | Yes* | Yes |
| PowerShell | Yes | Yes |
| Python | Yes | Yes |
| SQL | Yes | Yes |
| HTTP | Yes | Yes |
* IntelliSense for JavaScript and TypeScript is provided by Monaco's built-in language services rather than the kernel.
Markdown, HTML, and Mermaid ship as rich content cell types rather than language kernels; see Rich Content Cells.
Verso ships as a .NET global tool. Beyond launching the editor, the CLI runs notebooks headlessly, hosts a terminal REPL, and converts between formats, so the same notebook works interactively and in CI.
# Launch the Verso editor in your browser
verso serve
# Open a specific notebook
verso serve my-notebook.verso
# Run a notebook headlessly
verso run pipeline.verso --param region=us-east --output json
# Convert a Jupyter notebook to Verso format
verso convert notebook.ipynb --to verso
# Start an interactive REPL (C# by default; switch with .kernel fsharp, .kernel python, ...)
verso repl
# Export a notebook through a registered ExportMenu action
verso export notebook.verso --format html --output out.html| Command | Purpose |
|---|---|
verso serve |
Launch the Verso editor as a local web server |
verso run |
Execute a notebook headlessly and stream outputs |
verso repl |
Interactive REPL hosted in the terminal, backed by the same kernels and extensions as the editor |
verso convert |
Convert between .verso, .ipynb, and .dib formats |
verso export |
Export a notebook via an ExportMenu toolbar action (HTML, Markdown, …) |
verso info |
Display CLI version, runtime, and extension details |
verso run supports typed parameters (--param name=value), JSON output for CI integration, selective cell execution, and fail-fast mode. verso repl supports completion, persistent history, multi-line cell submission (blank-line to submit), and meta-commands like .kernel, .vars, .save, .load, and .export. See the CLI README for the full option reference, meta-command list, exit codes, and CI/CD examples.
Verso is split into three layers. The engine knows nothing about the UI. The UI knows nothing about the host environment. Extensions work identically everywhere.
+-----------------------------------------------------------+
| Front-Ends |
| +---------------------+ +--------------------------+ |
| | VS Code Extension | | Blazor Server Web App | |
| | (Blazor WASM | | (verso serve, or | |
| | inside a webview) | | dotnet run Verso.Blazor)| |
| +----------+----------+ +-------------+------------+ |
| | | |
| +----------------------------------------------------+ |
| | Shared UI (Razor Class Library) | |
| | Monaco editor, panels, toolbar, theme provider | |
| +----------------------------------------------------+ |
| |
| +----------------------------------------------------+ |
| | CLI (verso run / verso convert) | |
| | Headless execution, format conversion, CI/CD | |
| +----------------------------------------------------+ |
+-----------------------------------------------------------+
|
+-----------------------------------------------------------+
| Verso Engine (headless .NET library, no UI) |
| Scaffold - Extension Host - Execution Pipeline |
| Layout Manager - Theme Engine - Variable Store |
+-----------------------------------------------------------+
|
+-----------------------------------------------------------+
| Verso.Abstractions |
| Pure interfaces, zero dependencies |
| The only package extension authors need to reference |
+-----------------------------------------------------------+
Front-ends provide the user experience. Blazor Server talks to the engine directly, in-process. VS Code runs Blazor WebAssembly in a webview, communicating with a host process over JSON-RPC. Both share the same Razor components so the notebook experience is identical. The CLI drives the engine headlessly for CI pipelines and automated workflows.
The engine is a headless .NET library. Scaffold orchestrates a notebook session: cell management, kernel dispatch, execution, cross-kernel variable sharing, and subsystem coordination. Every language kernel, theme, layout, and formatter ships as an extension using the same public interfaces available to third-party authors.
Verso.Abstractions contains only interfaces and the [VersoExtension] attribute. It is the sole dependency for extension authors and has zero transitive dependencies.
For a deeper look at each layer, see the architecture documentation.
A focused set of interfaces in Verso.Abstractions defines every point of extensibility: language kernels, cell renderers, cell types, cell property providers, notebook panels, toolbar actions, data formatters, magic commands, themes, layouts, serializers, notebook migrations, post-processors, and cell and layout interaction handlers. Extensions can also implement IExtensionSettings to expose configurable settings in the UI.
Third-party extensions load in their own AssemblyLoadContext, collectible and unloadable. Your extension references only Verso.Abstractions and works across every front-end without modification.
dotnet new verso-extension -n MyExtensionVerso includes a dotnet new template, a testing library (Verso.Testing), and sample extensions in the repo. For the full interface reference and extension host internals, see the extension documentation and extension host architecture.
| Category | Included |
|---|---|
| Kernels | C# (Roslyn), F# (FCS), JavaScript (Node.js / Jint), TypeScript, PowerShell, Python (your own interpreter, run out of process), HTTP |
| Cell Types | Code, Markdown, HTML, Mermaid, Parameters, SQL, HTTP |
| Themes | Light, Dark, High Contrast (WCAG 2.1 AA) |
| Layouts | Notebook (linear), Dashboard (12-column CSS grid), Presentation (read-only flow) |
| Panels | Metadata, Extensions, Variables, Settings, Properties, View, Compare |
| Magic Commands | #!time, #!nuget, #!pip, #!npm, #!python, #!extension, #!restart, #!about, #!import, #!sql-connect, #!sql-disconnect, #!sql-schema, #!sql-scaffold, #!http-set-base, #!http-set-header, #!http-set-timeout |
| Toolbar Actions | Run Cell, Run All, Clear Cell Output, Clear Outputs, Restart Kernel, Switch Layout, Switch Theme, Export HTML, Export Markdown, Export CSV, Export JSON, Export Verso |
| Data Formatters | Primitives, Collections (HTML tables), Objects (expandable graph, bounded so framework internals cannot exhaust the output budget), HTML, Images, SVG, Exceptions, F# types, SQL result sets |
| Serializers | .verso (native JSON, read/write), .ipynb (read/write, write opt-in), .md (read/write, plain Markdown, no outputs), .dib (read only) |
JSON-based, human-readable, and diff-friendly:
{
"verso": "1.0",
"metadata": {
"defaultKernel": "csharp",
"activeLayout": "notebook",
"preferredTheme": "verso-light"
},
"cells": [
{
"id": "...",
"type": "code",
"language": "csharp",
"source": "Console.WriteLine(\"Hello from Verso\");",
"outputs": [...]
}
],
"layouts": {
"dashboard": {
"cells": {
"cell-id": { "row": 0, "col": 0, "width": 6, "height": 4 }
}
}
}
}In this repository:
- Architecture: the engine, front-ends, and extension host in depth
- Guides: database connectivity, Mermaid diagrams, notebook comparison, and more
- Extension authoring: the full interface reference and walkthroughs
- Migration: coming from Polyglot Notebooks, Jupyter, or Papermill
- CLI reference: every command, option, meta-command, and exit code
- Known issues: what is currently broken and what to do about it
- Gallery: notebooks you can read in the browser and download to run
- Documentation: the same guides, rendered and searchable
- API reference: generated from the public API surface
- Release notes: what changed in each version
git clone https://github.com/DataficationSDK/Verso
cd Verso
dotnet build Verso.sln
dotnet run --project src/Verso.Blazordotnet build src/Verso.Host
cd vscode
npm install
npm run build:all
npx vsce package --skip-licenseInstall the .vsix file, then open any .verso file. Use Open With... to import .ipynb or .dib files.
dotnet test Verso.slnContributions are welcome. Open an issue to discuss what you'd like to work on. Verso accepts contributions under the Developer Certificate of Origin; see CONTRIBUTING.md for the sign-off workflow.
Verso is a Datafication project.