One platform. The components you need.
Devs ex Macchina™ makes device and process values available as datapoints, used as the I/O layer for its applications. An external MES, web application, or service can also authenticate and read/write datapoints through a REST API, using only HTTP(S) and JSON. Any HTTP client can talk to the API; DEVS handles the industrial protocol details underneath.
Build applications and automation on that data using embedded JavaScript or Python scripts; use native C++ for a path with demanding timing requirements. Select the modules you need and run them on a small device, a local server, or in the cloud.
The application-facing interface
Read a datapoint with an HTTP GET. Write a writable value with a POST. Exchange JSON using the tools your application already has: a browser, a script, an MES integration, or a backend service.
No DEVS-specific client or industrial protocol library is needed in the consuming application. The server's modules handle the connection to the equipment.
DEVS also supports commonly used industrial protocols, including OPC UA and MQTT, for connecting equipment and applications that use those interfaces.
How this simplified an MES integrationInspect the RM:RHF struct,
open individual values, and follow live temperature trends.
46 seconds · Narrated · English captions. Use full screen for detail. Watch on YouTube.
One request, a complete equipment snapshot
Read furnace temperatures, billet count, and door status together.
The Rolling Mill application's RM:RHF struct groups
these values in one datapoint. Change format to read
it as JSON or hex. These responses capture one moment of operation:
a furnace temperature of 1,936 °F and 50 billets in the furnace.
Request
GET /device-api/datapoint/data/RM:RHF?format=json HTTP/1.1
Host: devs.example
Response
HTTP/1.1 200 OK
Content-Type: text/plain
{
"FURNACE_TEMP": 1936,
"BILLET_TEMP": 2054,
"BILLETS_IN_FURNACE": 50,
"FURNACE_ZONE1_TEMP": 1503,
"FURNACE_ZONE2_TEMP": 2106,
"FURNACE_ZONE3_TEMP": 2198,
"FURNACE_TIME": 3249,
"CHARGE_DOOR_OPEN": false,
"DISCHARGE_DOOR_OPEN": false
}
The struct becomes a JSON object with named fields and native number and Boolean values. The body is formatted here for readability.
Request
GET /device-api/datapoint/data/RM:RHF?format=hex HTTP/1.1
Host: devs.example
Response
HTTP/1.1 200 OK
Content-Type: text/plain
{"datapointMem": "900706083200DF053A089608B10C00000000"}
datapointMem contains the same struct's raw bytes,
encoded as hex. This struct occupies 18 bytes: six 16-bit integers,
one 32-bit integer, and two Boolean bytes. For example, the first
two bytes, 90 07, encode 1936 as a little-endian
16-bit integer.
Hex represents a memory layout, so interpreting it requires the field types, order, and byte order. JSON gives applications the named values directly.
devs.example stands for your installation's address.
Authentication headers are omitted from these examples; requests
use the installation's configured authentication and permissions.
Connect systems
Connect PLCs, sensors, and databases without building a separate application for every source. DEVS represents device values as datapoints, with a consistent way to read, write, and subscribe to changes.
DEVS modules connect to Modbus, OPC UA, MQTT, Siemens S7, Allen-Bradley, GPIO, and virtual devices. SQL query results can also be exposed as datapoints. Applications access the resulting values through HTTP(S) and JSON; WebSocket subscriptions provide change notifications.
Build applications
Describe what your application should do in App Wizard, or start with a selection of reusable parts. An AI coding agent helps build the interface and logic around your workflow.
Combine code, an overview screen, datapoints, control flows, SQL statements, trends, an assistant, and change tracking. Review the result, build a version, and install it in DEVS.
Start with a simple electric circuit: a source, a switch, and a motor. Describe how the switch turns the motor on and off, and let the AI coding agent build the interface and logic.
Keep developing with App Editor or the SDK. Package the finished application as a single bundle, ready to install in DEVS.
See what goes into an appWhat a DEVS app looks like
A DEVS app packages its code and resources in a single OSP bundle: a ZIP archive containing the interface, application logic, configuration, and supporting files. Bundles can also be digitally signed.
Build a simple app with App Wizard, then drag its bundle onto the DEVS launcher desktop to install it. Remove apps through the launcher's drag-and-drop workflow.
Underneath, POCO's Open Service Platform (OSP) resolves bundle dependencies and manages installation, startup, shutdown, and removal.
Read the OSP architecture overviewInside the application bundle
Build a simulated electric circuit with App Wizard: a source, switch, and motor. Inspect the generated code, run the app, and attach a Node-RED debug node to see values in real time. Then update the bundle, uninstall it, and drag it back onto the launcher to reinstall.
Watch on YouTube 3:06 — Live debugging 6:02 — Uninstall and reinstall
Automate operations
Use visual Node-RED flows and JavaScript to connect events, data, and actions. Process readings, apply application logic, query a database, and send results to connected systems.
The PumpStation application uses a visual flow to regulate pressure and stage pumps. For a different timing requirement, a customer's PLC-to-SQL loop uses native C++ on DEVS and completes in under 300 ms. Match the implementation to the job.
Package flows, scripts, and SQL statements with an application, and edit them through the browser as the process evolves.
Understand your operation
The Rolling Mill application connects the mill overview with its production schedule, billet records, finished coils and bundles, events, and delays. An operator can follow a work order and inspect what happened to a billet as it passed through the stands.
Add an application assistant with its own instructions, documentation, and tools for reading relevant data. DEVS supports configurable local and cloud AI providers, so you can choose where the assistant's model runs.
Watch the AI assistant answer production questionsDeploy at the right scale
Run DEVS on a small device or gateway close to your equipment, on an on-premises server, or in cloud and data-center infrastructure. Choose the deployment that fits your hardware, connectivity, and operational requirements.
Modularity starts with the platform: include the protocol drivers, services, and applications you need. It continues inside each application, where you choose its data, logic, interface, and supporting tools.
Start with a focused installation, add capabilities as requirements grow, and connect installations across locations through the DEVS mesh.
Connect remotely
Monitor, maintain, and support connected installations through integrated private remote access. Connect DEVS instances and authorized support users across locations.
The DEVS mesh uses WireGuard-compatible encrypted connections and our own Headscale-based coordination infrastructure. Selected services are made reachable over the mesh, with access policies controlling who can reach the connected networks.
Maintain control
Use accounts, roles, and permissions to control access to data, applications, and administrative functions. Integrate with local authentication or enterprise LDAP/Active Directory, and configure TLS for encrypted web access.
See how an application's scripts, SQL statements, flows, dashboards, and datapoint configuration differ from the shipped version. Review changes, keep version history with Git, and decide how local changes are handled when an application is upgraded.
Double Digital Twin · D2T
Double Digital Twin (D2T) pairs a production digital twin with an identical, real-time replica for development, testing, and staged deployment. The second twin starts with the same applications, configuration, and datapoint model as the running system.
The replica receives runtime updates as an ordinary live-data subscriber; production does not need to know the mirror exists. Its simulated devices also mirror the runtime state of their physical counterparts. Test commands act on those simulated devices, while the production twin retains its connection to real equipment.
Database replication brings production data into a separate staging database. Test queries, application workflows, and integrations with that data, while each twin uses its own database. Database writes made during testing stay in staging.
Subscribe to live runtime updates, mirror physical device state, and replicate production data into the staging database.
Try a new control flow, operator screen, database query, or integration. Device commands and database writes stay inside the staging environment.
Compare staging results with production, investigate differences, and promote the application version after validating its behavior.
A pump-station team can try revised staging logic in the second twin, using mirrored operating data and simulated pumps. They can inspect pressure, flow, and pump transitions before deploying the validated logic to the production twin.
Run a modified material-tracking service in staging alongside the production version, using mirrored runtime data and a replicated database. The modified service writes its tracking results to the staging database.
Compare those results with production for the same time period: material identities, processing events, and work-order associations. Investigate differences, confirm the intended changes, and validate the tracked data before deploying the service to production.
Built on POCO, DEVS connects three layers through consistent data and application interfaces.
Protocol modules and database services bring data into the platform. REST and WebSocket interfaces make it available to your applications.
JavaScript, visual flows, and SQL turn incoming data into application logic, automated actions, and information for other systems.
Web applications bring live data, controls, trends, and assistants together in an interface built for the people using the system.
Tell us about your equipment, workflow, and deployment. We can help you put the right DEVS components to work.