Clean-slate operating system · active research & development

A computer where authority is explicit and meaning is shared.

MRML is a capability-native operating system designed around memory-safe software, isolated services and VMs, a semantic interface for sighted and blind users, and AI that can help without becoming root.

Explore the architecture See current progress
No ambient authorityMemory safety by defaultAI ≠ root
authority.inspect
principal  AgentSession #18
scope      BrowserTab #7

ALLOW  Semantic.Inspect
ALLOW  Semantic.Interact
ASK    Media.Describe
DENY   Secret.Export
DENY   RawHID.Inject
DENY   OtherTabs.Inspect

▮
“Power should be explicit, limited, inspectable, and revocable.”

Architecture

Everything important is an object. Capabilities decide what can happen.

Names identify things; they do not authorize them. Applications, services, devices, VMs, accessibility tools and AI operate through explicit, attenuable authority.

01

Capability native

Paths, ports, names and identities are not ambient authority. Rights can be delegated narrowly and revoked.

02

Fault isolation

Services are designed to fail, clean up, and restart without turning one compromise into a machine-wide compromise.

03

VM containment

Unsafe and legacy software belongs behind explicit virtual-machine boundaries whose devices project only delegated capabilities.

Accessibility is architecture

The monitor is optional. Meaning is not.

MRML is designed so visual presentation, Braille, speech, keyboard control and text-only AI can consume the same underlying semantic state rather than reverse-engineering pixels.

A blind user should be able to operate the supported desktop, trusted security prompts and browser workflows with the monitor off.
semantic://browser/tab/7generation 42
#12heading level=1Account
#18textbox · focusedEmailaction: SET_VALUE
#21buttonSign inaction: ACTIVATE
Braille⠠⠎⠊⠛⠝⠀⠊⠝
Speech“Sign in, button”
LLMACTIVATE node #21

Braille first-class

A transport-neutral Braille model, routing and input are planned as native semantic interactions, with virtual devices for CI and later physical-device validation.

Same redaction

Secrets are redacted before semantic state reaches GUI, Braille, speech, automation or AI. Accessibility is not a bypass.

Real-user gate

Accessibility APIs are not meant to stabilize before practical testing with disabled users and monitor-off workflows.

Security model

Assume components fail. Limit what failure can become.

01

One compromise should remain one compromise.

Revocation, mapping invalidation, cleanup-gated retirement and bounded restart are core mechanisms—not optional hardening.

02

Intelligence does not imply authority.

An AI can inspect or act only through capabilities actually delegated to its session. Prompt injection does not manufacture OS authority.

03

Owner policy stays above vendor policy.

The architecture aims for owner-controlled trust roots, scoped attestation and security mechanisms that do not become permanent publisher authority over the machine.

04

Claims require evidence.

MRML distinguishes goals, implemented mechanisms, tested behavior, measurements, audits and proofs. Virtualized evidence is not called physical-hardware proof.

mrml-rustc

A first-party Rust compiler with different constraints.

MRML is developing an original, dependency-free Rust compiler aimed at a no_std, no-global-alloc environment and contemporary, forward-looking Rust semantics. Rust 2024 is the floor, not the destination.

The compiler remains incomplete. Ownership/CFG analysis, broad trait solving, full language coverage, linking and package orchestration remain future milestones.

624compiler + driver tests in the latest supplied milestone on both Windows and Arch Linux
2native object targets currently emphasized: AMD64 COFF and ELF64
0unsafe blocks found in the documented compiler/driver hygiene review

Current progress

Building the substrate before the screenshot.

The current roadmap emphasizes service isolation, persistent configuration/storage and the virtual-device stack before the full desktop.

Gate closed

Two-service substrate

Blocking IPC, typed peer death, revocable shared memory, cleanup-gated retirement and bounded restart have equivalent signed KVM/WHP paths.

In progress

Storage & configuration

Capability-native object identities, COW publication/recovery machinery and configuration checkpointing are moving toward authenticated durable storage.

In progress

Virtual devices

Block-device work is establishing common queue, reset, interrupt and restart semantics intended to extend toward PCI/VirtIO-compatible devices.

Next major compiler gate

Typed CFG + ownership

The compiler's place/access preanalysis is groundwork for initialization, moves, borrows, loans and Polonius-style flow-sensitive analysis.

Roadmap

A dependency graph, not a feature wishlist.

  1. 01

    Kernel & service substrate

    Capability lifecycle, IPC, shared memory, cleanup and restart.

  2. 02

    Persistent services & devices

    Configuration, storage, networking, firewall, block/device transport and QEMU differential testing.

  3. 03

    Application ABI & trusted compositor

    Memory-safe application model, microVM projection, HiDPI graphics and Semantic Scene Graph.

  4. 04

    Browser, accessibility & AI control

    No-JIT browser, structured semantic web, Braille/speech parity, capability-scoped local/remote AI.

  5. 05

    Authority UX

    Capability provenance, trusted consent, SecretObject use/export separation and visible AI principals.

  6. 06–08

    Persistent trust, hardware isolation & hardening

    Rollback-resistant boot, owner trust roots, physical IOMMU evidence, fuzzing, audit and external review.

MRML in four lines

Names identify. Capabilities authorize.

Power should be explicit, limited, inspectable, and revocable.

One compromise should remain one compromise.

Intelligence does not imply authority.

Research system · work in progress

Build the computer around the boundaries you actually want.

MRML is not production-ready. Its architecture is being implemented and tested incrementally, with unsupported and unproven properties kept explicit.

Back to top