This article is part of our Juliet&Romeo® series, where we explore the foundations of scalable, future-ready automation. In this post, we examine real-time capabilities, what’s missing in current approaches, and how Juliet&Romeo® enables new kinds of solutions.
Though hard real-time layers and capabilities are the core of automation systems, expressing and managing time-sensitive logic in a scalable way remains a challenge.
As systems grow across units, device types, and process complexity, the logic needed to coordinate behavior becomes:
Hard to express cleanly in traditional PLC environments
Difficult to verify and validate, especially as teams scale
Painful to test and maintain, particularly across commissioning and upgrades
That’s why many teams turn to soft real-time implementations built in high-level languages like Python or C++, just to regain control over structure and logic. But this creates new problems; loss of timing guarantees, increased integration risk, and inconsistent behavior of and between modules depending on how they are deployed.
PLCs are still the workhorses of automation, offering:
Deterministic real-time execution
High reliability under industrial conditions
Standardized (IEC 61131 programming environments)
But for modern applications, their IEC 61131 languages are not sufficiently expressive, and their toolchains aren’t built for modern software development. This is why many engineers are drawn to Python and similar languages, offering missing aspects like:
They offer clear, expressive syntax
Vast ecosystem support
Native integration with version control, CI/CD, simulation, and analysis tools
A familiar environment for software engineers and AI developers
But Python alone lacks real-time guarantees, and running it on top of PLCs creates new layers of complexity.
Juliet&Romeo® solves this by combining real-time guarantees with the flexibility of modern development models:
Juliet, the programming language, offers Python-like expressiveness, but with semantics built for real-time behavior
Romeo, the real-time virtual machine, guarantees predictable, consistent execution both for modules and for full deployments
Developers can describe and implement logic and algorithms, including motion, I/O, event-driven control, and AI-driven responses. This right next to the low level controls, without giving up readability or test-ability
The timing guarantees, multitasking, and reliability of the PLC world
The structure, clarity, and toolchain integration of Python-like development
The ability to scale across units, teams, and technologies,without architectural workarounds
Juliet&Romeo is made for co-existence. This means that legacy solutions in the PLC can be integrated and extended with new programming paradigms. This keeps earlier investment alive, while allowing continuous and maintainable incorporation of innovation.
When timing, logic, and structure are unified, you unlock more than fast response times: you enable automation that’s testable, scalable, and intelligent.
Reduce development and commissioning time by validating timing behavior early and deliver consistent system performance without fragile tuning
Reduce Enable maintainability and safe reuse of modules with deterministic behavior and easy to read expressive code
Automate more with AI closer to the process: low latency responses and low level expressiveness fits well for reactive and testable AI modules that can react to variety and unforeseen situations
Juliet&Romeo® isn’t just real-time capable, it’s real-time scalable.
It empowers teams to build and reuse expressive control and application logic that runs deterministically, without complexity exploding as systems grow.
You no longer have to choose between structure and speed, or between reliability and flexibility. With Juliet&Romeo®, you get both, right where you need it.
