Orthevs Engineering Lab · OSEL

Operating systems as versioned products instead of individual installations.

The Operating System Engineering Lab connects Blueprints, package sources, image builds, provisioning, fleet operations, security and recovery across the entire Day 0 to Day N lifecycle.

Documented target state · Concept / Architecture Baseline

Domain application · target architecture

Independent engineering environment

The Lab is designed as a complete domain application with a workspace, editors, models and SDK-like interfaces. Its Factories are the specialist tools; Engines handle processing and execution. Shared Contracts connect it with other Labs.

Engineer operating systems, kernels, packages, distributions, images and VM tests.

From Engineering Contract to verifiable outcome

  1. 01

    Contract & Foundation

    Requirements and rules select the domain foundation.

  2. 02

    Lab Workspace

    Models, editors and tools address the domain problem.

  3. 03

    Factory & Engine

    Specialist tools create artifacts and use suitable execution mechanisms.

  4. 04

    Validation & Product

    Tests, evidence and approvals lead to a versioned outcome.

The workflows and capabilities shown describe the documented target model. Check availability and maturity for each release and capability.

Mission and ambition

An OS release is an auditable product bundle.

OSEL describes operating systems declaratively: distribution, package versions, roles, policies, images, installation methods and support boundaries are versioned rather than improvised host by host. Through build, test, approval and signing, a Blueprint becomes an immutable release candidate.

The Lab develops neither its own kernel nor a new distribution. It integrates established package managers, installers, image builders and configuration management systems through adapters. Linux forms the first reference path; Windows and specialized systems follow with explicit feature matrices.

OSEL combines immutable image pipelines with controlled mutable configuration management. This makes visible which state is owned in the image, at bootstrap or later in operation, and prevents competing ownership between tools and Labs.

Capability map

Twelve domains structure the Operating System Engineering Lab.

The domains organize responsibility and lifecycles. Within them, Factories deliver clearly bounded, versionable capabilities.

1 · OBF · OCTF · OCF · OPF

OS Architecture & Product Design

Define OS products, profiles, compatibility and catalogs with clear support boundaries.

2 · DRF · KEF · PKF · SRF

Sources & Package Engineering

Manage package sources, dependencies, custom packages and kernel configuration reproducibly.

3 · APF · ICF · LOF · IBF

Image & Distribution Engineering

Compose, build, package and publish images for different target media.

4 · BPF · CIF · ISF · PRF

Bootstrap & Provisioning

Combine installers, PXE, cloud initialization and OS provisioning into repeatable workflows.

5 · NCF · ORF · SFF · SCF

Configuration & Role Engineering

Apply system, network, storage and role profiles to hosts in a controlled manner.

6 · HIF · CMF · OHF · VSF

Identity, Security & Compliance

Integrate host identity, hardening, compliance, vulnerabilities and SBOMs into the lifecycle.

7 · HQF · OTF · PBF · RCF

Verification & Qualification

Demonstrate bootability, hardware suitability, performance and release quality before promotion.

8 · FDF · HEF · IDF · RSF

Delivery & Fleet Deployment

Distribute images, enroll hosts and steer rollouts with rings and halt criteria.

9 · HLF · IUF · OUF · PMF

Patch, Upgrade & Lifecycle

Coordinate patches, major upgrades, immutable updates and host lifecycle with a recovery path.

10 · BRF · DTF · DGF · HMF

Operations & Reliability

Bring together monitoring, drift, diagnostics, backup and restore for managed hosts.

11 · AHF · CHF · EEF · VHF

Specialized OS & Hardware

Represent container hosts, virtualization, edge, embedded, GPU and HPC as dedicated profiles.

12 · OAF · OIF · OLF · OWF

Developer Experience & Automation

Offer OS workspaces, pipelines, automation and integrations through the same APIs.

Use cases

OSEL starts with the complete engineering problem.

The scenarios combine several Factories into one dependable flow. They describe the documented target state, not a product function that is already committed.

1Golden Image

Publish a verified Ubuntu image

An OS Blueprint is validated against schema and policies, package sources are frozen, and the image is built in isolation, then booted, integration-tested, scanned and signed. Only a passed gate promotes the candidate into a release channel.

  • Repository snapshot and locks
  • Boot and integration test
  • SBOM, signature and promotion
OBF → SRF → ICF → IBF → OTF → VSF → APF
2Fleet Security

Roll out critical patches ring by ring

Advisories and inventory determine the affected hosts. OSEL creates a plan that requires approval, updates a canary ring first and extends the rollout only when health and SLO gates are passed.

  • Impact from real inventory
  • Canary and halt criteria
  • Recovery instead of blind retry
VSF → PMF → RSF → HMF → BRF
3Platform Nodes

Update Kubernetes workers under control

PEL hands over target identity and operational requirements, OSEL checks OS and hardware compatibility, coordinates drain, reboot and readiness, and returns the verified host state to PEL.

  • Explicit PEL/OSEL ownership
  • Drain and reboot impact
  • Host readiness as a contract
PEL → OSEL API → OUF → HMF → PEL
4Edge & Recovery

Provide edge or rescue systems reproducibly

Specialized hardware, limited connectivity and offline promotion are modeled as a profile. Signed live or rescue artifacts remain linked to sources, tests, target hardware and recovery procedures.

  • Hardware qualification
  • Offline-capable artifacts
  • Documented restart
HQF → EEF → LOF → IDF → BRF

End-to-end lifecycle

From the requirement to the controlled next state.

OSEL separates the lifecycle of the OS product from the lifecycle of a specific managed host and connects both through deployments and operations.

  1. 1
    Discover

    Capture target and hardware

    Clarify use case, distribution, platform, devices and support requirements.

  2. 2
    Design

    Define the OS product

    Version Blueprint, profiles, roles, packages, policies and compatibility.

  3. 3
    Build

    Build the image reproducibly

    Lock sources, build in isolation and produce digests as well as build Evidence.

  4. 4
    Verify

    Qualify the release

    Test boot, integration, hardware, performance, security and compliance.

  5. 5
    Publish

    Approve the release

    Sign, promote and publish artifacts with support and channel status.

  6. 6
    Provision

    Install the target

    Provision VM, bare metal, cloud or edge via declared installation profiles.

  7. 7
    Configure

    Apply roles

    Configure system, network, storage and security state in a controlled manner.

  8. 8
    Operate

    Observe the fleet

    Continuously capture inventory, health, drift, supportability and patch level.

  9. 9
    Upgrade

    Change ring by ring

    Steer patches and upgrades with approval, canary, reboot and recovery gates.

  10. 10
    Recover

    Restore operations

    Connect diagnostics, rescue, backup and restore with verified readiness.

  11. 11
    Decommission

    Decommission the host

    Drain workloads, handle data, revoke identity and retain Evidence.

Closed feedback loop

Inventory, drift, patch level and recovery feed back into the OS product. Insights are not merely documented; they flow, versioned, into the next engineering cycle.

Reference architecture

OS product, host state and infrastructure resource keep unambiguous owners.

OSEL owns the operating system on the target; PEL owns the VM, hardware or cluster resource. Operation IDs and contracts connect both lifecycles.

Layer 1 · Shared foundation

Orthevs Platform

IAM, policy, audit, secrets, events, artifact storage and observability.

Layer 2 · OS Control Plane

OSEL Core & API

Blueprint registry, release catalog, fleet inventory, operation ledger and workflows.

Layer 3 · Engineering Capabilities

OSEL Factories

Build, provisioning, configuration, qualification, security, lifecycle and recovery.

Layer 4 · Targets & Adapter

OS Execution Plane

Image builders, package sources, PXE, cloud, hypervisors, configuration tools and managed hosts.

OS as a Product

Version, support, provenance and operational responsibility are part of the release.

Immutable + Mutable

Image and runtime configuration have separate, explicit ownership.

Operation Ledger

Mutations return operation ID, idempotency key, status, errors and audit link.

Declare rollback honestly

Non-atomic updates do not promise rollback when only recovery is possible.

Lab Core

Shared responsibilities keep the Factories integrable.

The Lab Core bundles the cross-cutting domain services; a Factory adds a capability without rebuilding these foundations in parallel.

1

Factory Manager: registration, capability discovery, versions, dependencies, enable/disable.

Shared OSEL function for consistent APIs, lifecycles and verifiable handovers.

2

Blueprint Registry: OS profiles, composition, schema validation, versions and diffs.

Shared OSEL function for consistent APIs, lifecycles and verifiable handovers.

3

Release & Artifact Metadata: image digests, SBOM, signatures, promotion and channels.

Shared OSEL function for consistent APIs, lifecycles and verifiable handovers.

4

Host/Fleet Inventory: host identity, OS version, agent status, desired/observed state.

Shared OSEL function for consistent APIs, lifecycles and verifiable handovers.

5

Workflow & Job Engine: DAG execution, retries, timeouts, approvals and checkpoints.

Shared OSEL function for consistent APIs, lifecycles and verifiable handovers.

6

Adapter Manager: OS, provider and tool adapters with capability negotiation.

Shared OSEL function for consistent APIs, lifecycles and verifiable handovers.

7

Operation Ledger: operation states, idempotency keys, error codes and audit links.

Shared OSEL function for consistent APIs, lifecycles and verifiable handovers.

8

Secret Broker: short-lived credentials and secure handover to workers.

Shared OSEL function for consistent APIs, lifecycles and verifiable handovers.

Domain model and evidence

From Blueprint to host, every derivation remains visible.

OSBlueprint and OSProfile lead to OSBuilds, artifacts and an approved OSRelease. Deployments connect this release with targets, fleets and managed hosts; OSOperations document every change.

Images and large artifacts reside in suitable registries or object stores. OSEL keeps digests, SBOMs, signatures, provenance, support status and test evidence together and stores no production secrets in the image.

1

OSBlueprint

Distribution, packages, roles, policies and desired state.

2

OSBuild

Concrete build with sources, tool versions and results.

3

OSRelease

Approved artifact bundle with signature, SBOM and channel.

4

ManagedHost

Host identity, OS version, inventory, health and enrollment.

5

RolloutPlan

Rings, quorums, halt criteria, blast radius and abort rules.

6

OSOperation

Status, approval, attempts, errors, result and recovery path.

Security, governance and operations

The operating system supply chain extends from source to running host.

OSEL protects build environment, artifacts, bootstrap, privileged operations and fleet rollouts as one coherent supply chain.

Sources

Pin sources and packages

Release builds use controlled repositories, locks and freshness rules.

  • Snapshot repositories
  • Dependency locks
  • License and provenance evidence
Build

Isolate builders

Privileged image builds run on short-lived, constrained workers.

  • Ephemeral workers
  • No build secrets in the image
  • SBOM and signature
Rollout

Limit the blast radius

Patches and upgrades follow rings, quorums and health gates.

  • Canary first
  • Maintenance windows and approval
  • Automatic stop on degradation
Recovery

Prove bootability

Backup alone is not enough; rescue, restore and host readiness are tested.

  • Boot verification
  • Diagnostics and rescue path
  • Recovery Evidence

Interplay within the Orthevs system

OSEL delivers the trusted system foundation for other Labs.

OS releases and host readiness are handed over as versioned artifact and capability contracts.

Target ProfileOSEL ReleaseProvisioningHost ReadinessLab WorkloadFleet Feedback
PEL

Platform Engineering

Consumes OS releases, bootstrap and readiness; provides VM, hardware and cluster targets.

IEL

Infrastructure Engineering

Provides physical, virtual, network and storage target contexts for OS deployments.

SEL

Security Engineering

Assesses hardening, vulnerabilities, compliance and supply chain evidence.

AMEL

AI & ML Engineering

Requests GPU, HPC or edge profiles with matching drivers and runtime prerequisites.

BCEL

Blockchain Engineering

Uses hardened node and validator images with defined kernel and storage profiles.

Roadmap target state

A golden image pipeline proves product and release quality first.

Additional distributions and fleet breadth follow only once build, test, signing, provisioning and recovery work for one reference path. The phases are deliberately described without binding delivery dates.

  1. Phase 0Architecture

    Contracts and operation ledger

    Core contracts, Blueprint schema, Factory lifecycle, API, events and ownership boundaries with PEL.

    Exit Gate: a Blueprint can be validated and an operation planned traceably.
  2. Phase 1Golden Image MVP

    Ubuntu image pipeline

    Blueprint, profiles, repository snapshot, composition, build, boot test, packaging and publishing.

    Exit Gate: signed Ubuntu image with SBOM and test Evidence.
  3. Phase 2Provisioning

    VM and roles

    A target is reproducibly installed, enrolled, configured and reported as ready.

    Exit Gate: deployment and roles are idempotent and repeatable.
  4. Phase 3Fleet Operations

    Patching and security

    Inventory, drift, canary patching, approval, health gates and recovery.

    Exit Gate: safe ring-based patching with a documented abort path.
  5. Phase 4Multi-OS

    Additional distributions and specialized profiles

    RHEL/SUSE/Windows adapters, live OS, edge and GPU/HPC with feature matrices.

    Exit Gate: adapters explicitly declare compatibility and missing capabilities.
  6. Phase 5Enterprise Scale

    HA, air gap and compliance

    HA Control Plane, offline promotion, large fleets and robust Evidence.

    Exit Gate: recovery and promotion work in the chosen operating profile.
MVP scenario

OS Blueprint → Build → Boot Test → Signature → Publish

The MVP creates a reproducible golden image from an Ubuntu Blueprint. Package sources, build environment, tests, SBOM, scan results and signature remain linked; only a passed approval gate publishes the release candidate.

Deliberate boundaries

What the target state explicitly does not promise.

Named non-goals protect the Lab from a broad but unintegrated tool catalog and keep technical statements verifiable.

  • OSEL develops neither its own kernel nor its own distribution.
  • The MVP does not promise full feature parity between Linux and Windows.
  • Package managers, installers and configuration management tools are integrated, not reimplemented.
  • Risky bulk changes require scope, approval, halt criteria and a recovery path.
  • Rollback is offered only where the target technology demonstrably supports it.
  • The 48 Factories are prioritized along robust product and fleet pathways.

OSEL Factory Portfolio

48 capabilities across 12 domains.

Every Factory has its own detail page covering responsibility, use cases, artifacts and contract. The catalog represents the planned capability map.

Bootstrap & Provisioning

4 Factories

Configuration & Role Engineering

4 Factories

Delivery & Fleet Deployment

4 Factories

Developer Experience & Automation

4 Factories

Identity, Security & Compliance

4 Factories

Image & Distribution Engineering

4 Factories

Operations & Reliability

4 Factories

OS Architecture & Product Design

4 Factories

Patch, Upgrade & Lifecycle

4 Factories

Sources & Package Engineering

4 Factories

Specialized OS & Hardware

4 Factories

Verification & Qualification

4 Factories

Shape OSEL together

Which OS product should become reproducible first?

A golden image, a Kubernetes node profile or a ring-based patch process are well suited as a verifiable starting point with clear artifacts and Exit Gates.

Orthevs – Engineering the foundation for what comes next.

Orthevs as an app

Install Orthevs

The Orthevs web app can be installed on supported mobile devices and desktop browsers.

iPhone and iPad

Open Orthevs in Safari. Tap Share, then Add to Home Screen. Enable Open as Web App if offered, then tap Add.

Android

For the web app, open the browser menu and choose Install app or Add to Home screen. Confirm the installation.

Desktop browser

Open the browser menu or the install icon in the address bar, then choose Install app or Add to Dock.

Web app installation depends on your browser. If no install prompt appears, follow the browser steps shown above.