What Yoke is made of.
A Core per instance, the programs that install and keep it running, the tools an author builds with, and the interfaces that reach it — each with one job.
On the host
One process per instance. It launches the units, admits each Plugin against what the operator granted, routes their messages without reading them, keeps the state and the log, and serves the channels interfaces attach to.
Installs, validates, starts, stops and observes deployments, and reaches a running instance through the published administrative contract — grants, status, the log. Its shell is the same contract, interactive.
Brings each declared instance to its desired state and keeps it there. An init unit starts it when the host comes up; the manager starts it when nothing answers.
Asks the host's authentication service, once, whether a password is an account's, for the Core that runs it. It is the one dynamically linked program, so the Core stays static.
For authors
Makes a project, checks it with the same gate the Core applies, and builds a package from it — signed when given a key, sealed when given a credential.
One family per language — Go, Rust, Python, C and C++ — for writing Plugins, and in Go for interfaces and administrative tooling too.
Drives a real Core and a library's harness through every case of the contract it implements, and passes only when every cell does. It is what makes each family's coverage a fact rather than a claim.
Interfaces
A browser front for a channel: it signs in, attaches and drives the published contract — the same contract, through the same library, that anyone else would use.
Panels on a device's own screen, written with the C++ and C interface libraries, started and supervised as part of the application.
Into an image
Recipes that build the runtime and an application into an embedded Linux image, so a device boots into it.