Skip to main content

I Built a Notebook Engine for C, and the Potential Is Incredible

· 3 min read
Eduardo J. Barrios
Eduardo J. Barrios
Software Engineer & Music Producer

I built a terminal-first notebook backend engine for C, and the results honestly surprised me.
The project started as a proof-of-concept, but it quickly became a strong validation that notebook-style workflows can work for low-level languages too.

Why Build a Notebook Engine for C?​

Most notebook experiences are designed for Python and data science. C developers usually jump between files, compile manually, and run full programs for every small experiment.

I wanted to test a different workflow:

  • write code in small cells
  • execute progressively
  • keep state across cells
  • save and reload sessions in a dedicated notebook format

That’s exactly what this engine does.

What I Built​

This project is a pure terminal backend prototype that lets you:

  1. create and edit sequential C cells
  2. concatenate them into a temporary source file
  3. compile and execute the combined program
  4. capture and persist outputs per cell

The implementation validates the core runtime model and notebook persistence mechanics.

The .cnb Format​

To make notebooks portable and structured, I introduced a custom extension: .cnb (C Notebook).

A .cnb file stores:

  • notebook metadata (like cell count)
  • each cell’s code
  • each cell’s captured output

This allows practical save/load flows while keeping the format human-readable enough for inspection and debugging.

Terminal Commands and Workflow​

Inside the terminal interface, the main commands are:

  • :save → save the current notebook state
  • :load → load a default notebook
  • :exit → exit the engine

The project currently focuses on backend execution and format integrity, which was the primary objective of this stage.

Why I Think the Potential Is Huge​

Even at prototype level, this unlocks powerful possibilities:

  • Rapid experimentation in C without heavy project scaffolding
  • Educational workflows where students can build concepts step-by-step
  • Research and systems prototyping with reproducible iterative execution
  • A foundation for a full frontend notebook experience

In short: C can benefit from notebook ergonomics more than people expect.

Current Scope (and What’s Next)​

This public repository is a backend proof-of-concept focused on validating architecture.
The full-featured notebook infrastructure I developed remains private for product and usability reasons.

Still, this backend confirms the core idea:

Notebook-style development for C is practical, extensible, and highly promising.

Final Thoughts​

Building this gave me confidence that there is real space for better developer tooling in systems languages.
If you’ve ever wanted Jupyter-like iteration with C performance and control, this direction is worth exploring.

This is just the beginning. 🚀