Jupyter

Executes individual notebook cells against a selected Jupyter kernel (Python, R, Julia, C#) running in a separate process, maintaining kernel state across cell runs. Uses the Jupyter Kernel Protocol (ZMQ-based messaging) to send code to the kernel, capture stdout/stderr, and return execution results. Each cell execution is isolated but shares the kernel's variable namespace, enabling incremental development workflows.

Renders Jupyter notebook cell outputs in multiple MIME types (text/plain, text/html, image/png, image/svg+xml, application/json, text/latex, application/vnd.plotly.v1+json, application/vnd.vega.v5+json) using a pluggable renderer system. The Jupyter Notebook Renderers extension (auto-installed dependency) provides built-in renderers for LaTeX, Plotly, and Vega visualizations. Custom MIME types can be registered via the notebook renderer API, enabling third-party extensions to add new output formats.

Tracks the execution order of cells within a notebook session, displaying execution numbers (e.g., [1], [2], [3]) next to each cell. Maintains execution history in the kernel's namespace, allowing cells to reference outputs from previously executed cells. Supports out-of-order execution (e.g., running cell 5 before cell 3), which can lead to state inconsistencies. Provides a command to clear execution history and restart the kernel.

Enables notebook editing and execution in web-based VS Code environments (vscode.dev, github.dev, GitHub Codespaces) by running the Jupyter extension in the browser. Uses VS Code's web extension API to provide a subset of local functionality, including cell execution against remote kernels (in Codespaces) or local kernels (in vscode.dev with local kernel support). Synchronizes notebook state with cloud storage (GitHub, OneDrive) for persistence.

Exports notebooks to multiple formats (HTML, PDF, Markdown, Python script) using nbconvert integration. Triggered via command palette (`Jupyter: Export as...`) or right-click context menu. Requires nbconvert package and optional dependencies (pandoc for PDF, etc.) to be installed in the kernel environment. Exports preserve cell outputs, metadata, and formatting based on the target format.

Provides a kernel picker UI (top-right notebook interface) and command palette command (`Notebook: Select Notebook Kernel`) to enumerate available Jupyter kernels on the local machine and switch between them per-notebook. Kernels are discovered via the Jupyter kernelspec system (stored in ~/.jupyter/kernels/ or conda env directories). Switching kernels restarts the kernel process and clears all variables, enabling multi-language workflows within a single notebook file.

Displays a sidebar panel (Variables Explorer) that introspects the active kernel's namespace and lists all defined variables, their types, and values. Uses kernel introspection via Jupyter's inspect protocol (sending inspect requests to the kernel) to retrieve variable metadata without executing user code. Supports filtering, sorting, and expanding nested data structures (dicts, lists, DataFrames). For pandas DataFrames, provides a tabular preview; for other objects, shows repr() output.

Reads and writes Jupyter notebook files (.ipynb) in the standard JSON-based Jupyter Notebook Format (v4.x). Automatically saves notebook state (cells, outputs, metadata) to disk after each cell execution or manual save. Supports importing Python scripts (.py) as notebooks via a conversion process that treats comments as markdown cells and code blocks as code cells. Exports notebooks to HTML, PDF, and Markdown formats via nbconvert integration (requires nbconvert package in kernel environment).

Provides a cell tagging UI (via Jupyter Cell Tags extension, auto-installed) that allows users to attach arbitrary tags (e.g., 'setup', 'test', 'slow') to individual cells. Tags are stored in cell metadata within the .ipynb file. Enables filtering and organizing cells by tags, and supports tag-based execution workflows (e.g., run only 'test' cells). Integrates with Jupyter Slide Show extension to support presentation mode based on cell tags.

Integrates with the Jupyter Slide Show extension (auto-installed) to convert notebook cells into presentation slides based on cell tags. Cells tagged as 'slide', 'subslide', 'fragment', or 'notes' are rendered as slides in a full-screen presentation view. Supports navigation between slides, speaker notes, and slide transitions. Uses reveal.js (JavaScript presentation library) for rendering.

Supports execution of code in multiple languages (Python, R, Julia, C#, and others) by delegating to language-specific Jupyter kernels registered in the system's kernelspec directories. Each kernel is a separate process that implements the Jupyter Kernel Protocol, communicating with VS Code via ZMQ sockets. The extension does not provide kernels; it discovers and manages existing kernels installed in the user's environment.

Provides code completion, parameter hints, and inline documentation within notebook cells by leveraging language-specific IntelliSense providers (e.g., Pylance for Python, R language server for R). Completion is triggered via standard VS Code shortcuts (Ctrl+Space) and displays suggestions based on the kernel's namespace and imported modules. Requires language-specific extensions (e.g., Python extension for Python IntelliSense) to be installed alongside the Jupyter extension.

Provides debugging capabilities for notebook cells by integrating with the Python debugger (pdb) and language-specific debuggers via kernel extensions. Supports setting breakpoints in cells, stepping through code, inspecting variables, and viewing the call stack. Requires the Python extension and debugpy package to be installed in the kernel environment. Debugging is initiated via the Debug Cell command or by running cells with breakpoints set.