Getting Started

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.

Installation

This starts a server that hosts the notebook under the route "/notebook-name" and automatically opens it in your browser. You can also display the notebook directly in other environments like VSCode's plot pane:

Both methods run in the same Julia process as the parent, allowing you to edit and re-evaluate any file seamlessly.

Motivation

As the author of Makie.jl, I've faced challenges integrating its advanced features—like offline export, widgets, and interactions—across different notebook platforms in a stable and efficient way.

Over the years, as Bonito.jl (the Julia framework for creating HTML/JavaScript in Julia) has matured, I decided to build a completely Julia-native notebook system with a sharp focus on plotting and dashboards.

Bonito.jl brings significant advantages: all widgets are reusable, and notebooks can be easily rearranged into different formats, making the transition from notebook to polished dashboard effortless.

Another big motivation was to have a simple markdown file format which is human readable and can be checked into git without problems, so one doesn't even need to edit the notebook with bonitobook.

Comparison to Pluto

I love the team behind Pluto and the attention to detail that has been put into it, but Pluto itselve has never appealed to me. The Pkg integration and reactive workflow isn't working for me and that most of Pluto is implemented in Javascript instead of Julia doesn't fit my approach of "ecosystem first, notebook second" which I imagine for BonitoBook.

The final issue is, that the Makie integration has stalled - you can use Makie in Pluto, but WGLMakie isn't working as well as it could due to several reasons.

On the positive side, I think there's lots to share, we've been wanting to create a shared websocket serialization implementation and it should actually be easy to bring Pluto's reactive execution model to BonitoBook thanks to Pluto's modular approach in that regard.

Runs everywhere

Thanks to Bonito.jl's universal design, BonitoBook can be viewed across multiple platforms:

• VSCode Plot Pane

• Browser

• Electron applications

• Static Site (e.g. this site via Bonito.jl, or Documenter).

• Server deployments

• HTML displays (Pluto, Jupyter, etc...)

• JuliaHub

• Google Colab

Plotting with Makie

Since WGLMakie is also based on Bonito.jl, the Makie integration is seamless and supports all WGLMakie features including interactive widgets, observables and JavaScript integration. Here's a live example of an interactive 3D galaxy visualization, with the animation done in Javascript so it stays interactive without running Julia. The other plots shown in this notebook are not interactive in that way, and can only be interacted with when actually running the notebook with Julia.

Notebook format

The format is a simple markdown file with more config options and data stored in a separate folder. This keeps the notebook format fully compatible with markdown and makes it easy to edit it with other editors.

The a hidden folder structure looks like this:

                                              mybook.md                # Main content file
.mybook-bbook/           # Hidden folder structure
├── styles/
│   └── style.jl         # Custom styling
├── ai/
│   ├── config.toml      # AI configuration
│   └── system-prompt.md # Custom AI prompt
└── .versions/           # Automatic backups
    └── mybook-*.md      # Timestamped backups
└── data/             # Write out to `./data` to get included into the zip
    └── data.csv      # Any data needed for the notebook
                                            

Jupyter notebooks (.ipynb) are automatically converted to markdown files with the same name before setting up the notebook and creating the fodler structure.

Project compatibility

The parent folder of a notebook can contain additional files like a Julia project. This allows that multiple notebooks can share the same environment, which makes it perfect for integrating with your existing VSCode Julia projects and running a notebook alongside a VSCode setup:

                                              MyJuliaProject/
├── dev/                # Any Julia package checked out for development
├── Project.toml        # Julia dependencies
├── Manifest.toml       # Dependency lock file
├── mybook.md           # Book file
├──── .mybook-bbook/    # Hidden book structure
├── another-book.md     # Another book using the same project
├──── .another-bbook/
                                            

The zip export feature packages everything into a reproducible, shareable archive including the project environment and all associated data, which can be directly loaded by using book("path/to/zipfile").

AI Integration

The current implementation is based on a generic chat, which can use different chat agents to talk with. Those agents are currently installed as Package extensions on ClaudeCodeSDK and on PromptingTools. Install those and use them, to activate them. By default, if both are loaded, Claude Code is preferred, since the integration is better and the agentic features are just more mature.

Supports the common commandline modes

Julia native ecosystem

BonitoBook is built entirely in Julia using Bonito.jl, providing native performance and seamless integration with the Julia ecosystem.

With Bonito it's easy to create and share components. All BonitoBook components can be used outside the notebook, which will further extend the Bonito ecosystem for building interactive web applications Here is a quick example how one can make a simple checkbox widget in Bonito:

Note, you can include any css or javascript dependency in your widgets and Bonito will make sure they'll get included only once.

This is why we can e.g. use the editor widget in the notebook itself:

And why we can easily re-arrange any notebook into a completely different layout/form:

Full composability with existing Bonito apps

Any package defining Bonito Apps are working inside BonitoBook. This includes custom widgets, or whole applications.

BonitoBook.Components

BonitoBook includes its own component library—essentially the standard Bonito components with enhanced styling that integrates seamlessly with the notebook interface.

@manipulate

BonitoBook revives the beloved @manipulate macro from Interact.jl with modern enhancements. It works great together with Makie's SpecApi, which is the new declarative API for Makie.

LaTeX support

Excellent LaTeX support powered by MathTeX.

$$$\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}$$ $$\mathbf{A} = \begin{pmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{pmatrix}$$$

Python integration

Python support is powered by PythonCall and CondaPkg, enabling Julia-like dependency management. Cells share the same process and variables, creating seamless cross-language interaction.

Package management

Shared namespace

The shared namespace enables seamless cross-language workflows:

Rich MIME support

MIME support enables matplotlib plots to display automatically, perfect for mixed-language visualizations:

Sidebar system

Features collapsible sidebars for tools, file browser, chat, and custom widgets with configurable positioning and behavior.

@edit and Revise.jl support

Use @bedit in the notebook to open and edit files. With Revise.jl loaded, changes are automatically detected and re-evaluated.

Style customization

Customize your book's appearance by editing .name-bbook/styles/style.jl (accessible via the paint can icon):

Export/import options

Import formats

• Jupyter notebooks (.ipynb)

• Markdown files (.md)

Export formats

• export to standalone HTML file

• Markdown export

• Quarto export

• Ipynb

• PDF

Future

There are lots of plans for whhat can be done in the future.

• While I've been working quite a bit with BonitoBook to make sure everything works well, it's obviously still not battle tested and it will take a while to become rock solid.

• Rich markdown export for e.g. readme's (inlining output as image/svg)

• drag & dropping cells and changing their language

• Overview function for navigation

• Notebook store, where one can easily share their research

• Run notebook in another process for stability and interrupt.

• fixes for mobile CSS

• More config options for export

• Exe building of a notebook

• Better model agnostic agent tools implementation, so one isn't locked into an AI provider, while not loosing any features.

• Support display(...) inside for loop and have more examples on how to customize display behavior