Skip to main content
Glama

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 License: MIT OR Apache-2.0 Status: release candidate Platforms

🇬🇧 English · 🇫🇷 Version française

Inkboard

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).

Two browser guests and an AI agent editing the same board

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. Testers wanted: the 10-minute testing guide 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), 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.

  • Ready for AI agents. A built-in MCP server 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 tracks each of those requests.

Related MCP server: sketchdex

Install

Grab the installer for your system from the 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).

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 1.91 or newer.

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).

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).

  • 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

Dark theme

Icon library

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 (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). 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 · the web page · host your own relay.

Use it with AI agents (MCP)

inkboard-mcp is a Model Context Protocol 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:

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.

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).

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

The engine: document model, geometry, bound connectors, history, SVG export, auto-layout. No UI dependency.

inkboard-formats

draw.io, Excalidraw, JSON Canvas, Mermaid, PNG/PDF, LaTeX typesetting.

inkboard-app

The desktop app (egui), also built for the web (guest page).

inkboard-session

Live sharing: protocol, end-to-end encryption, host sequencer, guest client, network simulator.

inkboard-net

Network transport of sessions (QUIC with relay fallback, native and browser) and relay diagnostics.

inkboard-fonts

The fonts built into the app (identical text layout on every platform and in the browser).

inkboard-crowd

Load-testing tool: a real host and simulated guests.

inkboard-cli

The ink command-line converter.

inkboard-mcp

The MCP server.

inkboard-pen

Pen eraser detection on Windows (the only crate with unsafe code).

More: architecture and design decisions · roadmap · distribution and signing (French copies in docs/fr/). The original web prototype is kept in 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 or start a discussion — see also the testing guide and 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

Apache-2.0

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. 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.

Available Tools

27 tools
add_code_blockB

Adds a code block (monospace font, dark background, syntax highlighting).

Inputs: code (required), x, y, page, +1 more.

add_connectorA

Connects two objects with an arrow that follows them when they move (ids returned by add_shape or describe_board).

Inputs: to (required), from (required), page, path, +5 more.

add_formulaB

Adds a LaTeX formula (math mode) typeset the way TeX does. Errors if the LaTeX is not supported.

Inputs: latex (required), x, y, page, +2 more.

add_iconA

Places an icon of the library on the board, as an image object that can be connected with add_connector. icon is an id returned by search_icons. Size: size = longest side (default 64, 8 to 2000), or w and/or h (the icon's ratio is kept when only one is given). Monochrome icons (mono: true in search_icons) take the color stroke (default: the theme's text color); colored icons keep their own colors. label adds a text centered under the icon, grouped with it. Returns the image id (and label_id).

Inputs: icon (required), h, w, x, +7 more.

add_imageA

Adds an image (PNG, JPEG, GIF, WebP or SVG, 15 MiB at most) from a file (source, under the allowed root) or from base64 data (data_base64). The natural size is reduced to at most 600; w and/or h override it.

Inputs: h, w, x, y, +4 more.

add_pageC

Adds a page. Returns its number.

Inputs: name, path.

add_shapeC

Adds a shape with text (rect, ellipse, diamond, triangle, sticky = sticky note, text = free text). Returns the id.

Inputs: geom (required), h, w, x, +8 more.

add_tableB

Adds a table of cells; rows is a list of rows (lists of texts). The first row is the header.

Inputs: rows (required), x, y, page, +2 more.

arrange_objectsA

Aligns, distributes, stacks, groups or locks objects. align_*: at least 2 unlocked objects, aligned on their common bounding box. distribute_*: at least 3 unlocked objects, equal gaps between the two outermost (an error otherwise; the engine alone would do nothing). Locked objects are skipped by align/distribute and reported in skipped_locked. bring_to_front/bring_forward/send_backward/send_to_back change the stacking order (z of describe_board detail "full"). group (2+ objects, returns group), ungroup, lock, unlock.

Inputs: ids (required), action (required), page, path.

auto_layoutC

Rearranges the shapes joined by connectors into a layered graph.

Inputs: page, path, direction.

batchA

Runs several tool calls in ONE request (1 to 200 operations, in order), on one board, as a single undo step in the application. Use it to build or rework a board quickly instead of one call per object. Each operation is {"tool": "add_shape", "args": {...}} with the arguments the tool normally takes (but never path, output or source: the batch-level path applies to all). An operation can reuse what an earlier one returned: a string that is EXACTLY "$N.key" (N = index from 0 of an earlier operation, then keys or list indexes separated by dots, e.g. "$0.id" or "$3.ids.1") is replaced by that value of the result of operation N before the operation runs; text that only contains "$0.id" inside a longer string stays literal, and a text that is exactly like "$3.99" would be taken for a reference. An operation without page acts on the batch-level page (default: the first page), whatever the previous operations did. atomic (default true): at the first error everything already done is undone, the board is unchanged, and the error gives the operation index, its error and the results obtained before the rollback. With atomic: false the batch stops at the first error and keeps what succeeded, answering {applied, failed: {index, error}, results} (not an error). Success answers {results: [one result per operation], applied}. Not allowed inside a batch: batch, create_board, save_board, board_changes, export, render.

Inputs: operations (required), page, path, atomic.

board_changesA

Reports what the USER changed on the board since your last look (describe_board or board_changes): objects added, modified, deleted. Your own changes are not reported. The first call records a baseline.

Inputs: path.

create_boardC

Creates an empty board (.inkboard file).

Inputs: path (required), name.

delete_objectA

Deletes an object, or several with ids (connectors that were bound to them remain, detached). Give id or ids.

Inputs: id, ids, page, path.

describe_boardA

Lists the pages and objects of a board (id, type, text, position, connector links). In live mode, also reports the user's selection (selection). Also reads draw.io, Excalidraw, JSON Canvas and Mermaid files. detail: "full" adds each object's style, font, stacking order z, group, lock, rotation and (connectors) route and arrow; tables also list their cells.

Inputs: page, path, detail.

duplicate_objectsA

Copies objects, each copy shifted by (dx, dy) from the previous one (default 40, 40; count copies, default 1, 50 at most). Connectors between copied objects are copied and linked to the copies; a connector linked to an object that is not copied becomes free in the copy. Groups are copied as new groups. Returns sources (copied ids in page order) and ids (new ids: copy 1 in the order of sources, then copy 2...).

Inputs: ids (required), dx, dy, page, +2 more.

exportA

Exports a page to a file; the format is chosen by the extension of output: .svg, .png, .pdf, .drawio, .excalidraw, .canvas, .inkboard.

Inputs: output (required), page, path.

find_objectsA

Finds objects on a page without reading the whole board: by text, regex, type or area. Filters combine (all must match). text is a case-insensitive substring of a shape's text, a connector's label, a table's cells or a formula's LaTeX. in_region keeps objects whose bounding box overlaps the rectangle. Returns count (all matches), truncated (more than limit) and objects (same summaries as describe_board).

Inputs: page, path, text, type, +3 more.

format_textA

Formats text already on the board, like selecting it in the application: bold, italic, underline, strike, color, highlight. Works on a shape's text, a connector's label, or one table cell (cell). Choose the part with match (first occurrence; every one with all: true) or range [start, end) (character indices of the plain text, end excluded); with neither, the whole text. clear: true removes all formatting of the part first (then the other options apply). Returns changed: the number of characters whose formatting changed. Error if match is not found.

Inputs: id (required), all, bold, cell, +10 more.

import_mermaidA

Adds a Mermaid diagram (flowchart/graph, stateDiagram, sequenceDiagram) with automatic layout. Returns the ids created.

Inputs: mermaid (required), x, y, page, +2 more.

list_icon_groupsA

Lists the groups of the icon library (AWS, Azure, Brands...) with their sets and the number of icons of each, to know what to search for. Does not modify the board (a board path is still needed when the application is not open).

Inputs: path.

manage_pagesA

Lists, renames or deletes pages (add_page creates them). list returns number, name and object count. rename and delete need page (number from 1, or name); rename also needs name. The last page of a board cannot be deleted; deleting a page deletes its objects.

Inputs: action (required), name, page, path.

move_objectsA

Moves objects together. Either relative (dx, dy) or absolute (x, y: new top-left corner of the bounding box of all the objects, as update_object's x/y for one). Connectors bound to moved objects follow. Locked objects move too.

Inputs: ids (required), x, y, dx, +3 more.

renderA

Returns a PNG picture of the board (or of a part of it) as an image, to check your work visually. Read-only: the board, the file and the undo history are untouched. By default the whole page content is shown. region {x, y, w, h} (board units) shows exactly that rectangle; ids frames the given objects (plus padding) while still drawing their surroundings; give either, not both. show_ids: true draws a small white badge with the id of every visible object (top-left corner; middle of an arrow) so you can link what you see to the ids that update_object or add_connector expect (pen strokes get none). The longest side is max_px pixels (default 1400, 16 to 3000; a small region is enlarged 4 times at most); a PNG above 4 MiB is automatically produced smaller (said in note). output also writes the PNG to a .png file under the allowed root, for clients that do not display images. Text is measured approximately, as in export.

Inputs: ids, page, path, max_px, +4 more.

save_boardA

Saves the board displayed in the application (live mode; it must already have a file). No effect in file mode: every tool already saves there.

Inputs: no named parameters.

search_iconsA

Searches the built-in icon library (about 28,800 icons: AWS, Azure, Google Cloud, Cisco, Kubernetes, brand logos, UI and diagram symbols...) by keywords; names are in English. Every word of query must match (case-insensitive) the icon name, its set or its group. Returns ids to give to add_icon. Use list_icon_groups to see what the library contains, and group / set to narrow a broad search. Does not modify the board (a board path is still needed when the application is not open).

Inputs: query (required), set, path, group, +1 more.

update_objectA

Modifies an object: text, position (top-left corner), size (shapes), colors, line style, font, lock, rotation; a connector's route, arrowheads and ends; one table cell. Everything is validated before anything is applied (an error changes nothing); a parameter that does not suit the object's type is ignored and listed in avertissements. Locked objects can still be modified here.

Inputs: id (required), h, w, x, +21 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    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

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      A local-first whiteboard MCP server that enables AI agents to create, inspect, and update canvas diagrams and shapes collaboratively via 13 semantic tools.
      6
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Lets Claude, Codex, Cursor and other MCP clients draw hand-drawn Excalidraw diagrams on a local whiteboard, saving them as real .excalidraw files the agent can inspect, revise and undo. It also provides rendering to PNG, SVG import, and docs so agents can self-serve setup and troubleshooting.
      19
      53 npm
      1
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables MCP-capable agents to read, create, modify, align, distribute, organize and export local-first infinite whiteboard content, including sticky notes, text, shapes, arrows, ink, mind maps, images, files and links across multiple pages. Provides 16 tools over stdio or Streamable HTTP, plus resources and prompts, with version-conflict protection and audit trails so canvas edits never silently overwrite newer content.
      16
      25
      MIT