LabCraft

A graphical dataflow programming language and IDE, built in pure Rust.
Designed from the start to be written, run and fixed by people and AI agents alike. Ambition: to do at least what LabVIEW does, open and cross-platform.

Specification · Visual notation · Examples · Try it · Contributing

Status (2026-11-04): the first milestone in Rust has started, and nothing is usable in Rust yet.
The language and its text format are described (spec v0), with example programs. What runs today is
a set of throwaway Python tools, including a proof of concept that checks and runs the examples
against simulated instruments, and that an AI agent drives over MCP. The first milestone (M0: reading,
checking and writing programs, then running them, with a read-only diagram viewer alongside) is
described in docs/roadmap.md.

One program, two views

Diagram of read_voltage: visa.open, scpi.query_f64 and visa.close in a row on a red error wire, the VISA session as a blue wire, the raw reading converted to volts

The error wire (red) orders the actions and carries the error: if the measurement fails, the
nodes after it are skipped, except visa.close, marked always, which still closes the session
(blue). Values carry their physical unit ([V]).

The diagram is drawn from a text file, which is the format itself,
examples/read_voltage.lcf:

labcraft 1

use scpi
use visa

/// Reads the DC voltage of a multimeter.
fn read_voltage(resource: string, err: error = none) -> (voltage: f64[V], err: error) {
    dmm, e1 = visa.open(resource, timeout: 2 s, err: err)
    raw, dmm2, e2 = scpi.query_f64(dmm, "MEAS:VOLT:DC?", err: e1)
    #close: e3 = visa.close(dmm2, err: e2)
    voltage = with_unit(raw, [V])
    err = e3
}

The diagram was rendered from this file by a throwaway tool
(tools/lcf-figcraft), following the draft
visual notation; the editor does not exist yet.

An AI agent at work

An agent (Claude Code) writes a new function from a one-line request, using the proof of concept
over MCP: check finds a real error, the agent fixes it, the diagram is drawn from the text, and
the function runs against a simulated power supply.

An agent fixes a check error, shows the diagram of check_power, then runs it: 5.02 V x 0.30 A = 1.52 W, Pass

Try it

The proof of concept is in Python (3.11 or later):

pip install -r tools/lcf-poc/requirements.txt
python tools/lcf-poc/lcf.py check examples
python tools/lcf-poc/lcf.py run examples check_voltage --sim instruments/dmm-230V.toml --arg resource=SIM::DMM0

check reports errors with their line and node; run executes a function against a simulated
instrument and prints its outputs (here Verdict.Pass, 230.06 V). To let an AI agent drive it over
MCP, see tools/lcf-poc/README.md.

Documents

The language

Document	Content
docs/language-spec-v0.md	Language and file format, v0 (first draft): types and units, dataflow, errors, structures, grammar, open questions
docs/visual-notation.md	How a diagram is drawn: nodes, terminals, wire families, structures (first draft)
docs/cli.md	The command line: `fmt` and `check`, their reports and diagnostic codes (first draft)
examples/	Example programs (`.lcf` functions, `.lct` types), from a multimeter check to a test station state machine
docs/glossary.md	Terms used across the documents

The project

Document	Content
docs/vision.md	Why LabCraft, for whom, principles, differentiators, non-goals
docs/roadmap.md	Where the project stands, milestones from a first vertical slice in Rust (M0), planned code layout
docs/acceptance-m0.md	The scenarios that say when each part of M0 is done (M0a, M0b, M0v), and what they need written first
docs/architecture.md	How the Rust code of M0a is arranged, and the order of work
docs/decisions.md	The project decisions: options, recommendation, status
docs/alternatives.md	Existing products and what they teach us
docs/inspirations.md	Ideas to borrow (languages, compilers, tools, UX)
docs/craft-ecosystem.md	The Craft apps (storytold, SolidCraft) and what LabCraft takes from them

Throwaway tools and material

Folder	Content
tools/lcf-poc	Python proof of concept: check, run against simulated instruments, MCP server
tools/lcf-figcraft	Renders a function as a diagram, following the visual notation
tools/lcf-view	Syntax check of the examples and of the spec's code blocks
instruments/	Simulated instruments (TOML) for the proof of concept
design/	The board of the visual notation, drawn by hand, and the component library the renderer reads (FigCraft files)
docs/rfc/	Small programs discussed in the RFCs

Contributing

The language is not frozen: feedback from users of LabVIEW and other test and measurement tools is
what matters most right now. See CONTRIBUTING.md.

License

Your choice of MIT or Apache 2.0. LabCraft is an independent
project, not affiliated with NI; see NOTICE.