OmniFrame: A Raw Substance Modular Computing Platform

R&D Concept Paper — Version 0.01 Author: lazy_dude (Independent Enthusiast) Date: May 24, 2026 Status: Conceptual Architecture, Under Active Development

Abstract

OmniFrame reimagines the computer as a suitcase of sealed, self‑identifying cartridges — CPU, RAM, storage, GPU, power — snapping into a rugged chassis without any borrowed interconnect standards. It replaces all legacy protocols with the Substance Link, a deterministic packet network protected by forward error correction. Components are abstracted into six Raw Substance archetypes and measured in Speed‑Normalized Gigabytes and Standard Normalized Compute. A custom Substance BIOS hands a brand‑blind Substance Tree to a Linux‑only kernel, while a multi‑agent system enforces security, optimizes resources, and accelerates performance. This public‑domain blueprint (CC0) provides a complete, gap‑free conceptual architecture for truly sustainable, vendor‑neutral computing.

1. Introduction

The personal computer remains trapped in a cycle of forced obsolescence. Proprietary sockets, chipset lock‑in, and operating system dependencies ensure that a CPU from one generation cannot coexist with memory from another. Even modular attempts retain the fundamental flaw: they are bound to specific manufacturers and standards. OmniFrame breaks this cycle by asking: What if a computer recognized a CPU not as an "Intel Core i9" but simply as a "Computator" with a certain performance rating? What if memory were measured not in "DDR5‑6000" but in Speed‑Normalized Gigabytes against a universal reference?

Inspired by the detachable, reconfigurable spirit of Huawei's MateBook Fold, OmniFrame extends modularity to its logical extreme. It is not a product but a target architecture — a North Star for a future where no component ever becomes e‑waste, and every generation of hardware can coexist in a single, stable, high‑performance machine.

2. Core Theme and Design Principles

The central theme is universal compatibility through functional abstraction. By defining every component by its fundamental archetype (Raw Substance) and measuring its capability in a common, normalized currency, the system becomes completely indifferent to brand, generation, or manufacturer. Seven inviolable principles underpin the design:

• Raw Substance Identity — Components are defined solely by what they are (Computator, Temporary Keeper, etc.), never by brand or model.
• Universal Measurement — All resources are quantified in a single performance unit: Speed‑Normalized Gigabytes (SNG) and Standard Normalized Compute (SNC).
• Original Interconnect — No PCIe, CXL, Ethernet, or any industry standard is borrowed. A fully custom Substance Link carries all data.
• Universal Cartridge — Every component is housed in a sealed, self‑translating cartridge with a common physical interface to a passive backplane.
• Stability as Core — Data integrity and link reliability are guaranteed by forward error correction, independent clock lines, a dedicated Safety Controller, and a multi‑agent software layer.
• Linux‑Only Governance — The machine runs exclusively Linux, with custom kernel subsystems that own every hardware resource.
• Physical Ruggedness — The chassis is a military‑grade, IP67 sealed suitcase with integrated liquid cooling, locking levers, emergency auto‑off, and diagnostic indicators.

3. Raw Substance Definitions

Every electronic component, stripped of marketing and branding, possesses a pure functional identity. OmniFrame recognises six fundamental archetypes:

Executes instruction sequences to transform data
Holds data and instructions in active use; volatile
Retains data across power cycles
Performs many identical operations simultaneously
Stores and delivers electrical energy
Translates between internal Substance Link and external protocols

Archetype Name
Computator
Temporary Keeper
Permanent Keeper
Parallel Computator
Life Giver
Bridge

Each cartridge announces only its archetype and a capability descriptor. The system never knows or cares about brand or model.

4. Universal Measurement: SNG and SNC

To make mixing generations and architectures practical, OmniFrame introduces a common performance currency.

Speed‑Normalized Gigabyte (SNG) — For Temporary and Permanent Keepers. The fastest cartridge in the chassis sets the reference bandwidth. All other cartridges report effective capacity as Physical Capacity × (Bandwidth / Reference Bandwidth). A slower DDR3 stick contributes fewer SNG, but every SNG is guaranteed to deliver reference‑level performance. Total SNG is the usable memory pool.

Standard Normalized Compute (SNC) — For Computators and Parallel Computators. A short benchmark runs at cartridge boot. The result is normalised against a fixed reference (1 SNC = 1 billion integer operations per second). The OmniFrame Scheduler uses SNC for task placement; higher SNC receives more load.

This ensures that no cartridge is ever useless — merely tiered.

5. The Substance Link (Original Interconnect)

All high‑speed communication between cartridges uses a fully custom, original protocol. No industry standard is borrowed.

5.1 Physical Layer

• Differential pairs (one per direction) with a dedicated, separate clock line.
• No encoding (8b/10b, scrambling); one symbol equals one data unit.
• Blind‑mate gold‑plated pad array, aligned by cartridge magnets.
• Fixed symbol rate per chassis; harmonizers in the Fabric Cartridge bridge different speeds.

5.2 Universal Packet Format

A single packet structure carries all data, control, and management traffic.

+ ------- + ------- + ------- + ------- + ------- + ------- + ------- + ------- +
|Start   |Origin  |Dest    |Trans   |OpCode  |Length  |Payload |HMAC    |Guard   |
|2 symb  |8 symb  |8 symb  |8 symb  |4 symb  |12 symb |var.    |8 symb  |4 symb  |
+ ------- + ------- + ------- + ------- + ------- + ------- + ------- + ------- +

5.3 Addressing

Resources are addressed via a Substance Address: (Cartridge ID, Channel, Offset). This is the machine's native coordinate system, independent of any CPU memory map.

5.4 Error Handling

Forward error correction (convolutional code) corrects up to 4 symbol errors per 64‑symbol block. No link‑level retransmission; corrupted packets are dropped, and the requestor times out.

5.5 Interrupts and DMA

An Interrupt Router inside the Fabric Cartridge delivers interrupt packets to Computators based on a programmable vector table with priority levels.

Bulk Transfer operations allow direct cartridge‑to‑cartridge data movement without Computator involvement.

5.6 Switching

The Fabric Cartridge is a stateless packet forwarder. It reads Destination ID, looks up a port in a table loaded by the Management Cartridge, and forwards — with speed harmonization. Multiple Fabric Cartridges can cascade. All symbol rates are derived from a single System Clock Source.

6. Cartridge Architecture (Model)

Every component lives inside a sealed, standardized cartridge. Internally, a smart controller provides physical adaptation, protocol translation, auto‑analysis, health monitoring, and wireless identification.

+ --------------------------------- +
| CARTRIDGE CASE (Sealed)           |
|                                   |
|  +----------+                     |
|  | Raw      | e.g.,               |
|  | Component| DDR3 DIMM           |
|  +----+-----+                     |
|       |                           |
|  +----+---------------------+     |
|  | Smart Controller         |     |
|  |  - FPGA/ASIC             |     |
|  |  - Voltage Regulators    |     |
|  |  - Protocol Translator   |     |
|  |  - Auto-Analysis         |     |
|  |  - Health Monitor        |     |
|  |  - NFC Tag (passive)     |     |
|  |  - UWB Module            |     |
|  +--------------------------+     |
|                                   |
|  External Interface:              |
|  - Magnetic alignment             |
|  - Locking lever                  |
|  - Staged connector               |
|    (power/data/Early-Break)       |
|  - Liquid cooling port            |
|  - E-ink label                    |
+ --------------------------------- +

External interface (identical across all archetypes):

• Magnetic alignment and mechanical locking lever.
• Staged connector pins: long ground/power, medium data, short Early‑Break for predictive disconnect.
• Liquid‑cooling quick‑connect port.
• E‑ink label displaying archetype, capacity, and health.

7. System Components and Chassis Layout

7.1 Physical Chassis Top‑Down View

+ --------------------------------------------------------------------- +
| OMNI FRAME SUITCASE (IP67)                                            |
|                                                                       |
| +-------+ +-------+ +-------+ +-------+ +-------+                    |
| | Bay C1| | Bay C2| | Bay M1| | Bay M2| | Bay M3| ...               |
| |(Comp) | |(Comp) | |(Temp) | |(Temp) | |(Temp) |                   |
| +-------+ +-------+ +-------+ +-------+ +-------+                    |
|                                                                       |
| +-------+ +-------+ +-------+ +-------+ +-------+                    |
| | Bay G1| | Bay S1| | Bay S2| | Bay P1| | Bay P2|                   |
| |(Par)  | |(Perm) | |(Perm) | |(Life) | |(Life) |                   |
| +-------+ +-------+ +-------+ +-------+ +-------+                    |
|                                                                       |
| [ Management Cartridge (MC) + Shadow MC ]                            |
| [ Fabric Cartridge(s) ]                                               |
| [ Safety Controller ]                                                 |
| [ Power Distribution (48V) ]                                          |
| [ Cooling Loop Quick-Connects ]                                       |
|                                                                       |
| Front Panel: OLED Display, 3 Buttons, LEDs, Speaker                  |
+ --------------------------------------------------------------------- +

7.2 Component Descriptions

• Management Cartridge (ID 0x00): Conductor. Boots first, scans bays, authenticates cartridges, assigns Origin IDs, programmes Fabric forwarding tables, presents the unified resource map. A Shadow Management Cartridge maintains a complete encrypted replica and takes over within milliseconds if the primary fails.
• Fabric Cartridge: Stateless packet forwarder with harmonizer buffers. Cascadable. Contains the Interrupt Router and Bulk Transfer engine.
• Safety Controller: Independent microcontroller on its own power domain (supercapacitor + coin cell). Monitors lock levers, Early‑Break pins, presence, coolant flow, and accelerometers. Executes emergency shutdown, controls per‑bay soft‑start power sequencing.
• Power Distribution: Dual redundant hot‑swap PSU cartridges (Life Givers). 48V DC internal bus with OR‑ing diodes and active load sharing. Supercapacitor ride‑through for 5 seconds.
• Cooling Subsystem: Integrated liquid cooling loop with quick‑connect per cartridge. Redundant pumps. Thermal Emergency Protocol: throttle, then isolate the overheating cartridge.
• Bridge Cartridges: Visualizer (display), Listener (input), Connector (network), Sound Bridge (audio), Talk Cartridge (legacy I/O).
• Front Panel: 2.8‑inch OLED, three buttons (Scroll Up, Down, Acknowledge), tricolor bay LEDs, speaker, external LED panel mirroring internal status when lid is closed.

8. Substance BIOS (Boot Firmware)

A custom boot firmware replaces all legacy BIOS/UEFI functions with a brand‑blind, multi‑architecture boot chain.

Masked ROM initializes MC hardware, verifies Stage 1 signature
Queries Safety Controller for powered cartridges and emergency flags
Powers bays sequentially, awaits Identify packets, authenticates, assigns IDs
Runs SNG/SNC benchmarks; establishes reference standard
Configures Fabric tables; assembles memory map, CPU topology, storage inventory
Scans Permanent Keepers for a signed Linux kernel; enters Diagnostic Mode if none found
Constructs a Substance Tree (device tree in Raw Substance terms) and jumps to kernel

Name
ROM Boot
Safety Handshake
Substance Enumeration
Norm Calibration
Resource Assembly
Boot Selection
Kernel Handoff

Key Features: brand‑blind, secure boot (verified against immutable fuse keys), measured boot (tamper‑evident log), hot‑plug aware (remains resident), diagnostic integration with OLED and LEDs.

Boot Flow Diagram

Power On
|
v
Safety Controller self-test --- Fail --> OLED: "Safety Controller Fault"
| Pass
v
Management Cartridge powers on
|
v
MC scans bays, reads presence pins --- Missing --> OLED: "Missing: Temp Keeper Bay M2"
| All present
v
MC sends Identify request --- No response --> OLED: "Unresponsive: Bay C1"
| All respond
v
MC validates auth tokens --- Fail --> OLED: "Security Fail: Bay S1"
| All pass
v
MC runs benchmarks, calculates SNG/SNC
|
v
MC configures Fabric forwarding tables
|
v
MC loads Linux kernel --- No kernel --> OLED: "No Bootable OS Found"
| Found
v
MC constructs Substance Tree, jumps to kernel
|
v
Linux boots --> OBA starts --> RSM, SQMA, RAPA, SCHA agents start
|
v
Normal Operation (hot-plug, monitoring)

9. Multi‑Agent Software Architecture

The runtime intelligence is distributed across four specialised agents and a bridge, all running on a standard Linux kernel.

Hardware Layer
|
v
Substance BIOS
|
v
Linux Kernel (unmodified)
|
v
OmniFrame Bridge Agent (OBA) <--- sysfs, netlink, cgroups, eBPF
|
+-----------------------------+
v                             v
Raw Substance Manager (RSM)   Security & Quirk Mitigation Agent (SQMA)
|
+-----------------------------+
v
Resource Allocation & Policy Agent (RAPA)
|
v
Substance Cache & History Agent (SCHA)

Core Duty
Enforces brand‑blind purity; computes SNG/SNC; assigns archetype roles; maintains Ground State
Handles brand‑level vulnerabilities and microcode bugs using an anonymised Quirk Database; never exposes brand identity to RSM
Smart resource allocation based on workload profiling (eBPF); honours user‑defined rules and risk‑accepted overrides
Manages a multi‑tier cache from low‑tier cartridges; records system‑state history for quick‑reference and rollback; provides temporary scratchpad storage
Translates between standard Linux kernel interfaces and the other agents using only stable, existing kernel APIs. No out‑of‑tree kernel modules required.

Key Interactions:

• RSM defines the pure norms and roles.
• SQMA applies anonymous security fixes without RSM awareness.
• RAPA optimises placement and allows user overrides (with risk acceptance).
• SCHA accelerates I/O and provides a "time‑machine" for system state.
• OBA enforces all policies via standard Linux mechanisms.

10. Stability and Security Subsystem

10.1 Secure Connection

• Per‑packet HMAC with session keys rotated every 60 seconds.
• Physical link fingerprinting to detect cartridge swaps.
• Mandatory encryption of all data payloads.

10.2 Trust Chain

• Hardware root of trust in immutable fuse arrays.
• Periodic re‑identification.
• Measured boot attestation log.

10.3 Fault Containment and Graceful Degradation

• Every cartridge is a fault domain; faulty cartridges are quarantined.
• Continuous health diagnostics (memory scrubbing, SMART‑like monitoring, core offlining).
• Automatic mitigation: data migration, SNG/SNC reduction, role downgrade, read‑only remount.

10.4 Ground State and Emergency Restoration

A versioned, checksummed snapshot of the entire system configuration (cartridge IDs, roles, norms, forwarding tables). Automatically updated. On unrecoverable error, restores the last known‑good state.

10.5 File Corruption Protection

• Block‑level cryptographic checksumming.
• Background scrubber.
• Self‑healing RAID across Permanent Keeper cartridges.
• Atomic restore points (immutable snapshots).

10.6 Safe Removal Protocol

Flushes buffers, remounts read‑only, migrates data, releases lock. Dependency resolution prevents unsafe ejects.

10.7 Emergency Save and Restore

During the 5‑second supercapacitor ride‑through, the kernel saves all volatile state. On next boot, offers session restoration.

10.8 Continuous Monitoring

Latency, error trends, thermal, resource exhaustion. A stability score (0–100) is displayed on the front panel and web console.

Emergency Shutdown Flow

Safety Controller detects: forced unlock / Early-Break / overheat / severe shock
|
v
Emergency Mode
+---> Audible alarm + strobe light
+---> Lock all other cartridges (solenoids)
+---> Send flush command to Permanent Keepers
+---> Kill main power bus (except storage)
+---> Supercapacitors keep storage alive for 3 more seconds
+---> Log event to non-volatile memory
+---> System enters "Transport Safe" mode
|
v
Power off; manual reset key required to restart

11. Diagnostic Subsystem

Before any OS boots, the OmniFrame communicates health clearly.

• Front‑Panel OLED: Plain‑text messages (e.g., "No Computator Found", "Temporary Keeper Missing — Bay M3").
• Bay LEDs: Off (empty), blinking white (missing/expected), green (nominal), amber (degraded), red (failed), blinking red (emergency).
• Visualizer Output: Text‑mode diagnostic screen with colour‑coded block diagram.
• Web Console Fallback: Minimal HTTP server accessible via Network Bridge.
• Audio Alerts: Single beep (normal), two beeps (non‑critical), continuous tone + strobe (critical).
• Acknowledge Button: Allows user to override non‑critical faults and boot with reduced resources.

12. Practical Feasibility

The OmniFrame is a long‑term engineering vision, but no component requires science fiction.

Can be prototyped in Linux userspace using NUMA and memory hotplug
Requires custom PHY and FPGA; packet format and forwarding are straightforward
Single FPGA can emulate both for a prototype
MCU + supercapacitor + sensors
Mature technologies (pogo‑pins, liquid quick‑connects, locking levers)
Can be built on coreboot/ARM Trusted Firmware foundations
OBA uses stable Linux APIs; agents are userspace daemons
I2C OLED + microcontroller
Materials and fabrication exist

Feasibility
Software‑definable today
Medium‑term R&D
Buildable with FPGAs
Off‑the‑shelf
Industrial design required
Custom firmware
Incrementally buildable
Simple embedded project
Manufacturing cost barrier

A minimal single‑cartridge demonstrator (Compute Module + Storage Cartridge over an FPGA‑emulated Substance Link) can be built by a small team to prove the core principles.

13. Technology Choices & Justification

Universal compatibility; zero e‑waste
Consistent performance tiering across all hardware
Full architectural freedom; deterministic low‑jitter data flow
Stability as core
Boot, enumeration, auth, resource mapping
Flexible topology; mixed‑speed coexistence
Emergency shutdown, physical security, ride‑through
Survives PSU failure; safe hot‑swap
Full performance under sustained load
Eliminates legacy firmware; clean Substance Tree
Enforces Raw Substance policies via standard APIs
Purity (RSM), security (SQMA), optimisation (RAPA), acceleration/history (SCHA)
User‑serviceable without keyboard/monitor
Identifies cartridges when unpowered
Auto‑discovery and predictive disconnect

Why Chosen
Eliminates brand/generation lock‑in
Common performance currency
No dependency on external standards
Eliminates retry buffers & non‑deterministic latency
Centralised, survivable orchestration
Stateless, high‑speed forwarding
Independent hardware supervision
Efficient, rugged power with ride‑through
High‑density cooling without throttling
Brand‑blind boot, secure measured chain
Deep hardware control, GPL alignment
Separation of concerns
Instant human‑readable failure indication
Persistent zero‑power identification
Passive ID + active proximity monitoring

14. How OmniFrame Fills the Identified Gaps

During conceptual development, critical gaps were systematically identified and addressed:

OmniFrame Solution
Raw Substance archetypes
SNG and SNC norms
Substance Link with FEC, no retry
Management Cartridge + Shadow redundancy
Independent Safety Controller with staged pins, ride‑through, mechanical locks
Safe Eject protocol with dependency resolution
Cartridge fault domains, health monitoring, graceful degradation
Ground State snapshots, emergency save during ride‑through
Block‑level checksumming, background scrubber, self‑healing RAID
OLED, bay LEDs, web console, audio alerts
Substance BIOS: brand‑blind, multi‑architecture, secure measured boot
RAPA agent with workload profiling and user overrides
SQMA agent with anonymised quirk database
SCHA agent: intelligent cache, history, temp storage
OmniFrame Bridge Agent using stable APIs only

15. Core Concept Implementation Checklist

Every major concept discussed during the development of OmniFrame has been implemented in this v0.01 paper. A selection of verified items:

• Raw Substances & Universal Measurement
• Substance Link (packet format, addressing, FEC, DMA, interrupts)
• Cartridge architecture (staged pins, cooling, locks)
• System components (Management, Fabric, Safety, PSU, cooling, Bridges)
• Substance BIOS (brand‑blind, measured boot, Substance Tree)
• Multi‑agent software (RSM, SQMA, RAPA, SCHA, OBA)
• Stability & security (Ground State, Safe Eject, emergency restore, link encryption)
• Diagnostic subsystem (OLED, LEDs, web console, audio)
• Practical feasibility assessment
• Technology choice justification
• All identified gaps explicitly filled

16. Conclusion and Next Steps

OmniFrame v0.01 presents a complete, gap‑free conceptual architecture for a computing platform that rejects branded standards, planned obsolescence, and vendor lock‑in. From the Raw Substance identity of a DDR3 stick to the Substance BIOS that bootstraps the machine without a single vendor string, every layer treats components as pure, measurable, interchangeable resources. Stability is a continuous, hardware‑enforced, software‑orchestrated process. The multi‑agent intelligence layer ensures security, performance, and user control without compromising the core philosophy.

This paper is an open blueprint, dedicated to the public domain, to inspire a future where computers are truly modular, sustainable, and free. Next steps include refining the Substance Link PHY specification, prototyping a minimal FPGA‑based demonstrator, and engaging the open‑hardware community for feedback.

Public Domain Dedication The author dedicates this work to the public domain under Creative Commons Zero (CC0). You are free to copy, modify, distribute, and perform the work, even for commercial purposes, without asking permission.