The modular embedded Linux platform.
A runtime for applications built from separate processes and reached through many interfaces at once — on one host, by choice.
What Yoke is made ofWhat Yoke is
A runtime, and the frame for building on it, for applications whose logic lives in separate processes. One more process — the Core — launches them, watches them, routes their traffic and keeps their state, without understanding any of it. Outwards it publishes one versioned contract, and every interface — a page in a browser, a panel on the device, a command line, a native application — reaches the application through that contract and nothing else.
The problem
The same kinds of application are rewritten again and again, and each time the same plumbing is reassembled around them: a process supervisor, authentication, an event channel, a contract between screen and backend written nowhere but in the two bodies of code that must honour it. And “we also need a desktop version” becomes a new project rather than a new view.
Two claims
The repeated parts are a framework: supervision, lifecycle, authentication, an inventory of what is installed and allowed, fan-out to every interface — written once, and used. And the cost of isolation is not the cost of distribution: on one host the operating system already isolates, supervises and connects processes, so splitting logic across them should not cost a service mesh.
Who it is for
Whoever builds one of these writes only the units that hold its logic; everything around them is provided.
- the administration tool
- the front-end for an instrument
- the dashboard for a device
- the appliance installed on site
- the edge gateway
Two ways to run it
The same Core runs both. What differs is where the description of a deployment comes from, and what starts the process.
Ship a whole application as one file
- One file describes the application: its units, its interfaces, and how each of them starts.
- The manager installs it without touching system locations, and runs as many independent instances of it as a host is asked to — each with its own state and its own channels.
- Its parts are checked to fit each other and the host before anything runs, and verified again before every start; the author may sign it and seal it.
- The guardian keeps every instance in the state it was asked for. The boundary is the account that launched it.
Features
Write only the domain
Supervision, lifecycle, authentication, the inventory of what is installed and allowed, and fan-out to every interface are provided. You write the units that hold your logic, and nothing around them.
Isolation without the distributed bill
Separate processes contain crashes, keep what touches the hardware apart, and let each part be written in its own language — with no service mesh, no sidecars and no control plane, because one host needs none.
One contract, many interfaces at once
A browser, a command line and a native application reach the same instance through one published contract, and none of them — ours included — has a private route. Off the device, a channel is reached only over TLS 1.3 with a credential.
A declaration grants nothing
What a Plugin says about itself is kept apart from what an operator has authorized and from what it is seen doing, and nothing runs before it is admitted against the inventory. Who may reach a channel is decided by file permissions before a byte is read.
Five languages, held to one contract by a test suite
Go, Rust, Python, C and C++ each cover the plugin contract whole, in their own language's idiom, and Go the interface and administrative contracts too. A conformance suite says so, not a document: a capability one language offers and another lacks is a defect.
Built for appliances
Power can go at any moment: the next start reconciles whatever it finds. State is one local file you can copy. Packages are signed, a host trusts a set of keys so rotating one is an addition and a removal, and what was installed is checked again at every start.
Updates in the field
A new version installs beside the running one, migrates its data once when the layout changes, and refuses a rollback that would no longer read it — with the previous state kept to restore.
A panel on the device
Reference interfaces in Qt and LVGL, written with the C++ and C interface libraries, put the application on the instrument's own screen, started and supervised as part of it.
Into your Yocto image
A layer of recipes builds the runtime and an application into an embedded Linux image, so a device boots into it.
What Yoke is not for
Not a cluster
One host, by choice. No clustering, no failover, no horizontal scaling: the state is a local file with a single writer.
Not a framework for your domain
The Core supervises, routes and persists, and never decodes what a Plugin sends. What the data means stays in the Plugins.