jupyter-repl

Run code interactively with Jupyter kernels.

Supports Python, R, JavaScript, and other languages with rich output including plots, images, HTML, and LaTeX. Each editor window has its own kernel indicator and command picker; an open picker retains the kernel it was opened for.

Features

• Interactive execution: run lines, selections, or automatically detected code blocks with inline results, multiple cursors, and smart Python/bracket/fold detection. Choosing None as the source grammar pauses source execution and removes inline results while existing kernels and standalone consoles remain available.
• Rich media output: renders Plotly, Vega, Bokeh and Panel charts, images, audio, video, HTTP(S) frames, safe HTML, Markdown, and LaTeX inline.
• Jupyter widgets: renders core ipywidgets, interact, output widgets and ipympl against the kernel, with custom anywidget modules in isolated frames.
• Kernel intelligence: autocomplete, object introspection, Python runtime source navigation through hyperclick, and a shared namespace with one kernel per language across files.
• Kernel management: starts local kernels, connects to remote gateways, and interrupts, restarts or shuts them down.
• Notebook adapters: drives external notebook cells, such as jupyter-view's, through the jupyter.adapter service.
• MCP automation: exposes explicit kernel and notebook execution with live UI results, source revision guards, bounded progress observation, and operation receipts that prevent duplicate runs.
• Typed source cells: renders literal Markdown locally, skips raw cells, and preserves cell magic headers when running selected body fragments.
• Jupyter console: attach a console in an embedded or system terminal.

Installation

To install jupyter-repl search for it in the Install pane of the Lumine settings, or run the command lumine --install lumine-code/jupyter-repl.

Commands

Commands available in lumine-workspace:

• jupyter-repl:run: run code at cursor,
• jupyter-repl:run-and-move-down: run and move to next block,
• jupyter-repl:run-all-inline: run all code inline, one statement at a time,
• jupyter-repl:run-all-above-inline: run all code above cursor inline,
• jupyter-repl:run-all-below-inline: run all code below cursor inline,
• jupyter-repl:recalculate-all-inline: clear results, restart kernel, run all inline,
• jupyter-repl:recalculate-all-above-inline: clear results, restart kernel, run all above inline,
• jupyter-repl:clear-results: clear output results,
• jupyter-repl:clear-and-restart: clear results and restart kernel,
• jupyter-repl:toggle-output-area: toggle output area mode,
• jupyter-repl:toggle-kernel-commands: toggle the active kernel's command picker,
• jupyter-repl:start-local-kernel: start a local kernel,
• jupyter-repl:connect-to-remote-kernel: connect to a remote kernel via gateway,
• jupyter-repl:connect-to-existing-kernel: connect to an existing kernel,
• jupyter-repl:interrupt-kernel: interrupt running execution,
• jupyter-repl:restart-kernel: restart the kernel,
• jupyter-repl:shutdown-kernel: shutdown the kernel,
• jupyter-repl:rename-remote-session: rename remote session,
• jupyter-repl:disconnect-remote-session: disconnect remote session,
• jupyter-repl:show-examples: choose an example file from a searchable list,
• jupyter-repl:edit-gateways: open gateways.json,
• jupyter-repl:shutdown-all-kernels: shutdown all running kernels,
• jupyter-repl:debug-toggle: toggle debug logging,
• jupyter-repl:open-terminal: open Jupyter console attached to active kernel in an embedded terminal pane,
• jupyter-repl:spawn-terminal: spawn Jupyter console attached to active kernel in a system terminal,
• jupyter-repl:copy-console-command: copy the Jupyter console command to clipboard,
• jupyter-repl:copy-result: copy a result's text or image to clipboard,
• jupyter-repl:open-result-in-editor: open a result's contents in a new editor,
• jupyter-repl:save-result-image: save a result's image to a file,
• jupyter-repl:toggle-result-expansion: expand or collapse a scrolling result,
• jupyter-repl:reset-result-size: return a dragged result to its natural size,
• jupyter-repl:close-result: remove a result.

The last six act on the result the command was dispatched from — its own context menu or its chrome — and otherwise on the result at the cursor's line.

Execution preparation has a default budget of 32 Mi UTF-16 units, configurable through jupyter-repl.maxExecutionSize and always bounded by the JSON transport's runtime ceiling. The budget applies to the code being prepared, so a small selected block remains executable in a much larger document. Oversized code or encoded messages fail explicitly before materialization or transport; code is never truncated. Kernel completion uses at most a 64 Ki prefix, and kernel magic-header detection uses at most 4,096 units from the first line. Traceback navigation retains only the executed rows, up to 1 Mi units and 4,096 rows, plus a source revision; larger executions remain runnable but omit that optional mapping.

Commands available in .jupyter-repl.kernel-picker:

• jupyter-repl:select-kernel: choose the selected kernel for the request that opened the picker,
• jupyter-repl:insert-kernel-comment: insert or update the kernel magic comment on the first line,
• jupyter-repl:refresh-kernel-list: rescan kernel specs and reload the list.

Commands available in .jupyter-repl.example-list:

• jupyter-repl:open-example: open the selected example with its default opener in the initiating window,
• jupyter-repl:open-example-with: choose how and where to open the selected example,
• jupyter-repl:open-example-external: open the selected example in its default external program,
• jupyter-repl:show-example-in-folder: reveal the selected example in the system file manager.

Saving an example in Text Editor asks for confirmation before overwriting the original file. Use Save As to keep a separate copy.

Documentation

Left click the kernel status item to open its command picker, or middle click to interrupt execution. Its context menu includes the picker, kernel lifecycle and remote-session actions, and console commands. Actions target the kernel shown in that window; recovering or unresponsive kernels offer restart and shutdown only.

Rendered in the editor under Settings, and readable here:

• Kernels — installing kernels, choosing between them, and remote gateways.
• Running code — what a run sends, what the results do, and the console launcher.
• Jupyter services and lifecycle — package responsibilities, owned requests, notebook adapters and provider/view teardown.
• IPython and Jupyter cells — write cell documents, use magics, configure Python analysis and convert notebooks.
• Tracebacks — follow verified source links and inspect folded library frames.
• Bokeh and Panel — configure isolated interactive chart output.
• Widgets — which ipywidgets controls render, and what happens to them when the kernel restarts.
• MCP tools — explicit kernel selection, live notebook execution, progress, cancellation and operation receipts.
• jupyter.kernel, jupyter.output, jupyter.execution — the service contracts.

Services

• background-tips.provider: provided to explain interactive execution in an empty workspace.
• jupyter.context: provided to resolve the invocation editor, source expression and cell range.
• jupyter.kernel: provided to let other packages execute code, request completions and introspection, and follow kernel state.
• jupyter.output: provided to let other packages render Jupyter output bundles with this package's renderers.
• autocomplete.provider: provided to feed kernel-backed completions to autocomplete consumers while a kernel is active for the editor.
• hyperclick.provider: provided to follow Python symbols to the source known by their running kernel.
• ipython.source: consumed to restrict runtime navigation in mixed IPython documents to their Python regions.
• jupyter.execution: provided to run pre-computed code blocks through this package's kernels and result bubbles.
• mcp.tools: provided to publish Jupyter kernel and execution tools through lumine-mcp.
• jupyter.notebook: consumed to resolve live notebooks by stable ID and capture their current source revision for MCP execution.
• jupyter.adapter: consumed to run cells of external pane items, such as jupyter-view notebooks, through the normal run commands.
• jupyter.cells: consumed to read cell boundaries and markdown-cell metadata where the run paths meet # %% markers.
• status-bar: consumed to display the kernel of the active editor and its execution state.
• terminal: consumed to run the Jupyter console in an embedded terminal pane.
• terminal-spawn: consumed to run the Jupyter console in a system terminal.
• image-editor: consumed to open image outputs in a full image editor.

Contributing

Got ideas to make this package better, found a bug, or want to help add new features? Just drop your thoughts on GitHub. Any feedback is welcome!