Wolfbook — AI-Friendly Wolfram Language Notebook

Get Started · Features · WPaper · AI Integration · MCP & Agent Tools · Using Cline · DeepSeek + Copilot · Presentations (.wslide) · Oberon Agent 🧪 · Best Practices · WB Functions · Citing

Wolfbook is a Mathematica-style notebook frontend for VS Code. Create, edit and run Wolfram Language notebooks against a local Wolfram Engine or Mathematica kernel — with typeset LaTeX and inline graphics, a live kernel that AI agents can drive, and plain-text notebooks that diff cleanly in Git. Wolfbook also includes WPaper, a live compiled-paper view and review workflow for writing LaTeX in VS Code.

Requires a Wolfram kernel. Wolfbook is the notebook interface; the mathematics runs in Wolfram Engine (free for personal and developer use) or Mathematica, which you install separately. Setup takes a few minutes — see Getting Started.

Why Wolfbook?

• A real Mathematica notebook inside VS Code, not just syntax highlighting
• Opens your existing Mathematica .nb files (read-only) — no kernel, no export step
• Works with Wolfram Engine (free) or Mathematica
• Plain-text .wb / .vsnb notebooks — diffable in Git, readable by AI tools
• Rich math output: LaTeX / KaTeX, SVG / PNG graphics, TikZ
• Interactive 3D graphics and coordinate tooltips for 2D plots
• WPaper for LaTeX — live compiled pages, source↔paper navigation and reviewable AI edits
• Live kernel access for AI agents — Copilot, Claude Code, Codex, MCP-compatible tools
• Mid-evaluation abort, Dynamic[] widgets, debugger and watch panel
• Globally numbered kernels (K1, K2, …) with a picker that can bind a notebook to a kernel owned by another live VS Code window, or start a new kernel whose slot and notebook association are restored after window reload; idle unattached kernels can be stopped from the same picker
• Per-user, per-notebook backgrounds that do not modify shared .wb files
• Open source, Apache 2.0

Wolfbook vs other Wolfram/Mathematica VS Code extensions

Recent features

Manipulate stays interactive: move Wolfram Language controls and rotate the resulting Graphics3D directly in the notebook.

Interactive 3D output: drag a rendered Graphics3D result to rotate it directly in the notebook.

Open existing Mathematica .nb files as safe, read-only notebook views, then save an editable .wb copy.

Format Wolfram Language cells in place, including named-character conversion and indentation.

Hover over a 2D plot to inspect curve coordinates without leaving the notebook.

What You Get

WPaper: a live LaTeX writing workspace

Open a .tex file and WPaper keeps the source editor beside the compiled paper. It rebuilds from the unsaved editor buffer after you pause, without writing generated files into your project, and keeps the page aligned with where you are writing. Click the paper to return to source; move through source to follow it on the page. Exact LuaLaTeX mapping is used when available, with SyncTeX fallback for documents that need another engine.

WPaper is designed for the part of scientific writing that a PDF preview alone does not solve:

• a structural outline, folding, CodeLens and deterministic reference/environment diagnostics
• printed previews when hovering \ref / \eqref, plus labels revealed directly on the page
• image paste that creates the figure source and asset together
• comparisons against disk, Git revisions or another paper
• a focused review of agent changes, where each change can be shown on the compiled page and kept or undone independently
• paper_* agent tools with source-hash guards, so an AI edit is rejected if the paper changed underneath it

WPaper deliberately does not register another LaTeX grammar or replace your existing language tooling. It works alongside LaTeX Workshop while Wolfbook supplies the compiled-paper navigation, editing and agent-review layer. Run Wolfbook: Open WPaper (or WPaper: Show Me Around for the guided tour) from any .tex file.

A proper notebook in VS Code

• .wb files with code cells and Markdown cells (with full LaTeX math via KaTeX)
• Symbolic results rendered as typeset mathematics with line-broken LaTeX — not plain text
• Graphics (plots, Graphics[…]) rendered as SVG or PNG inline
• Per-cell output format switching: WL / SVG / LaTeX / MathML / TikZ
• Dynamic[expr] widgets that update live while the kernel runs
• Abort the kernel without losing your kernel context, or restart with a clean kernel with one click — exactly like in Mathematica, but unique among VS Code notebook extensions
• Escape-mode Greek entry: type \[Alpha], \[Beta], \[Gamma] and they get converted into symbols, or use [escape]a[escape] etc.
• Watch any expression continuously; evaluate any selection mid-computation

Select Wolfram Language code and press Cmd+Shift+E on macOS or Ctrl+Shift+E on Windows/Linux to evaluate it immediately. The result is rendered in the Watch panel using the selected LaTeX, source or SVG output format. Evaluate Selection works while another cell is running and preserves the editor selection, so the same expression can be evaluated repeatedly.

Open your existing Mathematica .nb notebooks

Double-click any Mathematica .nb file and it opens directly in the Wolfbook notebook editor — cells, Markdown text, typeset output and graphics. Conversion happens in-process in about 20 ms: no kernel required, nothing to run, no export step in Mathematica first.

Opened .nb files are read-only by design: Wolfbook never writes .wb JSON back over your original notebook. Press ⌘S / Ctrl-S and it saves a sibling .wb copy — keeping any edits you made — and opens that, so the Mathematica file on disk is left exactly as it was.

• Output is re-typeset through the same LaTeX/KaTeX renderer as native notebooks
• Graphics are rasterised to PNGs alongside the notebook and cached by content
• WBInclude["file.nb"] uses the same importer, so you can pull an existing notebook into a Wolfbook session directly

VS Code IDE features — free

• Split view: open two notebooks side by side
• Multi-cursor: rename all occurrences of a symbol at once
• Step-by-step debugger: set breakpoints, step over/into loops, inspect variables
• Live Watch Panel: monitor expressions across evaluations without Print statements
• Full git integration: diff, blame, branch — works because .wb is plain text

AI that actually knows your notebook

Wolfbook exposes your live kernel and notebook contents to AI agents via purpose-built tools. GitHub Copilot in Agent mode can, for example:

• Read all cells and their outputs (#wolfbookContext)
• Evaluate any expression in the live kernel (#wolfbookEval)
• Look up Wolfram documentation without a browser (#wolfbookLookup)
• Insert, edit, and delete cells (#wolfbookInsert, #wolfbookEdit, #wolfbookDelete)
• Drive the step-through debugger autonomously (#wolfbookDebug)
• Query the kernel state — what symbols are defined, what are their values (#wolfbookState)

The same tools are exposed as an MCP (Model Context Protocol) server, so any MCP-compatible AI agent — Claude Code, Codex, and others — can use them too. See MCP & Agent Tools for details.

Presentations built in your notebook

Wolfbook includes a .wslide presentation format: JSON-based slides rendered via Reveal.js inside VS Code, with LaTeX math, live Wolfram Language eval blocks, and the same btl math renderer as the notebook. The entire slide format is editable by AI agents via 12 dedicated MCP tools. See Presentations. Drop your pictures and a bit of text and get a full slide deck in seconds. Refine it with AI and create a masterpiece.

Reworked in this release: the slide editor has been substantially reworked — a cleaner canvas with proper selection, alignment and arrange tooling, and a redesigned side panel. It now has AI editing built into the editor itself: select any block (or several) and press ⌘K to say what you want — "tidy this", "make these equal width", "turn into 3 bullets" — and the assistant proposes concrete changes you accept or reject before anything is written. Deterministic one-click actions for the common tidy-ups need no model at all.

🧪 Experimental: the Oberon research agent

This is an experimental preview and it is off by default. Oberon requires your own third-party LLM API key, spends real money per run, writes files into your workspace, and its commands and settings will change between releases. With no API key configured it never runs and nothing leaves your machine. Nothing else in Wolfbook depends on it — ignore this section entirely and the notebook, kernel and slide features work exactly as before.

Wolfbook ships an early preview of Oberon, an autonomous research agent that lives inside the extension. Where the tools above let an AI assist you, Oberon takes a brief and does the work: it plans the calculation, probes the live kernel, records the steps that survive, compiles them into a clean notebook, and then restarts the kernel and re-runs that notebook from scratch to verify it. The model is allowed to be wrong; the kernel is the judge.

It is also integrated with SkilXiv.org, a public registry of versioned, citeable, executable know-how. Oberon looks up a relevant skill before it starts — which on hard problems is the difference between rediscovering a method by trial and error and simply applying it — and can draft new skills from verified results for you to review and publish.

Oberon is opt-in and off until you configure an API key; with none set, it never runs and nothing leaves your machine. It costs real money per run (typically cents, on DeepSeek) and its interface will change between releases.

→ Oberon — the experimental research agent: what it does, how to configure providers, roles, budgets, the SkilXiv integration, and exactly what data goes where.

Quick Start

1. Install prerequisites

• VS Code 1.95+ / Antigravity
• Wolfram Engine (free, non-commercial) or Mathematica
• Activate Wolfram Engine at wolfram.com/engine/free-license — requires internet once

2. Install Wolfbook

Wolfbook can be found in the VS Code Marketplace or on GitHub in the Releases section. Or on Antigravity's marketplace or open-vsx.org.

3. Create your first notebook

Create an empty file test.wb and open it in VS Code. The kernel starts automatically on first cell execution.

4. Enable AI (optional but recommended)

Install GitHub Copilot from the Extensions panel (free tier available; GitHub Education gives generous limits). Open the Copilot Chat panel (⌃⌘I), switch to Agent mode, and start asking. From our experience Claude Code in Agent mode gives the best result.

→ Full setup guide: Getting Started

Architecture

Wolfbook is built around two bespoke native C++ addons:

mathematica-wstp-node — connects directly to the Wolfram kernel via the WSTP (Wolfram Symbolic Transfer Protocol) protocol. No subprocess piping, no ZeroMQ. This is what makes mid-evaluation abort, Dynamic widgets, and Dialog[] subsessions possible.

wolfbook-btl (Box-to-LaTeX) — translates Wolfram's internal TraditionalForm box structures to LaTeX, rendered client-side with KaTeX. About 10× faster than Wolfram's built-in TeXForm for complex expressions, and handles many cases TeXForm cannot. Dynamically adjusts line-breaking to fit the page width. Long expressions are paginated or can be exported in one click in .wl format.

Both addons are prebuilt for macOS (Apple Silicon and Intel) and Windows and bundled in the .vsix. Linux is under construction. You can also compile them yourself; see Building from Source.

Documentation

Data and privacy

Wolfbook does not collect analytics and has no telemetry of its own. Your notebooks, kernel session and slides stay on your machine.

Network access happens in exactly two places, both under your control:

With no Oberon API key configured, none of the above happens — no LLM calls, no SkilXiv requests, nothing. To disable the SkilXiv parts while still using the agent, set wolfbook.oberon.recall.enabled and wolfbook.oberon.recall.usageTelemetry to false.

Full detail: Oberon — data and privacy.

Status and Feedback

Wolfbook is just over a month old (first release: March 2026). It works well for the use cases demonstrated at the CERN workshop, but rough edges remain. If you encounter a bug or unexpected behaviour, please report it via the GitHub issue tracker — include your OS, VS Code version, Wolfram Engine / Mathematica version, and a minimal code or screenshots that reproduces the problem. We will try to fix issues as quickly as possible.

Feature requests and pull requests are also very welcome.

Citing Wolfbook

If Wolfbook supports your research, a brief mention in the acknowledgements helps us track impact and sustain development:

"Some computations in this work were facilitated by the Wolfbook VS Code extension (github.com/vanbaalon/wolfbook)."

Links

• GitHub: github.com/vanbaalon/wolfbook
• WSTP addon: github.com/vanbaalon/mathematica-wstp-node
• Wolfram Engine (free): wolfram.com/engine

Author: Nikolay Gromov, King's College London — nikolay.gromov@kcl.ac.uk
License: Apache 2.0

Wolfbook is an independent open-source project, not affiliated with or endorsed by Wolfram Research Inc. "Wolfram", "Mathematica", and "Wolfram Language" are trademarks of Wolfram Research Inc.

Acknowledgements

Wolfbook was heavily inspired by and initially based on the official vscode-wolfram extension by Wolfram Research Inc. (Apache 2.0). The LSP client layer and kernel-finding logic originate from that project. The notebook frontend and the entire kernel backend have since been rewritten from scratch.

Special thanks to Ruben Myers for his help compiling the Unix build of the native binaries — the WSTP bridge and the btl math renderer are native addons that must be built per platform, and that work is what makes Wolfbook usable outside macOS and Windows.