quill

Notebooks as markdown. No JSON mess. Beautiful output.

why quill?

markdown notebooks

Your notebooks are markdown files with OCaml code blocks. Git-friendly. No JSON. No merge conflicts.

beautiful output

Plots render inline. Arrays display as tables. Everything from Raven just works.

integrated with raven

First-class support for nx arrays, hugin plots, and rune models. Everything displays beautifully.

web editor

Browser-based interface with syntax highlighting and live output. Or use your favorite editor.

show me the code

Jupyter 

# Cell 1
import numpy as np
import matplotlib.pyplot as plt

# Cell 2
data = np.random.randn(1000)
plt.hist(data, bins=30)
plt.show()

# Cell 3
print(f"Mean: {data.mean():.2f}")
print(f"Std: {data.std():.2f}")

QUILL 

# Data Analysis

Let's generate some random data:

```ocaml
open Nx
open Hugin

let data = randn float32 [|1000|]
```

Now plot it:

```ocaml
let fig = figure ()
let ax = subplot fig
let _ = Plotting.hist ~values:data ~bins:30 ax
show fig
```

Statistics:

```ocaml
Printf.printf "Mean: %.2f\n" (mean data);
Printf.printf "Std: %.2f\n" (std data)
```

how it works

Write your notebook as a markdown file: 

# My Analysis

Some introductory text about what we're doing.

## Load the data

```ocaml
open Nx

let data = Nx_io.load_npy "data.npy"
let () = Printf.printf "Loaded %d samples\n" (shape data).(0)
```

The data contains measurements from our experiment...

## Visualize

```ocaml
open Hugin

let fig = figure ()
let ax = subplot fig
let _ = Plotting.plot ~y:data ax
show fig
```

Then run it: 

# Start the web interface
quill serve

# Or execute directly
quill exec notebook.md

what's implemented

Quill is under active development. Here's what works today:

working now

  • ✓ Markdown parsing with OCaml blocks
  • ✓ Web-based editor with syntax highlighting
  • ✓ Text and plot output
  • ✓ Array visualization

coming soon

  • ⏳ Interactive widgets
  • ⏳ Export to HTML/PDF
  • ⏳ LSP integration in editor
  • ⏳ Cell-by-cell execution
  • ⏳ Rich media output (images, tables)

design philosophy

Notebooks are documents. A notebook is a markdown file. You can edit it in any text editor, version it with git, and read it on GitHub.

Code is code. OCaml code blocks are real OCaml. Your editor understands them. Refactoring tools work.

get started

Quill isn't released yet. For now, check out the documentation to learn more.

When it's ready: 

# Install
opam install quill

# Create a notebook
cat > example.md <<'EOF'
# My First Notebook

Let's do some math:

```ocaml
let x = 2 + 2
let () = Printf.printf "2 + 2 = %d\n" x
```
EOF

# Run it
quill exec example.md