Version 5.6 · The AI agent designs, programs and trains Sim to Real plants · Motor drives on every robot axis · Free add-ons · 465 nodes

Camera to inference to PLC — wired, not coded.

Cameo Image Studio is a node-graph workbench for machine vision. Drag a camera node, wire it into GPU inference, wire that into a PLC or a motion axis, and watch the whole line run — without writing a build script. When you do need code, the graph exports to C++, Python or a standalone EXE.

Download for Windows Windows 10/11 · 64-bit Request an activation key

Windows 10/11 64-bit only. Setup is a small download that pulls the rest — CUDA, PyTorch, OpenCV, ONNX Runtime and an embedded Python — while it installs, so there is nothing to set up by hand.

465nodes in the catalogue

9interface languages

5camera vendors supported

C++ · Pygraph exports to code

Hikvision MVS Basler pylon The Imaging Source MindVision Intel RealSense RTSP · MJPEG Mitsubishi MC Siemens S7 Omron FINS Modbus TCP TwinCAT ADS GRBL motion MQTT ONNX Runtime CUDA VLM · Qwen2.5-VL VLA agent Linux ARM64 ARMv7 Cortex-M STM32 Arduino Verilog C++ Python

AI assistant

The agent sits inside the graph

Not a chat window bolted to the side. The assistant builds the pipeline, runs it and tunes its own parameters until the inspection passes. A vision-language model answers questions about the frame on your own GPU, and a vision-language-action agent turns what the camera sees into machine moves — inside limits you set.

AI agent — thinks and builds

Turns one sentence into a working pipeline, runs it, looks at the result and fixes its own mistakes.

VLM — understands the picture

Answers plain-language questions about a frame — “is every worker wearing a harness?” — with no class list trained in advance.

VLA — turns sight into motion

Reads what the camera sees and the live state of each machine, proposes the next move of an axis, PLC or robot toward your goal, and reads the state back after every move — inside the limits you set.

Example session

Count the screws on the tray. Mark the tray NG if one is missing.

ReadsSearches the catalogue of 436 nodes and their operating notes, and picks LoadImage, Cameo_Threshold, Cameo_Blob_Analysis, Pass/Fail_Judge and Show Result.
BuildsCreates and wires the nodes. The batch is validated before it touches the canvas, with a snapshot to roll back to.
RunsRuns the pipeline on the 12 sample images.
LooksOpens the threshold output and sees the problem itself: two screws that touch are counted as one blob.
FixesAdds Cameo_Morphology to separate them, raises the threshold, and runs again.
Passes12 of 12 trays right — 24 screws on a full tray, and the tray with one missing is marked NG.

Illustration, shortened. The steps are the ones the agent takes on every job; the node names come from the real catalogue.

Knows all 436 nodesPorts, parameters and how to operate each one — before it picks a single node.
Sees its own outputOpens the image coming out of any node and judges it by eye, up to four frames a round.
Checks before it actsEvery change is validated, applied as one batch and rolled back on error. It does not report done while the graph still has errors.
Reads your specAttach a photo, or a PDF of up to 600 pages, and it takes the tolerances and inspection rules from it.
Fixes the setup tooCamera not found? It checks driver, link, discovery and subnet, can set the camera’s IP, and installs a missing Python environment or model.
Remembers, in your languageEach machine keeps its own memory between sessions. It answers in nine languages and shows its thinking as it works.

AI assistant

Describe the inspection, get the graph

The built-in assistant reads the node catalogue and builds pipelines from a sentence. It can see the frames your nodes produce, attach an image or a PDF spec, run the pipeline and read back the result — then change parameters and try again.

Creates nodes, wires them and sets parameters, with validation and rollback
Writes custom C# nodes for steps the catalogue does not cover
Runs against a licensed server — a per-machine key, no API key to manage

Vision-language

Ask the frame a question

Wire an image and a sentence into a vision-language node and read the answer off a port. Ask whether every worker on the scaffold is wearing a harness and the graph hands back a verdict, a violation count and the boxes behind it — with no class list trained in advance. The model is a Qwen2.5-VL 3B tuned for site safety, and it runs on the machine itself.

Yes/no verdicts, free-text answers and violation counts on typed ports
PPE and safety checks that track each person and re-check on an interval
Runs beside the detector, so the box and the answer come from the same frame
4-bit build fits in a 6 GB GPU and runs offline — no frame is sent to a cloud service

Vision-language-action

Type the goal. The machine moves — inside your limits.

The VLA Agent node looks at the camera frame and its detections, reads the live state of every machine on the canvas over that machine’s own link, and acts through those same nodes to reach the goal you typed. After each move it reads the state back and decides the next one: perceive, think, act, verify.

Drives motion axes over GRBL, Modbus and ADS, PLC tags, robots over TCP, GPIO, serial and MQTT
Dry-run, Confirm or Autonomous — the position window, step and speed limits are checked before a command reaches the drive
Never starts by itself: an interlock input or the E-STOP in VLA Studio stops every machine at once

Frame + detections

Live machine state

VLA Agent

GoalMove the X axis to the screw the camera sees, then close the gripper

Mode Dry-runConfirmAutonomous

Safety policy Position window · max step · max speed · interlock — refused before the drive sees it

AxesGRBL · Modbus · ADS PLCMC · S7 · FINS RobotTCP I/OGPIO · MQTT

Read the state back, verify, decide the next move

Graphs, running

Stills and screen recordings straight from the shipping build — no mock-ups. Every node previews its own output on the body, so each one shows what that step really produced.

PPE safety graph — **D455 → safe_detect → PPE Yolo Tracker → Show Result** A depth camera into a safety graph: safe_detect finds the people, the PPE tracker checks each one for a helmet and a harness — five tracked in this frame — and Height Above Ground 2D takes the same detections with the depth stream and raises its own violation flag.

RGB · D455 stereo depth · Cameo AI depth One RealSense D455, two depth maps of the same shot: the camera’s own stereo depth (top right) goes flat and drops out in patches past the first few metres, while the AI depth below reads that same RGB frame and still separates the floor, the columns and the scissor lift.

Laplacian filter at 183 fps — **Load Video → Filter: Laplacian → Show Result** A Laplacian on every frame of the same PCB clip at 1280×720. The loader’s own counter reads 183 fps with the filter in the chain — about 169 megapixels a second, on an AMD Ryzen 7 5000-series machine.

Load Image → Shape Detect → Show Result — all of it built by the assistant A sentence and a photo of the board: segment the rectangular chip. The assistant builds the three nodes, sets Invert, MinArea 8000 and a square/rectangle filter, and runs the graph — Shape: 0 found. It reads back its own overlay, works out that its own filter threw the chip’s contour away, clears it and runs again: a contour closed tight around the QFP.

What the graph can do

Five capabilities that normally live in five separate tools, on one canvas.

Node graph

One canvas, 465 nodes

Every operation is a node with typed ports: load an image, threshold it, find blobs, run a detector, gate on distance, write a coil. Wires carry frames, detections, poses, depth maps and numbers. Nodes preview their own output on the body, so you see where a pipeline goes wrong without stopping it.

Free-run threading — the pipeline keeps its frame rate while you edit
Undo, autosave and crash recovery on the graph itself
Run Mode: a locked, read-only operator screen with a results dashboard

Labeling

Label datasets where you use them

Annotate boxes and polygons, export to YOLO or COCO layout, and feed the result straight into a training node in the same project. Text-prompted segmentation (Grounded SAM) can pre-label a batch before a human touches it.

Bounding box, polygon, class filter with per-class confidence
Detects a LabelMe install and hands off to it when you prefer that tool
Frame stacking, crop-per-detection and super-resolution as dataset nodes

Auto-labelled detections on a street scene

Neural networks

Draw the network, then train it

A graphical designer for MLP and CNN layers, plus a YOLO-style block table that exports the same YAML the training toolchain expects. Load .onnx or .pth weights, run inference on the GPU, quantise to INT8 for an STM32 target.

ONNX Runtime with CUDA, falling back to CPU when no GPU is present
Detection, segmentation, pose, depth, anomaly detection and OCR nodes
Reinforcement-learning studio with 12 classical methods for tuning loops

Control

The result has to move something

Vision that cannot actuate is a demo. Wire a verdict into a PLC coil, a motion axis, a GPIO on a microcontroller or an MQTT topic. Firmware for STM32 and Arduino is generated, compiled and flashed from inside the app.

PLC: Mitsubishi MC · Siemens S7 · Omron FINS · Modbus TCP · TwinCAT ADS
Motion: GRBL, Modbus and ADS axes, soft motion, nine-point calibration
MCU/FPGA: STM32 (PlatformIO), Arduino (arduino-cli), Verilog (Vivado / Quartus)

Sim to Real

A virtual factory to program before the real one

Build a plant from conveyors, sensors, pushers, robot arms, AGVs, robot dogs and humanoids, write its PLC in ladder, structured text or C, and run it in 3-D with physics. Its tags, cameras and lidars feed every vision and AI node, and an operator HMI drives it — then switch the link from the simulation to the real PLC or robot.

Endless-grid stage or a warehouse hall; 17 graded exercises from start/stop to a humanoid courier
HMI built from the plant's own tags: lamps, switches, sliders, push buttons, trends, alarms
Camera monitor: live colour and depth of every virtual camera, PNG snapshots and video recording
Robot arms with a motor, gearbox and servo drive on every axis: drive each axis alone and read its torque, current, voltage, power and temperature live

Free add-on — download

HMI operator screen built from the plant tags

Robots & RL

Train robots on rough ground

A terrain generator lays out slopes, stairs, blocks, stepping stones and waves at rising difficulty. Legged robots put their feet on the ground, wheels refuse steps they cannot climb, and whatever tips too far falls over. The reinforcement-learning node trains on a hidden copy of your plant, then drives the live one through ordinary wires.

Humanoid, robot dog, wheeled and tracked vehicles with stations, path planning and safety fields
Q-learning, SARSA, Dyna-Q and more on the plant itself — state from its tags, actions to its I/O or robots
The built-in AI agent builds the scene, writes the program, trains the policy and lays out the HMI

Terrain training ground with a robot dog, a humanoid and a tracked vehicle

Humanoid robot: standing, walking, crouching, waving

Robot dog studio

Drive it, train it, judge it

A studio for the quadruped robot of Sim to Real. Steer it with a joystick across stairs, slopes and stepping stones while its footstep plan, speed and body angles update live; train a walking policy with PPO on graded terrain in the background; then let a judge course score every checkpoint before the best one goes to the robot.

Joystick drive with a live footstep plan, speed chart and gait strip
PPO training on a terrain curriculum: stairs, pits, hills, blocks, stepping stones, waves
Judge course: every checkpoint crosses each kind of ground at rising difficulty, results side by side

Robot dog studio: driving the quadruped across stairs with its footstep plan

Robot dog studio: the training ground and gait settings

Block Simulator

Model the dynamics, then run them in the pipeline

A block-diagram simulator with its own C++ engine. Draw a plant and its controller the way control engineers do — sources, scopes, gains, sums, integrators, transfer functions, state space, PID, discrete filters, saturation, relays, logic, lookup tables and subsystems — close the feedback loops, and solve with variable-step ode45 / ode23 or fixed-step solvers. A Block Diagram node then runs the model live inside the vision pipeline: a camera measurement goes in, the command for the motor comes out.

89 blocks in 12 libraries, vector signals, subsystems, Goto / From and parameters tuned while it runs
Scopes with zoom and cursor, XY graphs, CSV and PNG export; 8 example models from a DC-motor PID to two tanks in series
The AI agent builds, simulates and tunes a model, reading overshoot, rise and settling time off the plot

Free add-on — download

Block Simulator: speed control of a DC motor with a PID

Scope: levels of two tanks in series following their set-point

HMI Designer

Operator screens wired to every node

Draw the operator screen of a line from push buttons, switches, sliders, set-points, lamps, OK / NG, gauges, trends, counters, camera pictures, result tables and alarm lists. Each element links straight to the nodes on the canvas — a result, an output, a setting, a picture or a formula — and buttons set values, pulse triggers, call node actions, change screens or start and stop the line. The screens are saved inside the project.

19 kinds of element, several screens, tags, alarms with a log, an engineer PIN and a full-screen kiosk mode
HMI Control and HMI Display nodes carry values between the screen and the graph
Ask the AI agent for a screen: it links the elements by name, renders it and fixes what overlaps

Free add-on — download

HMI Designer: an operator screen linked to the nodes

Operator screen running: camera picture, OK / NG, buttons, set-point and alarms

IoT & phone

The result leaves the machine

A verdict that stays on the inspection PC helps nobody. Publish it to an MQTT broker with the frame attached, POST it to a webhook — Telegram, LINE, ThingsBoard, anything that reads JSON — or lay the phone screen out in the designer and hand the operator exactly the tiles you chose. Save, and any phone already open redraws itself in seconds.

MQTT publish (verdict, score, JPEG) and subscribe — a sensor or a push-button fires the pipeline
Value tiles, switches, buttons and camera pictures, grouped into tabs, installable as a PWA
A Screen tab mirrors the app window and sends taps back — LAN and a token by default, a PIN for that tab

Cameo Bus

A robot network like ROS, without ROS

Robots, Raspberry Pi and Jetson boards, PCs and Sim to Real plants find each other on the network and talk in topics and services, the way ROS does, with no ROS and no Ubuntu to install. Cameras, odometry and joint states go out; velocity commands and actions come back. The core is C++ and the Python library is a single file, so the same script can drive the virtual robot and the real one: only the namespace changes.

Publish / subscribe topics, services with progress and cancel, automatic discovery on the LAN, a domain key against strangers
Bus Subscribe, Bus Publish and Bus Call nodes bring a robot's camera into any vision pipeline and send the verdict or the command back
A monitor of every machine, topic and service with a live camera view; 15 Python examples, from keyboard teleop to following a red ball
Mixed versions still find each other: an older robot keeps talking to a newer PC

Cameo Bus monitor: the topics of a robot and its camera picture, live

What it talks to

Verified in the shipping build. Anything not listed here is not claimed.

Cameras & sources

Hikvision MVS (GigE / USB3)
Basler pylon
The Imaging Source (GigE)
MindVision USB
Intel RealSense (colour + aligned depth)
RTSP · MJPEG · HLS · HTTP
Image folders and video files

Control & fieldbus

Mitsubishi MC protocol
Siemens S7
Omron FINS
Modbus TCP / RTU
Beckhoff TwinCAT ADS / EtherCAT
GRBL motion
MQTT · HTTP request

Code & firmware targets

C++ standalone project
Python (runs on Linux)
Headless EXE deployment
STM32 (PlatformIO)
Arduino (arduino-cli)
Verilog / HLS (Vivado, Quartus)
IEC structured text and ladder for PLCs
Image library for ARM64, ARMv7 and bare-metal Cortex-M

Download

One setup file. It fetches the rest of the runtime while it installs.

Windows installer

v5.5

A small setup executable for Windows 10/11 64-bit. Run it and it downloads the runtime it needs.

Size: —
Released: —
Fetched on install: —

Download installer

SHA-256 —

Verify before installing: CertUtil -hashfile <file> SHA256

The free 6-month trial is only in version 5.3.1 and newer. Install 5.3.1 (released 1 October 2026) or later and the application activates a free 6-month trial the first time it opens — no license file, AI assistant included. That first launch needs internet. Older versions in the list above (5.3.0 and earlier) have no trial and ask for a license; if you installed one of them, install this version over it.

The machine needs internet while it installs. Setup downloads the core runtime as it runs. The optional add-ons — the Python environment, the Halcon and Hikvision SDKs, the bundled AI models and LabelMe — stay on the server until you switch them on under Tools > Components. Once installed, the application itself runs offline.

Not code-signed yet. Windows SmartScreen will warn you on first run. Check the SHA-256 above against your download before you click through that warning — that check is what a signature would have given you.

Free add-ons

Sim to Real, the HMI Designer and the Block Simulator are separate downloads, so each machine installs only what it uses. The application fetches them for you: Tools > Components / Add-ons > Download and install, then restart. Or download a zip here and choose Install from file in the same window. They need Cameo Image Studio 5.5 or newer.

Sim to Real

—

The virtual factory: conveyors, sensors, robot arms, AGVs, drones, robot dogs and humanoids with physics, a soft PLC in ladder, structured text or C, GPU rendering and reinforcement learning on many robots at once.

Size: —

Download add-on

SHA-256 —

HMI Designer

—

Operator screens for the line — buttons, switches, sliders, lamps, gauges, trends, camera pictures and alarm lists — with every element linked to the nodes. Saved inside the project.

Size: —

Download add-on

SHA-256 —

Block Simulator

—

Block diagrams of dynamic systems on a C++ engine — transfer functions, state space, PID, discrete filters, logic, lookup tables, subsystems — and a Block Diagram node that runs the model inside the pipeline.

Size: —

Download add-on

SHA-256 —

Cameo image library

The C++ image library the application itself runs on, packaged for your own programs. The modules import nothing but the operating system and the Microsoft C++ runtime — no OpenCV, no LibTorch, no BLAS.

Windows x64

—

One DLL per module, the single-file build the C# binding loads, import libraries, headers, and the C# and Python bindings.

Size: —
Modules: —

Download all modules (archive)

SHA-256 —

Linux x64

—

The same modules built as shared objects with g++ 15, plus the headers and the Python package. The C# binding loads the single-file Windows build, so on Linux the way in is C, C++ or Python.

Size: —
Modules: —

Download all modules (archive)

SHA-256 —

What you have to supply yourself. A license.lic at run time — the same file that unlocks the application — plus the Microsoft Visual C++ 2015-2022 x64 runtime on Windows. Nothing else: no OpenCV, no LibTorch, no BLAS. The P/Invoke table showing how to call every exported function ships inside, under csharp/.

Beyond Windows

The same library, running on the board

The application needs Windows. The library does not. The same C++ modules build for embedded Linux on ARM and for a Cortex-M with no operating system underneath — they import nothing but the C runtime, so there is no OpenCV, no BLAS and no Python to cross-compile first.

Linux ARM64

—

For 64-bit Cortex-A boards running Yocto, Buildroot or a Debian-based image — Jetson, Raspberry Pi 4 and 5, Rockchip, i.MX8. Shared objects, headers and the Python package, the same way in as the x64 build. The archive ships with a README, the headers, the cameo Python package and six worked examples showing how to call it from Python.

Size: —
Modules: —

Download all modules (archive)

SHA-256 —

Linux ARM 32-bit

—

The same modules for a 32-bit Cortex-A with hardware floating point — i.MX6, Allwinner, the older Raspberry Pi images. Shared objects, headers and the Python package. The archive ships with a README, the headers, the cameo Python package and six worked examples showing how to call it from Python.

Size: —
Modules: —

Download all modules (archive)

SHA-256 —

Cortex-M, no OS

Built inside the app

Nothing to download here. The application builds this target itself: pick the modules a bare-metal microcontroller can carry, and it compiles them for arm-none-eabi and links the static archive into the firmware it generates — the same flow that flashes STM32 and Arduino.

Get the application

What an embedded build is, and what it is not. It is the image library — filters, geometry, measurement, blob, barcode, OCR and the neural-network module — compiled for the target. It is not the application: the node editor, the training studios and the AI assistant stay on Windows. Inference on these boards runs on the CPU, since the modules carry no CUDA. At run time each build wants the same license.lic that unlocks the application.

Request an activation key

The application runs offline, but the AI assistant is licensed per machine. Install first, open Tools ▸ AI Settings, copy the Machine ID it shows, and send it with this form.

Or email us directly: [email protected]

System requirements

These are the requirements for the Windows application — there is no macOS build, and the Linux port of the application is not released. The image library is the part that leaves Windows.

Item	Minimum	Recommended
Operating system	Windows 10 64-bit	Windows 11 64-bit
CPU	4 cores, x86-64	8 cores or more
RAM	8 GB	16 GB or more
GPU	None — inference falls back to CPU	NVIDIA RTX 3060 or better, current driver
Disk	30 GB free (SSD)	60 GB free for datasets and recordings
Fetched by the installer	Visual C++ x64 runtime, Microsoft Edge WebView2, CUDA and cuDNN libraries, PyTorch, OpenCV, ONNX Runtime and an embedded Python environment. Setup downloads them for you — nothing to install by hand, but the machine needs a connection during the install.

Questions

How much does it actually download?

The setup file itself is small — the exact size and hash are on the download card above. During the install it fetches the core runtime: CUDA and cuDNN, PyTorch, OpenCV with GPU support, ONNX Runtime and a complete Python environment. That figure is on the card too. The optional add-ons are downloaded later, from Tools > Components, and only the ones you switch on.

Do I need a key to use the application?

The vision pipeline runs without one. The AI assistant is licensed per machine: you send the Machine ID shown in the app and receive a key bound to that computer. A key issued for one machine will not work on another.

Is the download signed?

Not yet. Code-signing certificates are being arranged. Until then, verify the SHA-256 hash published next to the download — it detects a tampered or truncated file just as reliably.

What format are project files?

Projects save as plain .json: nodes, parameters and links, readable in any text editor and easy to keep in version control. The .mcameo extension you may see is a separate tensor container used for model weights, not a project.

Can it run without a GPU?

Yes. Detection and segmentation fall back to CPU automatically. Expect a large speed difference — heavy models are usable on CPU for testing, not for line rate.

Is there a macOS or Linux build?

No macOS build exists, and there is no Linux build of the application. The C++ image library is a different matter — it builds for Linux and the .so are in the download section above. For a pipeline, the practical route to Linux today is to export it as Python or C++ from the Windows application and run that on the target.

Can any of this run on an embedded board?

The library can. It builds for embedded Linux on 64-bit and 32-bit ARM, and for a Cortex-M with no operating system, so the inspection itself runs on the device — the Embedded section above says what each target carries. The application stays on Windows: build and train there, then run an exported pipeline or your own program against the library on the board.

Will the VLA agent move a machine without asking?

Only if you set it to. A new VLA Agent node starts in Dry-run, which logs what it would do and moves nothing. Confirm asks Yes or No before every action. Autonomous acts on its own, but only inside the position window, step and speed limits you set — anything outside them is refused before the drive sees it. The agent never starts by itself, and an opening interlock stops every machine.

Do the vision-language nodes send frames to the cloud?

No. The VLM nodes run a local model on the machine’s GPU — the 4-bit build fits in 6 GB — so frames stay on the machine. The VLA agent is different: it thinks with the AI provider you choose in the settings, which can be a cloud service such as Gemini, OpenAI or Claude, or a local model through Ollama.

Tell us what you think

Found a bug, missing a node, or something worked well? Every message is read by the people who build the application.

Type

Overall rating

Your feedback

Name (optional)

Email (optional) Only if you want a reply.

Application version For example 5.3.1. Leave blank if you have not installed yet.

Used only to improve the application. Not passed to anyone else.

Wire your first pipeline tonight

One small installer for Windows 10 and 11. It pulls the runtime it needs while it installs, then runs offline.

Download for Windows Request an activation key