Wiznet makers

Thumbnail Image: AI-generated image

VovkPLCRuntime: a portable PLC virtual machine for Arduino-class boards, browsers, and W5500-based communications

Introduction

VovkPLCRuntime is an experimental PLC runtime library that runs a custom PLC virtual machine on Arduino-compatible boards, on desktop, and in the browser through WebAssembly. The public GitHub repository describes it as a runtime for executing custom dynamic bytecode, and the current ZIP snapshot expands that into a much broader toolchain: compiler headers for several PLC-oriented languages, a WASM worker build, web tooling, and optional communications layers including Modbus RTU, serial RS232, and W5500-based raw TCP/UDP. The public repository currently shows 0 stars, 0 forks, 185 commits, and no releases, which makes it early-stage publicly even though the uploaded ZIP snapshot is already technically ambitious. (GitHub)

Quick background

To make sense of this project, two short ideas help.

A PLC is a controller that repeatedly follows a simple cycle: read inputs → run control logic → update outputs. Even the repository’s README explains the runtime in that exact pattern, which is why the project feels familiar to automation engineers even though it runs on non-traditional PLC hardware. The wider PLC world standardizes common PLC language families under IEC 61131-3, including graphical forms such as Ladder Diagram (LD) and textual forms such as Structured Text (ST). (PLCtalk)

This project’s twist is that it does not try to clone one vendor PLC exactly. Instead, it defines its own stack-based virtual machine, its own bytecode, and its own assembly layer, then builds higher-level PLC-like languages on top of that. In the uploaded ZIP snapshot, that architecture is visible directly in the source tree: there are compiler/linter headers for ladder, ST, STL, PLCASM, PLCScript, and even a project compiler that ties them together. Uploaded ZIP snapshot

What this project is

AI-generated image

The public README still presents the repository modestly as a work-in-progress Arduino library, but the current ZIP snapshot shows something much larger than a single runtime class.

At a high level, the project contains four layers:

• a runtime engine that executes PLC bytecode,
• a compiler/linter toolchain that converts PLC-like languages into that bytecode,
• a WASM/browser path so the same core can run in a web environment,
• and a communications layer for talking to the outside world. Uploaded ZIP snapshot

That broader shape is reinforced by the public README, which says the library can run PLC logic on Arduino boards, on a computer as a standalone program, or in the browser using WebAssembly. It also explicitly mentions online debugging, fast program updates without recompiling the Arduino sketch, and a future direction toward a richer editor workflow. (GitHub)

The uploaded ZIP snapshot makes those claims more concrete:

• src/tools/runtime-* files implement the VM, program loader, memory model, and instruction handlers.
• src/tools/assembly/* contains compiler/linter headers for multiple PLC-style languages.
• wasm/ plus package.json provide a worker-based browser/runtime build and a large automated test matrix.
• examples/ and PlatformIO targets show the intent to support both very small Arduino boards and larger MCU boards. Uploaded ZIP snapshot

So the safest description is this: VovkPLCRuntime is not just a PLC sketch library; it is an experimental portable PLC execution platform.

Author & public footprint

The public GitHub profile identifies the author as Jože Vovk (Jozo132) and shows 21 repositories and 48 starred projects on the account overview. That alone does not prove an industrial product business, but it does show a wider technical footprint than one isolated repository. (GitHub)

More importantly, the public package footprint around jozo132 points in a fairly consistent direction:

• node-black is described as an “Emulated PLC runtime.”
• node-omron-read and node-omron-write are Node-RED oriented packages for reading and writing Omron PLCs over FINS Ethernet.
• vovk-udp is a simplified UDP library.
• vovk-sequencer is a promise-based sequential/parallel execution helper.

That matters curatorially because it suggests the author’s public work is not random. The visible pattern combines:

• PLC / automation communication
• runtime or emulation ideas
• JavaScript / Node.js tooling
• and lightweight networking utilities. 

In other words, VovkPLCRuntime fits a broader personal theme: bringing PLC-style control ideas into more open, software-driven environments.

How it works

AI-generated image

At architecture level, the project is easiest to understand as a pipeline:

PLC-like source language → custom compiler/linter → custom bytecode → stack-based PLC VM → I/O + communication adapters

That flow is visible in both the public README and the uploaded ZIP snapshot. The README emphasizes that a custom assembly language sits at the base of the system, while the ZIP reveals how much has already been built on top of it: ladder parsing, ST/STL compilation, PLCScript, project compilation, and WASM tooling. (GitHub)

For non-specialists, this means the project is trying to separate “what the control logic means” from “what board it runs on.” Instead of hard-coding one PLC language to one PLC CPU, the system compiles logic into a common internal bytecode and then runs that bytecode on a portable virtual machine.

That explains why the same project can target:

• Arduino-class boards
• desktop/native execution
• browser/WASM simulation

and multiple communication back ends. 

The README’s own loop example also keeps the PLC scan-cycle idea intact:

1. read inputs,
2. run the PLC program,
3. write outputs,
4. listen for external PLC commands. 

So although the implementation is unusual, the control model still feels PLC-native.

Communications architecture and the WIZnet path

The uploaded ZIP snapshot shows that communication is not bolted on as a tiny afterthought. There is a dedicated PLC Communication Protocol Manager in plc-comms-manager.h, and it defines a common instance model for multiple protocols. The enum already reserves IDs for:

• Modbus RTU
• Modbus TCP
• raw TCP
• raw UDP
• generic serial RS232 

In the current code snapshot, the concrete transport implementations that are clearly present are:

• plc-modbus-rtu.h
• plc-serial-rs232.h
• plc-ethernet-w5500.h 

That is an important distinction. The protocol manager is architected broadly enough for Modbus TCP and multiple transport types, but the visible Ethernet implementation today is centered on W5500-backed raw TCP/UDP, not on a finished lwIP-style IP stack layer and not on a separate visible Modbus-TCP transport module in this ZIP snapshot.

Why it matters

VovkPLCRuntime matters because it is trying to move PLC-style control logic away from a single fixed hardware target and toward a portable software runtime. That matters in industrial context because IEC 61131-3:2025 still defines the mainstream PLC language family—Structured Text, Ladder Diagram, Function Block Diagram, and SFC—while the wider automation industry is increasingly talking about software-defined automation, where control logic becomes more portable, open, and less tied to one vendor’s hardware. (iTeh Standards)

That makes this project more interesting than a small Arduino experiment. In the uploaded ZIP snapshot, it already combines four pieces that are usually split across separate tools: a runtime VM, a multi-language compiler layer, a browser/WASM path, and a communications layer. Even though it is clearly marked as experimental, the design direction lines up with the broader industry move toward more flexible, software-centric control systems. (World Economic Forum)

Market and industry context

AI-generated image

This repository should not be framed as a commercial PLC product today. Publicly, the GitHub repo still looks early-stage: it shows 0 stars, 0 forks, no releases published, and 185 commits. That suggests a technically active project without broad public adoption yet. (GitHub)

The relevant market context is therefore the broader PLC / soft-PLC / software-defined automation space rather than a direct “market size for this repo.” One current market reference places the global PLC market at USD 12.79 billion in 2025, rising to USD 16.4 billion by 2031, and specifically notes that soft PLCs are gradually becoming mainstream, with an expected 7.22% CAGR. That does not mean VovkPLCRuntime is in that market commercially today, but it does show that the direction—portable logic, software-defined control, and more flexible deployment—is aligned with a real industrial trend. (GlobeNewswire)

The stronger conceptual fit is with the automation industry’s push toward software-defined automation. Recent industry commentary from the World Economic Forum describes this shift as moving control away from rigid hardware-specific controllers and toward more open software platforms that can be updated and scaled more easily. In that context, a project that runs PLC-like logic on microcontrollers, desktops, and in the browser is not mainstream yet, but it is pointing in the same architectural direction. (World Economic Forum)

External value and author activity

The public author profile also gives this project more context. Jože Vovk (Jozo132) shows 21 repositories and 48 starred projects on GitHub, and the pinned repositories are not random: they include VovkPLCRuntime, LSR32IO (an SPI I/O expansion library for Arduino-compatible boards), node-omron-read (a Node-RED PLC interface for OMRON FINS), and vovk-serial. That is a fairly consistent public footprint around embedded systems, industrial communication, and software tooling rather than a one-off firmware drop. (GitHub)

That pattern is reinforced by the older package trail around the same author name. Public package listings show node-omron-read and node-omron-write as Node-RED modules for direct OMRON PLC communication over FINS Ethernet, both published about seven years ago, and node-black as an “emulated PLC runtime” package published about five years ago. These are small public projects, but together they make the theme clearer: the author has been experimenting for years with PLC communication, software PLC behavior, and lightweight automation tooling across both JavaScript and embedded-style environments. (npm.io)

That gives VovkPLCRuntime more external value than a completely isolated experiment. Even without commercial traction yet, it sits inside a visible pattern of work around open PLC-style runtimes, Ethernet/serial industrial communications, and developer-friendly tooling.

Quick notes

A few caveats are important.

The uploaded ZIP snapshot and README still describe the library as a work in progress and explicitly say it is not recommended for production yet. That should remain part of the curation tone.

The W5500 path is also worth describing carefully. In the current ZIP snapshot, the project does not use lwIP, and it does not pull in WIZnet’s official ioLibrary_Driver as WIZnet defines TOE usage. Instead, it wraps the Arduino Ethernet library’s W5x00 path (Ethernet.h, EthernetUdp.h, utility/w5100.h) in a custom non-blocking class. Architecturally, that makes the Ethernet side more Arduino-friendly and portable, but it is not the same as a direct TOE/ioLibrary integration.

Finally, the protocol manager is broader than the currently visible transport implementations. The code reserves IDs for Modbus RTU, Modbus TCP, raw TCP, raw UDP, and RS232, but the clearly implemented network transport visible in this ZIP snapshot is the W5500-backed raw TCP/UDP path, alongside serial and Modbus RTU. So the architecture is forward-looking, while the implementation maturity is still uneven.

Q. What is the VovkPLCRuntime project?

A. It is an experimental, portable Programmable Logic Controller (PLC) virtual machine. It allows developers to run custom PLC logic on various platforms, including Arduino-compatible microcontrollers, desktop computers, and web browsers via WebAssembly (WASM).

Q. How does it run PLC programs across such different hardware? 

A. It uses a custom compiler-to-VM pipeline. Instead of tying code to specific hardware, it compiles standard PLC-like languages (such as Ladder Diagram or Structured Text) into a custom bytecode. This bytecode is then executed by its own stack-based virtual machine, separating the control logic from the physical board.

Q. How does the WIZnet W5500 chip fit into this architecture? 

A. The W5500 provides the hardware backbone for the project's Ethernet communications (raw TCP and UDP). The runtime implements a smart socket-partitioning scheme on the W5500 to safely share network traffic between real-time PLC logic and background monitoring tools without blocking the main control loop.

Q. Does it use the official WIZnet ioLibrary_Driver or lwIP? 

A. No, it uses neither. Instead of direct TOE (TCP/IP Offload Engine) integration via ioLibrary_Driver or an lwIP stack, the project wraps the standard Arduino Ethernet library into a custom, non-blocking class. This makes the code highly portable and Arduino-friendly.

Q. Is this runtime ready for real-world industrial deployment? 

A. Not yet. The author explicitly marks it as an early-stage, experimental work-in-progress that is not recommended for production. However, it is highly relevant to the industry's current shift toward "software-defined automation" and hardware-independent soft PLCs.

References

https://github.com/Jozo132/VovkPLCRuntime
https://github.com/Jozo132
https://standards.iteh.ai/catalog/standards/clc/de0f79b4-a9fa-4739-9da0-25d4ce5f4a36/en-iec-61131-3-2025
https://www.weforum.org/stories/2026/02/software-defined-automation-the-force-awakens/
https://www.researchandmarkets.com/reports/6093231/lora-lorawan-iot-market-global-industry-size
https://www.globenewswire.com/news-release/2026/01/23/3224530/28124/en/Programmable-Logic-Controller-PLC-Market-Trends-and-Growth-Outlook-2026-2031-by-Product-Type-Component-Product-Size-End-user-Industry-Geography.html
https://npm.io/package/node-omron-read
https://npm.io/package/node-omron-write
https://npm.io/package/node-black
https://docs.wiznet.io/Product/Chip/Ethernet/SW_Resource/driver