Oryvin

Oryvin Builds Itself, Almost.

Oryvin is a disciplined engineering model for keeping source, documentation, automation, deployment, and evidence connected instead of allowing them to drift apart.

Most environments split these concerns across unrelated tools. Documentation lives in one place. Build and deployment logic live somewhere else. Operational evidence ends up in logs, screenshots, terminals, and memory. Over time the system becomes harder to understand, harder to reproduce, and harder to repair.

Oryvin takes the opposite approach.

It treats documentation, automation, runtime identity, artifact handling, and validation as parts of one coherent system, with a human engineer still directing the work.

Oryvin system model

flowchart TD

    subgraph Engineering
        A[Human Engineer]
        B[AI Assistance]
        A <--> B
    end

    C[WEIC Authoring and API]
    D[hg Source of Truth]
    E[Origin Source Packaging]
    F[DropBoxMini Artifact Distribution]
    G[Orchestrator Execution]
    H[Infrastructure and Running Systems]
    I[Looker Validation]
    J[Operational Evidence]

    B --> C
    C --> D
    D --> E
    E --> F
    G --> H
    H --> I
    I --> F
    H --> J
    J --> B
    J --> C

Figure 1: Oryvin connects governed authoring, source control, packaging, deployment, validation, and evidence in a single operational loop.

What Oryvin is proving

Oryvin is proving that an engineering system can be built so that it increasingly supports its own lifecycle:

source remains authoritative
documentation remains close to the system it describes
deployments expose verifiable runtime identity
artifacts are derived and traceable
AI can help evolve the platform under human oversight

The important point is not that the platform is fully autonomous. It is that more of the work can be executed through stable contracts while a human engineer remains responsible for design, approval, and correction.

Documentation repository

This repository contains the current architecture and operating documentation for the Oryvin ecosystem.

Content is currently authored in EditorInChief (EIC), the first-generation knowledge editor built as a local Node.js application. EIC is being evolved into Wild EditorInChief (WEIC), a multi-user platform built on WildFly, Java, and PostgreSQL.

For the moment the material is published with MkDocs so the documentation can move faster than the platform transition. The repository structure is being kept close to the long-term WEIC model so the documentation can later migrate without major restructuring.

Bootstrap publishing surface

This site is not just a temporary static export. It is part of the Oryvin transition itself. Oryvin is documenting and updating its own generation change from EIC, a local Node.js system, to WEIC, a multi-user WildFly, Java, and PostgreSQL platform. AI helps draft, inspect, and accelerate that work, but a human engineer remains in control of what changes and what ships.

Core principles

Source is authoritative

hg is the source of truth. Releases and artifacts are derived from source, not the other way around.

Documentation is operational

Documentation is not a side product. It captures design, intent, contracts, and the structure needed to operate and improve the system.

Runtime identity matters

Services expose a common /health contract so deployment success and runtime version can be verified instead of guessed.

Automation executes defined work

Automation is useful when it runs clear, inspectable steps such as build, deploy, verify, and capture evidence.

Human judgment stays in control

AI helps draft, inspect, and accelerate work. A human engineer still decides what changes, what ships, and what is true.

Major components

Component	Purpose
WEIC	structured authoring, API, and future publishing platform
Origin	pulls from hg and prepares source bundles
DropBoxMini	distribution boundary for derived artifacts
Looker	captures screenshots and validation evidence
Orchestrator	executes patch, build, deploy, and verification flows
Infrastructure	controlled runtime environment for the platform