Skip to main content
Glama
README.md
<p align="center"><img src="crates/inkboard-app/assets/icon.svg" width="96" alt="Inkboard logo"></p>

# Inkboard

**A fast, free, fully offline infinite whiteboard β€” written in Rust.**
Draw, diagram and present on a native desktop app, import and export the formats you already use, **share a board live with people on other networks (even from a web page, with nothing to install)**, and let an AI agent draw on your board.

[![CI](https://github.com/VictorLetirand/inkboard/actions/workflows/ci.yml/badge.svg)](https://github.com/VictorLetirand/inkboard/actions/workflows/ci.yml)
[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](#license)
![Status: release candidate](https://img.shields.io/badge/status-release%20candidate-orange.svg)
![Platforms](https://img.shields.io/badge/platforms-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)

πŸ‡¬πŸ‡§ English Β· πŸ‡«πŸ‡· [Version franΓ§aise](README.fr.md)

![Inkboard](docs/img/interface.png)

**Live sharing, from a web page:** two guests in a browser and the AI agent edit the same board, in real time (recorded with real browser guests and a real host: [`demo.mjs`](crates/inkboard-app/web/test/demo.mjs)).

![Two browser guests and an AI agent editing the same board](docs/img/live-sharing.gif)

> **Status: release candidate.** Inkboard is a young project: the 0.2.0 features are complete and being stabilized (releases are named `v0.2.0-rc.N`). It is feature-rich and heavily tested (over 850 automated tests), but it has so far been **used by hand on Windows only** (live sharing was also tried between several computers, an Android phone on 5G and a Linux server).
> Linux and macOS builds compile and pass the automated tests in CI, yet nobody has used the app there by hand yet, and the pen has not been validated on real hardware β€” expect rough edges, and please [report them](../../issues).
> **Testers wanted:** the [10-minute testing guide](docs/TESTING.md) tells you what to try and how to report it.
> The interface is available in **English and French**; it follows your system language and can be switched from the menu (*Language*).

## Why Inkboard?

Microsoft retired the standalone **Microsoft Whiteboard** apps for Windows, iOS and Android on October 16, 2026 ([announcement](https://support.microsoft.com/en-us/whiteboard/retirement-standalone-microsoft-whiteboard-apps)), and the web alternatives all want an account, an internet connection, or a subscription.
We wanted a whiteboard that is:

- **Offline and private.** No account, no cloud, no telemetry. Your boards are plain files on your disk.
- **Fast on big boards.** Complaints about lag on large boards come up again and again for Miro, Excalidraw and Whiteboard. Inkboard stays smooth with 100 000 objects (β‰ˆ 4.5 ms per frame).
- **Interoperable.** Open and export **draw.io**, **Excalidraw**, **JSON Canvas** (Obsidian) and **Mermaid**, plus SVG, PNG and PDF. Your work is never locked in.
- **Solid where other tools are fragile.** Connectors that really stay attached (and route around shapes), real tables, layers, rich text with per-word colour and highlight, LaTeX formulas typeset like TeX, customizable shortcuts, pen pressure.
- **Shareable without a server.** Click *Share*: your computer *is* the server. Guests join from the app or from a web page, see everyone's cursor (the AI agent's too), and everything is end-to-end encrypted. See [Live sharing](#live-sharing).
- **Ready for AI agents.** A built-in [MCP server](#use-it-with-ai-agents-mcp) lets Claude (or any MCP client) create and edit boards β€” live, in the open app, with every step undoable.
- **Free software.** Dual-licensed **MIT OR Apache-2.0**, built on a small, UI-independent Rust engine you can reuse.

Before writing a line of code we surveyed what users keep asking for in whiteboard tools (performance, fragile connectors, tables, layers, exports, offline use, pen support…); the [roadmap](docs/ROADMAP.md) tracks each of those requests.

## Install

### Download (recommended)

Grab the installer for your system from the [**Releases**](../../releases) page (release candidates are published as pre-releases until 0.2.0):

| System | File | Notes |
|---|---|---|
| **Windows 10/11** | `inkboard_*_x64-setup.exe` | Installs for the current user (no administrator rights needed). |
| **Linux** (x86-64) | `inkboard_*_amd64.deb` or `inkboard_*_x86_64.AppImage` | `sudo apt install ./inkboard_*.deb`, or `chmod +x *.AppImage && ./*.AppImage`. Needs OpenGL and X11/Wayland libraries (`libxkbcommon`). |
| **macOS** (Apple Silicon / Intel) | `Inkboard_*.dmg` | Drag *Inkboard* to *Applications*. |

The installers also provide the `ink` command-line tool and the `inkboard-mcp` server next to the app.

**On Windows**, download `inkboard_*_x64-setup.exe` and double-click it: it installs for your user in a few seconds (no administrator rights, nothing else to install first), adds a Start menu shortcut, and uninstalls cleanly from *Settings β†’ Apps*. Add `--silent` for a silent install. A `winget` package is being prepared (`winget install Inkboard.Inkboard`).

> **The installers are not code-signed yet**, so your system will warn you the first time:
> on **Windows**, SmartScreen says "Windows protected your PC" β†’ *More info* β†’ *Run anyway*; on **macOS**, Control-click the app β†’ *Open*.
> Every release lists SHA-256 checksums so you can verify your download. Code signing is ready to be switched on in the release workflow as soon as a signing certificate is available ([how](docs/DISTRIBUTION.md#signing-recommended-it-is-what-removes-the-windows-warning)).

**If the window does not open on Windows:** Inkboard uses OpenGL and falls back to Direct3D / Vulkan by itself; you can force one with the environment variable `INKBOARD_RENDERER=wgpu` (or `glow`). If it ever crashes, it writes `%APPDATA%\Inkboard\crash.log` and tells you where.

### Build from source

You need [Rust](https://rustup.rs) 1.91 or newer.

```bash
git clone https://github.com/VictorLetirand/inkboard.git
cd inkboard
cargo run --release -p inkboard-app                    # start the app
cargo run --release -p inkboard-app -- diagram.drawio  # …or open a file directly
```

To build the installers yourself: `cargo install cargo-packager --locked`, then `cargo packager --release -c Packager.toml` ([details](docs/DISTRIBUTION.md)).

## Features

- **Drawing:** pen with pressure, highlighter, eraser, rectangles, ellipses, diamonds, triangles, lines, arrows, sticky notes, text, images, tables, vote dots, laser pointer. Infinite canvas, pages, layers, groups, alignment and distribution, snapping, undo/redo.
- **Smart connectors:** arrows are *bound* to shapes and follow them; elbow connectors route around other shapes; drag a midpoint handle to add a waypoint.
- **Style:** drop shadow, arrowhead size, and any color of an imported SVG replaced by another (multicolor logos included).
- **Paste from a spreadsheet:** a range copied from Excel, LibreOffice or Google Sheets becomes a table.
- **Rich text:** select words inside any shape, table cell or arrow label and make them bold, italic, underlined, struck, coloured or highlighted.
- **Icon library:** about 28,800 icons and shapes, offline β€” AWS, Azure, Google Cloud, Cisco, IBM, Kubernetes, flowchart / BPMN / UML-style shapes, electrical and process symbols, mockup widgets, 3,400 brand logos and 14,500 general-purpose icons β€” searchable from the toolbar ([details and licenses](docs/ICONS.md)).
- **Formulas and code:** LaTeX typeset with the STIX Two Math font (fractions, roots, sums, integrals, matrices…), editable by double-click; syntax-coloured code blocks with a language picker (Rust, JavaScript/TypeScript, Python, C/C++, C#, Java, Go, Shell, SQL, JSON, HTML, CSS, YAML).
- **Present:** full-screen page-by-page mode (**F5**), countdown timer (bottom-right clock button), laser pointer (**F**).
- **Import / export:**

  | Format | Open | Save / export |
  |---|---|---|
  | Inkboard `.inkboard` | βœ” | βœ” (atomic save + autosave) |
  | draw.io `.drawio` (compressed or not, multi-page) | βœ” | βœ” |
  | Excalidraw `.excalidraw` | βœ” | βœ” |
  | JSON Canvas `.canvas` (Obsidian) | βœ” | βœ” |
  | Mermaid (flowchart, state, sequence, class, entity-relationship) | βœ” | – |
  | SVG, PNG, PDF (vector) | – | βœ” |

- **Customizable shortcuts** (41 commands, several shortcuts per command, conflict handling) and a **light/dark theme** that follows the board background.
- **Export dialog:** *Export as PNG / SVG / PDF* (and Excalidraw / JSON Canvas) asks which pages to export (all, none, current, or any ticked), "Selection only" and, for PNG, the scale. Several pages give one file per page in a folder chosen once (named `<board>-<NN>-<page>.<ext>`; the web build downloads them one by one), or a single multi-page PDF.
- **File extension:** boards are saved as `.inkboard` (a JSON file; the installer makes a double-click open it). Boards saved by earlier builds as `.inkboard.json` (and the prototype's `.tableau.json`) still open, and are saved back under their own name.
- **Command line:** `ink convert diagram.mmd diagram.drawio`, `ink convert board.inkboard board.png`, `ink info file.drawio`.

| Main menu | Dark theme |
|---|---|
| ![Menu](docs/img/menu.png) | ![Dark theme](docs/img/theme-dark.png) |

![Icon library](docs/img/icon-library.png)

## Live sharing

> **Beta.** Live sharing is new: it has been exercised by automated tests (including simulated crowds of up to 100 guests and hostile inputs) and by hand on a few devices and networks, but not yet widely.

Click **Share** in the bottom-right corner to get a link; people who open it edit the same board live.

- **No server to install.** Your computer hosts the session; nothing runs anywhere else, and nothing connects until you start sharing.
- **Join from the app or from a web page.** A guest with the Inkboard app pastes the link; a guest with only a browser opens the **web link** (button *Copy web link*): nothing to install, no account. The web page is a static page, [victorletirand.github.io/inkboard](https://victorletirand.github.io/inkboard/) (Chrome, Edge and Firefox are tested; Safari and iOS are not). It only joins sessions, it cannot host one.
- **Names and live cursors** for the host, every guest and the **AI agent** (its cursor and what it is doing are shown to everyone).
- **You stay in control.** You approve each person, with an *edit* link or a *read-only* link; new links cut off the old ones; you can rename, restrict or remove anyone. Default cap: 10 participants (designed for 20, load-tested with 100 simulated ones).
- **Private by design.** End-to-end encrypted: the relay that helps two computers find each other only sees encrypted bytes. A guest can undo only their own edits.
- **Works across networks.** Connections are direct when possible and go through a relay otherwise (a public one by default, [you can run your own](docs/RELAY.md)). Tried on Wi-Fi, on 5G and between Windows and Linux; it survives network cuts of a minute and reconnects on its own.
- **Honest limits.** Some company networks (TLS-inspecting gateways) block the public relay: the app then says so and offers a *Copy the diagnostic* button to hand to your IT department. Very large boards (20,000 objects and more) take a few seconds to reach a new guest; 100 guests work but are not a normal use. See [how to share and join](docs/SHARING.md) Β· [the web page](docs/WEB.md) Β· [host your own relay](docs/RELAY.md).

## Use it with AI agents (MCP)

`inkboard-mcp` is a [Model Context Protocol](https://modelcontextprotocol.io) server: an agent can create shapes, bound connectors, tables, code blocks, formulas, images and whole Mermaid diagrams, lay them out automatically, and export.
With Inkboard **open**, the agent edits the board you are looking at β€” each call is one undo step, it can see what you have selected, and it can ask what *you* changed since it last looked.
With Inkboard **closed**, it edits the `.inkboard` file and the app reloads it automatically.

With [Claude Code](https://claude.com/claude-code):

```bash
claude mcp add inkboard -- /path/to/inkboard-mcp --root /path/to/your/boards
```

**Always pass `--root`**: it confines every file the agent can read or write to that folder. The server exposes 29 tools (`add_shape`, `add_connector`, `import_mermaid`, `add_icon` (28,800 icons), `render` (the board as an image), `batch`, `export`, `board_changes`…) and MCP resources with change notifications.
Full reference, security notes and limits: [docs/MCP.md](docs/MCP.md).

## Platform status

| | Windows | Linux | macOS |
|---|---|---|---|
| Builds and passes the automated tests (CI) | βœ” | βœ” | βœ” |
| Web guest page (browser, nothing to install) | Chrome, Edge, Firefox tested | not tried | not tried (Safari **not tested**) |
| App launched and used by hand | βœ” | not yet | not yet |
| Installers | built and tested | built in CI, untested | built in CI, untested |
| Pen eraser end (Windows Pointer API) | βœ” implemented, **not yet validated on real pen hardware** | – | – |

Pen pressure and the eraser end are implemented and covered by tests but **have never been tried with a real pen**: run `inkboard --pen-test` for a diagnostic report ([how](docs/STYLET.md)).

## Performance

Measured on the release build with a synthetic board (60 % labelled shapes, 25 % strokes, 15 % bound connectors), continuous zoom and pan:

| Objects | Frame time (fit-to-screen) | Frame time (100 % zoom) |
|---|---|---|
| 2 000 | 0.8 ms | 0.3 ms |
| 20 000 | 3.3 ms | 0.3 ms |
| 100 000 | 4.5 ms | 0.3 ms |

Reproduce with `ink bench 100000 big.inkboard && inkboard --bench big.inkboard`.

## Project layout

| Crate | Role |
|---|---|
| [`inkboard-core`](crates/inkboard-core) | The engine: document model, geometry, bound connectors, history, SVG export, auto-layout. No UI dependency. |
| [`inkboard-formats`](crates/inkboard-formats) | draw.io, Excalidraw, JSON Canvas, Mermaid, PNG/PDF, LaTeX typesetting. |
| [`inkboard-app`](crates/inkboard-app) | The desktop app (egui), also built for the web (guest page). |
| [`inkboard-session`](crates/inkboard-session) | Live sharing: protocol, end-to-end encryption, host sequencer, guest client, network simulator. |
| [`inkboard-net`](crates/inkboard-net) | Network transport of sessions (QUIC with relay fallback, native and browser) and relay diagnostics. |
| [`inkboard-fonts`](crates/inkboard-fonts) | The fonts built into the app (identical text layout on every platform and in the browser). |
| [`inkboard-crowd`](crates/inkboard-crowd) | Load-testing tool: a real host and simulated guests. |
| [`inkboard-cli`](crates/inkboard-cli) | The `ink` command-line converter. |
| [`inkboard-mcp`](crates/inkboard-mcp) | The MCP server. |
| [`inkboard-pen`](crates/inkboard-pen) | Pen eraser detection on Windows (the only crate with `unsafe` code). |

More: [architecture and design decisions](docs/ARCHITECTURE.md) Β· [roadmap](docs/ROADMAP.md) Β· [distribution and signing](docs/DISTRIBUTION.md) (French copies in [`docs/fr/`](docs/fr)).
The original web prototype is kept in [`prototype-web/`](prototype-web/); its `.tableau.json` boards can be opened in Inkboard.

## Roadmap

Planned or wanted next:

- **More interface languages** β€” English and French are built in; adding one means adding a translation table (see `crates/inkboard-app/src/i18n_fr.rs`).
- Code-signed installers (Windows via SignPath, macOS notarization) and automatic updates.
- Validation of pen pressure and eraser on real hardware; pen eraser support on macOS/Linux.
- First real-world usage on Linux and macOS, and fixes that come out of it.
- Real LaTeX beyond what the typesetting library supports; per-language code highlighting.

Have an idea or found a bug? [Open an issue](../../issues/new/choose) or start a [discussion](https://github.com/VictorLetirand/inkboard/discussions) β€” see also the [testing guide](docs/TESTING.md) and [CONTRIBUTING.md](CONTRIBUTING.md).

## License

Inkboard is free software and is **dual-licensed**: you may use it under **either** of the two licenses below. **You choose one**; you do not have to follow both.

| | [MIT](LICENSE-MIT) | [Apache-2.0](LICENSE-APACHE) |
|---|---|---|
| Use it, including in a commercial product | βœ” | βœ” |
| Modify it and redistribute it | βœ” | βœ” |
| Keep the copyright and license notice | βœ” | βœ” |
| Explicit patent license from the contributors | – | βœ” |
| Length of the text | very short | longer |

*Which one should I pick?* Either is fine. MIT is the shortest and simplest; Apache-2.0 adds the explicit patent grant. This table is a plain-language summary, not legal advice: the two license files are the reference.

Third-party components keep their own (permissive) licenses: see [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md).
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Inkboard shall be dual-licensed as above, without any additional terms or conditions.

TDQS

B3.4/5.0

Scored across 27 tools

Disambiguation4/5

Each tool has a clearly stated purpose, and the add_* family is cleanly split by content type (shape, icon, image, table, code, formula, mermaid). A few boundaries blur: update_object also moves/locks a single object while move_objects and arrange_objects handle the same properties in bulk, and export vs render vs save_board are close but disambiguated by whether they return a file, a picture, or just persist state.

Naming Consistency4/5

Nearly all names are snake_case verb_noun (add_shape, delete_object, find_objects, manage_pages, search_icons). A handful deviate: export, render, batch are bare verbs and board_changes is a noun, and manage_pages is a multi-action catch-all, but the overall pattern remains readable and predictable.

Tool Count3/5

27 tools is on the heavy side for a drawing app; the surface could likely compress (separate add_table/add_code_block/add_formula/add_icon tools, plus manage_pages subactions). Still, each tool maps to a real distinct capability rather than filler, so it is only borderline over-scoped.

Completeness4/5

Coverage is strong: board creation, object creation across all content types, update/delete/move/arrange/group/lock/duplicate, page management, search, formatting, import/export, rendering and a batch meta-tool. Minor gaps only: no explicit undo/redo or clipboard-style cut/paste tooling, which agents must emulate via duplicate_objects and batch atomicity.

Maintenance

ActivityMaintained
ResponsivenessLimited data