Grab a chair before proceeding.
You’re about to access the full Coreflux platform. Some people report weakness in their knees upon first contact.
You’ve been warned.
Features
An episode of "Everything reminds me of Coreflux"
For centuries, sailors crossing the Mediterranean spoke a language none of them were born with. Italians, Spaniards, Portuguese, Arabs, and Greeks all used a simplified hybrid tongue to trade, negotiate, and not get killed in foreign ports. They called it the Lingua Franca. Different mother tongues. One shared language at the dock.
The same problem turns up everywhere people are in motion. In Porto, you order a café. In Lisbon, a bica. Up north, a beer is a fino. Down south, an imperial. Different words. Same drink. Someone in the middle has to understand both, or someone’s dying of thirst.
Connected systems have exactly this problem, and they don't have a tourist guide to translate. PLCs speak Modbus. Sensors speak MQTT. Databases speak SQL. Cars speak CAN. Energy meters speak whatever the vendor felt like that quarter. Every Thing speaks something. The cost is in the translation.
LoT is the Lingua Franca. The Language of Things.
If you've ever wired one system into another, you know the routine. The PLC speaks one protocol. The sensor speaks another. The database wants its commands in SQL but politely. The cloud API wants OAuth tokens and JSON payloads. The legacy machine speaks something no engineer alive remembers learning.
The traditional answer is to glue everything together with scripts. One in Python, one in C, one in Node-RED, one in whatever the contractor used that month. Each of them does a translation job, in a slightly different way, on a different machine, written by a different person, none of whom are reachable when something breaks at 3am.
By the time you have ten devices integrated, you have ten different translation approaches living in ten different places, none of them documented in a way anyone but the original author can read.
We built LoT because we wanted out.
LoT runs inside the broker. It is declarative. It reads like English. If you can read a SQL query, you can read LoT.
The language has four directives, each one covering a different job:
Actions.
Event-driven logic. Something happens (a topic updates, a timer fires, another Action completes), and an Action responds. Transform a payload, publish to another topic, fire an alert, call a Route. Actions are the verbs of the language.
Models.
The schema. Models define the shape of your data, so the raw mess coming out of a sensor or a PLC becomes a clean, normalized structure every downstream system can consume. Models inherit, compute fields, and validate inputs. They are how the broker knows what your data actually means.
Rules.
Access control. Who can publish, who can subscribe, who can manage. Fine-grained, multi-tenant, with the kind of permissioning that becomes essential the moment you give a contractor temporary access to production.
Routes.
Connections to the systems outside the broker. Industrial protocols, REST APIs, databases, AI agents, MCP, everything we covered last episode. Routes belong to the same language as Actions, Models, and Rules. Same syntax. Same surface.The four directives cover every kind of logic the broker can run. They live in the same document, written in the same syntax, alongside markdown documentation, so the engineer who joins next year can read what the engineer who left last year wrote. The code is the documentation. The documentation is part of the code.
(2)%202.jpg)
In the episode, Hugo demos this with a small factory. Multiple machines. Different brands. Different protocols. Different signals.
A normal factory like this means a normal integration project: middleware, gateway servers, custom translators, a few weeks of work, a documentation file that ages poorly. Hugo opens a single LoT notebook instead. Inside it: the Routes that pull data from each machine, the Models that normalize the signals into one shape, the Actions that calculate OEE and parts produced across every machine using wildcards. One Action covers every machine on every line. Type once, apply everywhere.
He clicks run.
The dashboard comes alive. Cycle times, part counts, machine status, all updating live. The calculations are not running in a cloud service or a separate analytics tool. They are running inside the broker, in LoT, on the same plane as the data itself. The system isn't sending data away to be processed. The processing lives next to the data.
"That's Coreflux and LoT," Hugo says. "Things, into one system that talks to itself."
It is the moment the broker stops being plumbing and starts being intelligent.
.jpg)
A Lingua Franca isn't a better language. It's the one everyone is willing to use. It's the one the trade depends on.
LoT is the same idea. It’s not just a better way to write industrial logic. It's the one place all your logic can actually live, regardless of which Thing you're talking to or which engineer is writing it. The PLC, the sensor, the database, the cloud API, the AI agent, the dashboard, the alert system: every one of them gets handled by the same syntax, in the same file, deployed to the same broker.
The translation tax goes away. The handoff between engineers gets cheaper. The documentation gets written because the code is the documentation. The new hire learns one language instead of seven.
The Things you connect can stay as different as they like. The system that connects them only needs one language.
(1)%202.jpg)
Hugo Vaz, our CEO and the person who built LoT before there was a VS Code extension for it, walks through the four directives and the factory demo in the third episode of Everything Reminds Me of Coreflux. João Barroso starts the conversation at So Coffee Roasters with André, talking about how the same drink has different names in every region of Portugal. An espresso cup travels from Porto to the studio. Hugo claims he hasn't run on blood since 2019.
You will probably believe him.
Try Coreflux for free 👉 https://www.coreflux.org/
.png)
