Vision application runtime deployment to a target machine

Your program compiles, runs on the development PC, and then will not start on the controller beside the line. The code is rarely the problem: the target machine is missing the runtime half of your vision library, or the license that lets it execute there. This guide lists everything that has to be installed and activated on a target machine, why a development license does not travel with the executable, and the steps, arithmetic and checks that get the deployment right the first time. If an executable already fails with a missing-component message, the vision application startup error guide narrows the cause. This guide plans the deployment so that message never appears.

What has to be on the target machine

A deployed vision application is a stack, and every layer has to exist on the machine that runs it:

• Your executable, plus its models, scripts and configuration files.
• The library vendor's runtime package, installed from the vendor's installer, at the version your build linked against.
• A runtime (deployment) license activated on that machine, through the vendor's documented activation procedure.
• The camera drivers for the interfaces you use: the network driver a GigE port needs on the target NIC, and the host controller driver a USB3 port needs.
• The operating system runtimes your build links against, such as the C++ runtime packages.
• Drivers for anything else the station drives, for example the serial or network interface of a light controller.

Every item comes from the vendor that owns it: the runtime installer and the license from the library vendor, the camera driver from the camera vendor. Anything assembled by hand on the build machine — a DLL copied out of an install folder, a driver borrowed from another project — is the first thing to fail during a line audit.

Why the development license does not follow the executable

Development seats and runtime seats are different products at every commercial vision library. The development license covers building and debugging on the machine where you develop. Running the built executable on a different computer is deployment, and vendor terms treat it as a separate right: one deployment (runtime) license per target computer on which the application runs. That rule is why a fully activated development PC proves nothing about the second machine.

Some vendors also sell a debug license for attaching a debugger to a deployed runtime; it is a separate item from both the development seat and the deployment license.

If you are still selecting the toolchain, the development environment comparison shows what the licensing models look like before you build on one.

What you need before you deploy

• One deployment license per target machine, from the library vendor.
• The runtime installer whose version matches the library your build linked against.
• Camera driver packages for every camera interface on the target.
• Administrator credentials, and a rehearsed offline-activation path if the machine never touches the internet.
• The application packaged with relative paths for its models and configuration.
• Time for a dry run: as a rule of thumb, half a day per machine the first time, under an hour once the image exists.

Deploy in eight steps

If the cameras arrive late, build and test the application against recorded frames first — the emulation guide covers development without hardware. Then deploy in this order:

1. Record what you built. Note the library name and version, the compiler and bitness, and the runtime packages the installer needs. Pin this set in writing; the version-pinning guide explains why one version everywhere prevents the classic build-versus-target mismatch.
2. Prepare the operating system. Install updates once, then switch automatic updates off — an unattended reboot mid-shift is a self-inflicted outage. Give the camera NIC a static IP and the machine a reliable time source.
3. Install the vendor's runtime package from its installer. The installer registers components and lays down prerequisites that a file copy misses; do not assemble the runtime by hand.
4. Activate the deployment license on that machine, exactly as the vendor's documented procedure describes — serial number, license file or code exchange. Do this before the machine is rack-mounted.
5. Install the drivers for your area scan cameras and connect each one. A GigE camera needs the vendor's network driver bound to the target NIC; a USB3 camera needs the host controller driver. Confirm every camera enumerates before moving on.
6. Deploy the application with relative paths for models, images and configuration. Absolute paths from the build PC are the most common reason a deployed program cannot find its files; the model file path guide covers the failure pattern.
7. Configure startup the way the line will run it: auto-login as the operator account, the application started as a scheduled task or service, a watchdog that restarts it after a crash.
8. Image the finished machine. A disk image of the installed, licensed, tested target is your spare-in-minutes recovery and the reference for the next station.

Worked example: count the licenses, budget the disk

A three-station line with one configured spare:

Adding a fourth station next quarter is one more license; rebuilding the executable changes none.

Now the disk on the license-included controller in the comparison below — 8 GB of memory, 128 GB SSD:

The 30, 3 and 10 GB figures are planning values — measure your own build. Each extra 10 GB of OS, models or local logs takes 2,000 frames off the archive (10,000 MB ÷ 5 MB). If the line archives more than that between maintenance windows, send the defect images to a network store instead of the local disk.

Choosing the target machine

An office desktop runs vision software; it is a poor target machine. A vision controller is built for the job: fanless construction for the electrical cabinet, network ports sized for machine-vision traffic, built-in light controller channels, and a specification you can hold stable across stations.

For a turnkey line where the runtime license should arrive with the hardware:

It ships with a VM6200Pro license included, so the runtime side of the license plan is settled before the box is opened.

If your application runs on your own deployed runtime, order the controller without the bundled vision software license:

Two more cover the ends of the range: the MV-VC2140-128G40-1T suits a single-camera station on an Intel N-series processor, and the MV-VC5525-256G70-NN carries PoE camera ports, 8 built-in light channels and 32 GB of memory for a multi-camera cell.

The four side by side:

All 4 share: Certification CE, KC. Values as printed in each product's data sheet; open a part for its drawing and full specifications.

Verify the deployment before it goes live

Test the machine the way it will run, not the way you built it:

• Run with the development tools absent — never install them on the target. A program that starts only when the SDK is present is still missing its runtime.
• Run under the line's user account, not your administrator account.
• Disconnect the office network. Anything that reaches out for a license check or model download should fail here, in front of you, not on day 30.
• Trigger 100 cycles and measure trigger-to-result time against the bench number.
• Power-cycle three times and let the watchdog do its work.

When part of the processing splits between camera and host, the edge inference deployment guide plans that division. If the executable still fails after all this, treat it as diagnosis rather than planning, and work through the startup error guide linked at the top.

Common mistakes

• Copying DLLs instead of installing the runtime. It skips registration, prerequisites and the license, so it fails both technically and contractually.
• Assuming the development license covers the line. It covers the build PC; every target needs its own deployment license.
• Driver gaps. A USB3 camera that enumerates but drops frames on the target usually has a host controller or bandwidth problem — the USB3 transfer error guide walks that diagnosis.
• Version drift. A runtime one minor version away from the linked headers can load and still misbehave; the SDK upgrade guide shows what breaks after a library upgrade.
• Testing only as administrator, then watching it fail under the operator account on day one.
• Re-imaging a licensed machine without reactivating. Activation is typically bound to the machine, so after a re-image, reactivate through the vendor's documented procedure before the shift starts.
• Blaming the license for every failure. After a clean deployment, runtimes still fail on infrastructure — an HMI runtime that cannot find its controller after an application deployment, for example, has its own documented diagnosis.

When the per-seat runtime is not the answer

Per-machine deployment licenses are the standard model for commercial vision libraries, but three cases change the math:

• Permissively licensed open-source libraries under BSD or Apache 2.0 — OpenCV is the workhorse example — carry no per-machine fee. You trade vendor support and some algorithm breadth for a runtime you can ship with the machine.
• Controllers that bundle a runtime license settle the license question at purchase, as the two variants in the comparison above show.
• On-camera processing moves the runtime onto the camera and leaves the controller as a pass-through; the trade is a compute ceiling per camera against zero runtime installs on the PC.

Whichever route you take, the discipline is identical: know the versions, keep the paths relative, and test without the development tools.

Pre-flight checklist

Before you order:

• License plan: one deployment license per machine that will run the application, spares included.
• Controller variant matches the plan: license-included for bundled software, unlicensed for your own runtime.

Before you ship:

• Runtime installer version pinned to the build.
• Camera drivers on the install media.
• Offline activation path rehearsed.

At the machine:

• Runtime installed from the vendor's installer, license activated, every camera enumerating.
• Application running as the line user, watchdog armed, disk image taken.

If you want the license plan and the controller list checked before you order, send the station count and camera interfaces through the system configurator or contact the applications team. The systems topic page collects the rest of the deployment and integration guides.