Free to evaluate · Runs offline|ESP32 • STM32 • RP2040 • AVR • Linux

NEW|Built-in MCP server for AI authoring

Build embedded controllers visually. Ship native C++.

SMFlow compiles a node-and-wire flow ahead of time into readable, native C++17 for your microcontroller — no interpreter on the device, and nothing from SMFlow running on it. Simulate on your desktop, then deploy to real hardware. An AI assistant can draft the flow through the built-in MCP server while you approve every change.

From visual flow to native firmware — deterministic, offline, and yours to audit.

Download Free (Up to 12 Nodes)Get Pro License — $500 Perpetual (intro)

The SMFlow editor: two Read Variable nodes fanning out to three Compare nodes, each feeding a Write Variable node, with the node palette on the left and the properties pane on the right. — Compiled ahead-of-time to native C++17 • Zero interpreter on the targetByte-Identical Generated Source

Positioning

The Right Tool for Embedded Control

SMFlow is for embedded developers and machine builders who need deterministic control logic on microcontrollers — without building and maintaining the entire control architecture by hand.

Building custom embedded machinery has historically forced a difficult trade-off between complex C firmware and expensive proprietary PLCs. SMFlow bridges that gap.

Option 1

Traditional C/C++ Firmware

Writing bare-metal drivers, manual timer loops, state machine enums, switch-case blocks, debouncing, and fault handling in C/C++.

✓ Maximum hardware flexibility

✕ Complex to maintain & reason about visually

Option 2

Industrial PLCs

Using IEC 61131 ladder logic / function block systems on dedicated industrial PLC racks.

✓ Deterministic scan execution

✕ Expensive hardware & proprietary vendor lock-in

Option 3

Node-RED / High-Level

Flow-based visual tools designed for Linux gateways, servers, cloud integration, and IoT dashboards.

✓ Intuitive flow-based model

✕ Not for real-time deterministic microcontroller logic

The Solution

SMFlow

Deterministic Visual Control

PLC-style cyclic execution and visual state machines running directly on low-cost modern microcontrollers.

✓ Deterministic & Visual

✓ Inexpensive Microcontrollers ($2–$30)

✓ Ahead-of-time Native C++17

Where SMFlow shines: When a traditional PLC is overkill for your machine or product, but hand-writing and maintaining a complete custom embedded C++ firmware stack is unnecessarily complex and time-consuming.

"PLC-style" describes the execution model — a cyclic scan with deterministic node ordering and visual state machines. SMFlow is not a safety-rated or certified PLC and does not replace independent safety engineering, hardware interlocks, e-stop design, or application validation.

Watch the Introduction

See SMFlow end to end

A 12-minute walkthrough of the flow-to-firmware workflow — design a graph, simulate it, and compile it to native C++. More walkthroughs land on the channel as they are recorded.

Watch “Introduction to SMFlow” on YouTube

Clicking play loads the video fromYouTube, which then sees your IP address. Nothing from YouTube loads until you click.

More videos on the SMFlow YouTube channel

Developer Experience

From Visual Logic to Running Hardware in Minutes

No toolchain configuration headaches, no complex RTOS boilerplate, no manual state machine tables in C.

Select Target

Choose your microcontroller target (ESP32, STM32, RP2040, Arduino Opta, Arduino Nano, Uno R3 or Mega 2560 (AVR), or Linux IPC).

Place Hardware I/O

Drag in digital inputs, analog sensors, I²C/SPI peripherals, or CAN bus receivers.

Define States & Logic

Add state machine transitions, debounce timers, interlocks, and safety conditions.

Simulate Live

Step through scan cycles on your desktop. Inspect variables, forces, and timings in real-time.

Deploy to Hardware

Hit Deploy. SMFlow compiles ahead-of-time to C++17 and flashes your microcontroller.

"I just programmed a complete multi-state microcontroller application without having to write the whole controller in C."

Deterministic Execution • Zero Interpreter Overhead • Full C++ Toolchain Compilation

Cascaded on-delay timers and interlocked gates stepping a machine through stages — feeders, indexers, test fixtures, and dispensing stations.

Reference Flow

Start → Stage Timers → Interlocked Gates → Actuator Outputs

View the reference project

New

Your Machine on the Plant Network

An SMFlow controller answers a SCADA system, an HMI, or another PLC directly overModbus TCP. There are no Modbus nodes to wire: the project declares a register map that binds shared variables to holding and input registers, and the flow reaches them through the variable nodes it already has. Encoding and word order are always declared, never inferred — word order is the most common way a Modbus integration fails on site.

The server’s own health comes back into the graph as read-only variables, so“the SCADA went away, fall back to a safe state” is ordinary logic rather than firmware you have to write. Hand the integrator a register sheet straight out of the editor as CSV or Markdown.

Conceptual Flow

Analog Inputs → Scaling → Shared Variables → Modbus Register Map → SCADA / HMI

Arduino Mega 2560 + WIZnet W5100 / W5500 · static or DHCP addressing

Hardware & Protocol Abstractions

Direct Hardware Interfaces Without Low-Level Boilerplate

SMFlow abstracts low-level registers into clean, deterministic nodes so you can focus on control logic.

GPIO & Digital I/O

Pull-up/down, debounce filtering, interrupt triggers, high-speed PWM.

Analog & ADC/DAC

Voltage reading, pressure/temperature scaling, moving-average filters.

I²C & SPI Buses

Hardware sensor communication, OLED/LCD displays, external memory.

UART & Serial

Telemetry streaming, RS232/RS485 modbus, custom protocol packets.

CAN Bus (Controller Area Network)

Frame filtering, vehicle/industrial telemetry, hydraulic valve control.

Modbus TCP Server

Shared variables served to a SCADA system or HMI as holding and input registers, with declared encoding and word order.

Ethernet (W5100 / W5500)

WIZnet controllers over SPI, addressed statically or by a DHCP client that never blocks the scan.

Timers & Clocks

On-delay, off-delay, pulse timers, deterministic scan cycle schedulers.

Visual State Machines

Named states, transition guards, entry/exit actions, fault states.

Logic & Arithmetic

Boolean gates, comparator thresholds, mathematical formulas, clamps.

Supported Microcontroller & Hardware Targets

Espressif ESP32 / ESP32-S3STMicroelectronics STM32Raspberry Pi RP2040Arduino Opta PLCArduino Nano & Uno R3 / ATmega328PArduino Mega 2560 / ATmega2560Linux IPCs (x64 / ARM64)Desktop Simulator

New — Built-in MCP Server

Your AI assistant can author the flow.
You still approve every change.

SMFlow ships a Model Context Protocol server — smflow mcp — that connects Claude, Cursor, VS Code Copilot, Cline, or Windsurf straight to the editor you have open. The agent reads the real node catalog, the real pin map of your real board, and the real validation diagnostics, then proposes a transaction. Nothing touches the graph until you click Apply.

How AI authoring works Download and try it

The authoring loop

1
Discover, never guess.
The agent asks for the node catalog, the supported targets, and the board's pins, buses, and device drivers. It authors only from what your build actually has.
2
Propose a transaction.
Add nodes, set properties, wire ports — submitted as one atomic proposal against a specific document revision, with a one-line summary a human can approve at a glance.
3
Review on the canvas.
The editor ghosts the proposed additions, edits, and deletions over your graph. Apply or Reject. Applied proposals land as a single labelled undo step — Ctrl+Z takes the whole thing back.
4
Validate, then build.
The agent reads the same compiler diagnostics you see and fixes its own errors before asking for a build. An invalid graph still refuses to generate code.

claude_desktop_config.jsonJSON-RPC over stdio

{
  "mcpServers": {
    "smflow": {
      "command": "smflow",
      "args": ["mcp"]
    }
  }
}

One entry, and the agent attaches to whichever editor session is running. For CI and headless workflows, smflow mcp --project ./project.smflowedits the file on disk instead.

13 tools

11 read · 1 mutate · 1 build

▪ list_node_types▪ list_targets▪ describe_target▪ read_graph▪ describe_project▪ get_diagnostics▪ list_devices▪ list_variables▪ list_examples▪ get_example▪ list_sessions▪ propose_changes▪ build

There is deliberately no deploy tool. Flashing a physical board stays a human action from the editor or the CLI.

Off by default

The editor listens on no port until you turn on Allow local automation in Settings.

Loopback only

Binds to 127.0.0.1 on an ephemeral port, with a per-session bearer secret and no CORS. Nothing reaches your machine from the network.

Never silently rebased

Every proposal targets a revision. Edit the graph while the agent is thinking and its stale proposal is rejected, not merged.

Engineering Efficiency & Maintainability

Why Engineers Pay for SMFlow

The value of SMFlow is not merely counting lines of code. It is radically reducing the cognitive load and engineering hours required to architect, test, deploy, and maintain deterministic embedded systems.

▪

Instant Visual State Reasoning: See every state, transition trigger, timer, and interlock at a glance instead of hunting through scattered switch-case blocks and nested ISR callbacks.

▪

Frictionless Project Handover: Hand your project to another controls or electrical engineer without spending weeks explaining custom firmware architecture.

▪

Mistakes Caught Before the Compiler: Type checking, hardware capability checks, and bus budgets are verified against the real board when you build. An invalid graph refuses to generate code instead of producing firmware that compiles cleanly and misbehaves on the bench.

▪

Modify Machines 6 Months Later: Open an existing controller project months after deployment, understand its exact behavior in seconds, and make updates with zero risk of breaking unrelated timing loops.

The AI & Embedded Engineering Reality

AI can help write code.
SMFlow helps you build the controller.

Large language models have made generating raw code cheaper than ever. But generating code is only a fraction of the embedded engineering challenge.

An engineer still needs to define safe state machines, guarantee microsecond timing, audit hardware interlocks, simulate edge cases, test physical actuators, and safely maintain machines in production.

# Core Principle
SMFlow provides the structured, deterministic environment that turns control intent into validated, deployable embedded logic.

Hard Invariants

Clean C++17 AOT Output.
No Target Interpreters.

SMFlow takes a strict compiler approach: your visual graph compiles ahead of time into readable C++17 that firmware engineers can inspect, audit, and trust. The same project always generates byte-identical source. The target device runs no Python, Node.js, JVM, or background interpreter.

▪Deterministic Cyclic Scan: Every scan cycle executes nodes in the same validated order — a fixed, allocation-free sequence with no interpreter scheduling. (Wall-clock timing depends on your board and toolchain; see the measured benchmarks.)
▪Static Memory Layout: Pre-allocated buffers, zero heap allocations in inner execution loops.
▪Byte-Identical Source: The same project always generates the exact same C++ source — no timestamps, no random IDs, no ordering drift. The final binary is whatever your own compiler and toolchain produce from that source.

See how a flow runs — the scan cycle

generated/controller_main.cppAhead-of-Time C++17

// Auto-generated by SMFlow ahead-of-time compiler
#include "smflow_runtime.hpp"

void step_cyclic_task() {
    const bool btn_state = hal_read_digital(PIN_DI1);
    const bool motor_cmd = !btn_state;
    hal_write_digital(PIN_DO1, motor_cmd);
}

int main() {
    hal_init();
    while (true) {
        step_cyclic_task();
        hal_wait_next_period_us(1000);
    }
}

Transparent Licensing

Try It Free. Upgrade for Commercial Projects.

Start building for free with the full node library. Upgrade to Pro for unlimited nodes and commercial rights.

Community & Evaluation

SMFlow Free

Fully functional and free forever. Build real projects, test hardware drivers, and evaluate the full workflow.

$0 / perpetual

✓ Up to 12 nodes per flow
✓ Full microcontroller target support (ESP32, STM32, RP2040, AVR, Linux)
✓ Full driver, peripheral & protocol ecosystem (GPIO, I²C, SPI, CAN)
✓ Modbus TCP server, up to 4 mapped variables
✓ Desktop simulator with live scan cycle inspection
✓ Visual IDE & standalone CLI tools
✓ Never takes files hostage (always open & edit any size project)

Download Free Edition

Professional Perpetual

Buy Once. Keep Using It.

SMFlow Pro

For engineers, machine builders, system integrators, and commercial controller developers.

$800$500 / one-time purchase

Introductory pricing — regular price $800

✓ Unlimited nodes per flow
✓ Unlimited Modbus TCP register map
✓ Commercial use rights included
✓ 3 device activations per seat
✓ 100% offline-capable after activation
✓ Cross-platform: Windows, Linux, macOS
✓ Headless CI/CD build agent support (`SMFLOW_LICENSE_DIR`)
✓ Zero runtime fees, zero royalties on compiled binaries

Buy Pro License ($500)