Notebooks

Notebooks are a type of Integrated Development Environment (IDE) accessed through the web-browser, where code at text are interleaved. They are particularly useful for sharing and showing computations.

Jupyter (IJulia)

Julia kernel for Jupyter

Jupyter is the original notebook. The name is a reference to the three core programming languages supported by Jupyter: Julia, Python and R^[1]. It It is very mature, and used by a large community. This should probably be the first one you try.

A Jupyter notebook is organized in "cells". Cells can contain either text (in markdown format) or code. The code is evaluated in the kernel as if you were entering the same code into a Julia session.

The Colab service makes it easy to test Jupyter without needing to install anything locally. It also includes a Julia kernel.^[2]

The main kernels supported by Jupyter are :

• Python: IPython (the default kernel shipped with Jupyter)

• Julia: IJulia.jl

• R: IRkernel, ark (a new kernel developed by Posit (previously RStudio) for the Positron IDE)

Pluto

🎈 Simple reactive notebooks for Julia

Where Jupyter is multi language (and mainly Python), Pluto.jl is a Julia project and mainly (only?) supports Julia.

It also differs from Jupyter in the execution model. Where the state of the Jupyter kernel depends on the order in which cells were run, Pluto maintains a consistent state, where all cells are updated in a reactive manner.

An other difference is that cells in Pluto only contain a single line of code.

Many people are very happy with the Pluto model, where the state is always consistent (like in a spreadsheet). Others prefer the linear execution model of Jupyter notebooks, which is more similar to an interactive Julia session, but where you often need to "restart the kernel and run from the top" to make sure all is consistent.

You can test Pluto in the browser without installing it at https://binder.plutojl.org/.

The author of Pluto.jl gave a talk (YouTube link) at JupyterCon 2023, which is a good demonstration of how to use Pluto.jl.

Neptune

Simple (Pluto-based) non-reactive notebooks for Julia

From the README:

Neptune originated as a fork of the Notebook platform Pluto, for those (like Data Scientists) who have requirements which conflict with the 'reactive' aspect of Pluto (where all cells re-evaluate every time a single cell is evaluated or re-evaluated). It may turn out to be that Neptune is only an interim solution, and that the capabilities it enables will eventually exist within the Pluto, but that it is not certain. Users with projects or applications which are not logically sequential or linear in execution/design, or which do not load external scripts, should first try Pluto.

See also announcement.

BonitoBook

BonitoBook excels in plotting, customizability, ai integration and language interoperability, making it perfect for exploring data, building dashboards and any other interactive application.

BonitoBook was announced in 2025 by Simon Danisch who is also the main author of Bonito and Makie. It integrates very well with Makie, and part of the motivation for BonitoBook seems to be that Makie support in Jupyter and Pluto is limited.

BonitoBook uses the linear execution model as Jupyter.

From the website:

BonitoBook is a Julia-native interactive notebook system built on Bonito.jl that seamlessly combines multi-language execution, AI integration, and modern web-based editing in one powerful platform.

License

Note that BonitoBook is not under a free license, but the PolyForm Noncommercial License.

Quarto

Open-source scientific and technical publishing system built on Pandoc.

Quarto developed by Posit PBC (formerly RStudio).

As Jupyter, Quarto is not a Julia project, but supports a Julia kernel as well as Python and R.

A quarto document is written in Markdown with metadata in YAML code in code-blocks.

From the README: Quarto is an open-source scientific and technical publishing system built on Pandoc. Quarto documents are authored using Markdown, an easy to write plain text format.

In addition to the core capabilities of Pandoc, Quarto includes:

1. Embedding code and output from Python, R, Julia, and JavaScript via integration with Jupyter, Knitr, and Observable.

2. A variety of extensions to Pandoc Markdown useful for technical writing including cross-references, sub-figures, layout panels, hoverable citations and footnotes, callouts, and more.

3. A project system for rendering groups of documents at once, sharing options across documents, and producing aggregate output like websites and books.

4. Authoring using a wide variety of editors and notebooks including JupyterLab, RStudio, and VS Code.

5. A visual Markdown editor that provides a productive writing interface for composing long-form documents.

Learn more about Quarto at https://quarto.org.

Visual Studio Code (vscode) extension: julia-vscode

Julia extension for Visual Studio Code

vscode is the most popular editor for editing Julia code. Julia is well supported through the julia-vscode extension.

Vscode also has support for editing (an evaluating) Jupyter notebooks.

Positron

Positron, a next-generation data science IDE

Positron is a fork of vscode optimized for data science. It supports Julia through the IJulia.jl Jupyter kernel, but there is room for improvement.

From the README:

What is Positron?

• A next-generation data science IDE built by Posit PBC

• An extensible, polyglot tool for writing code and exploring data

• A familiar environment for reproducible authoring and publishing

Star History