A Protected Core. Extensible Edges.
Why It Matters
Most industrial software fails in one of two ways:
It is either closed and rigid.
Or open and unstable.
Closed systems protect stability — but limit innovation.
Open systems enable experimentation — but compromise reliability.
In process control, neither extreme is acceptable.
You need both.
The Principle
UnicornOne is built on a simple architectural idea:
Protect the core.
Empower the edges.
The core remains:
- Deterministic
- Versioned
- Tested
- Stable
- Backward-compatible
The edges are:
- Extensible
- User-programmable
- Domain-specific
- Replaceable
- Evolvable
This is sovereign software.
The Protected Core
The core of UnicornOne governs:
- Control loops
- Logging
- Data integrity
- Configuration structure
- Device abstraction
- Communication handling
It is not modifiable at runtime by users.
Why?
Because this layer ensures:
- System safety
- Deterministic execution
- Reproducibility
- Traceability
This is the foundation.
Without it, nothing else is safe.
The Extensible Edges
Where innovation belongs is at the edges.
UnicornOne allows users to extend:
- Workbooks (AI-assisted workflows)
- Device plugins (custom hardware drivers)
- RHEED analysis modules
- Metrology filters and transforms
- Flux and modeling layers
Users can embed their expertise directly into the system.
Not by hacking the core.
But by building structured extensions.
Why This Matters for Labs
In most labs, knowledge lives in:
- One experienced operator
- A spreadsheet
- A half-finished script
- A notebook
- A custom tool built once and forgotten
With sovereign architecture:
That knowledge becomes executable.
Transferable.
Repeatable.
Stability Without Stagnation
The core remains stable across upgrades.
Your extensions remain compatible.
You do not lose work because of a version change.
You do not fork your own control system.
You evolve within structure.
Freedom Without Chaos
Extensibility does not mean anarchy.
All extensions:
- Run inside defined boundaries
- Interact through structured APIs
- Are logged
- Are versioned
- Can be disabled safely
Innovation without instability.
Why Sovereignty Is Necessary
Vendors cannot anticipate every research need.
Waiting for feature requests slows discovery.
Sovereign software gives researchers:
- Control over their tools
- The ability to encode new methods
- Freedom to experiment computationally
- Protection from architectural fragility
You are not locked in.
You are structured in.
The Deeper Philosophy
We do not sell AI as a black box.
We do not sell control as a closed appliance.
We build environments where:
Physics is encoded.
Knowledge is executable.
Intelligence is bounded.
Innovation is safe.
A protected core.
User-extensible edges.
That balance is not accidental.
It is architectural.
Bizmuth 