I. Local Freedom: Private Thought and the Absolute Autonomy of the Mind

Meet Joe, The Huskie: Our Guide to Absolute Freedom

To accompany you on this journey toward absolute digital freedom, we proudly introduce Joe, The Huskie—the official mascot of TIMES. Joe represents the resilient, loyal, and energetic nature of our community. Just like a Husky navigating the vast, snowy wilderness with absolute focus, Joe leads the way through the complex landscape of bare-metal computing, pointing you toward paths of complete system autonomy and safety.

The Philosophy of Post-Political Ethical-Anarchy

Unlike the Lunduke Computer Operating System (LCOS) and its monarchy-driven downstream lineage, TIMES rejects centralized administrative hierarchy. We believe that true software independence cannot be handed down by a single ruler; it must be claimed collectively by the community. TIMES is a community-centered, post-political ethical-anarchy. We do not build to rule, nor do we play the games of political factions. We organize our development branch as an independent, unbound codebase (indie-branch) where individuals collaborate through voluntary cooperation, mutual respect, and pure mathematical merit. —Our pack runs together.

Meet Joe, The Huskie: Our Guide to Absolute Freedom

To accompany you on this journey toward absolute digital freedom, we proudly introduce Joe, The Huskie—the official mascot of TIMES. Joe represents the resilient, loyal, and energetic nature of our community. Just like a Husky navigating the vast, snowy wilderness with absolute focus, Joe leads the way through the complex landscape of bare-metal computing, pointing you toward paths of complete system autonomy and safety.

—Design for stability.

II. The Bootstrap Architecture: From Devuan to Epistemic Monarchy-Offloading

TIMES implements a robust, systemd-free base using a clean four-layer bootstrap blueprint designed to maximize stability while retaining absolute development autonomy.

1. The Core Base (Devuan Stable-Branch)

TIMES inherits the solid, non-systemd foundation of Devuan via our strategic, downstream fork of LCOS. By utilizing clean, alternative init-systems such as sysvinit, runit, or openrc, we keep the initialization sequence completely linear, transparent, and auditable. TIMES stands proud as the world's first LCOS-derived distribution.

Our structural goal is highly focused. We do not aim to be a new Debian, nor a new Devuan, nor a new Ubuntu. Instead, we want to be the definitive user-centric desktop gateway. Think of it through this precise structural analogy:

Linux Mint : Ubuntu :: Ubuntu : Debian

By applying this exact relationship to our own ecosystem:

TIMES : LCOS :: LCOS : Devuan :: Devuan : Debian

Just as Linux Mint is to Ubuntu, offering an accessible, polished, and robust user experience on top of a solid foundational system, TIMES will be to LCOS. LCOS acts as our highly stable, intermediate upstream, while we refine and polish the user-facing layer with custom tools, clean configurations, and complete visual elegance.

3. Upstream Exploitation and the Monarchy Package Pool

We recognize that LCOS invests heavily in developer hiring to maintain high-availability mirrors and stable packaging trees. TIMES is engineered to utilize this to our advantage. By building directly on top of their downstream package pools, we inherit their stable package refinements automatically. This allows us to avoid massive corporate overhead, focusing our community energy entirely on custom user-space tools and cryptographic hardening while LCOS resources subsidize our base stability.

4. The Development Horizon (Version 0.1 Roadmap)

We value stability above all else. Our roadmap is strategically tied to upstream progress: we will officially kick off our core development pipeline as the Lunduke Computer Operating System reaches version 0.5 or 1.0 (we will wait until its creator explicitly declares: "now the system is very stable"). Once that stability milestone is reached, our team will take approximately 1 to 6 months to construct and optimize our own independent version 0.1.

—The freedom of trademark.

III. The Freedom of Trademark: Why We Are Not a "Linux" Distro

An operating system built on the principles of post-political ethical-anarchy cannot bind its identity to corporate licensing bodies or industry-managed trademarks. TIMES is intentionally not classified as a "Linux" distribution.

1. Rejecting Corporate Naming Gates

While our operating system utilizes a highly optimized, fully open-source kernel kernel tree, we refuse to pay licensing fees to the Linux Foundation, nor will we sign restrictive usage agreements simply to secure the right to use a trademarked name. TIMES belongs to the community, not to corporate boards.

2. The Path of Pure Functional Integrity

We define our system by its function and safety, not by branding. By isolating our custom user-space libraries, our Haskell Turtles, and our independent package layouts from corporate trademark entanglements, we ensure that no external organization can ever demand changes to our codebase under the threat of trademark litigation. TIMES runs on raw, honest engineering. —No licenses bought. Only code written.

—Interfaces built on safety.

IV. The Minimalist Desktop Substrates: The Philosophy of Choice

TIMES firmly rejects the industry trend of forced single-desktop pipelines. We recognize that user choice in graphical rendering is a vital expression of software autonomy. We offer two highly optimized, isolated desktop pipelines:

Default Pipeline (XLibre & YesLibre)

By default, TIMES boots into XLibre (the hardened, clean fork of the traditional X11 display server, optimized for stability and compatibility). Over this stack runs the YesLibre Desktop Environment, built entirely by MitsuoLabs. YesLibre utilizes Elm and Haskell to write 100% crash-free, memory-safe system-level panels, taskbars, and system interfaces, entirely eliminating common runtime GUI errors.

Alternative Pipeline (Wayland & NoSea)

For users seeking modern, security-isolated display handling, TIMES provides an explicit, natively integrated Wayland boot option. The default interface for the Wayland pipeline is the custom NoSea Desktop Environment (also developed by MitsuoLabs). NoSea acts as a highly optimized, minimalist Wayland compositor, built with formal-verification concepts to ensure isolated applications cannot perform screen-scraping or interface tampering. —Choice is software autonomy.

—No daemons. Only turtles.

V. The Turtle Paradigm: Executing with Deterministic Safety

Traditional operating systems rely on asynchronous background "daemons"—mysterious loops that spawn rogue processes, leak memory, and hide execution anomalies from the user's view. TIMES rejects this paradigm entirely. We implement absolutely zero background daemons. Instead, we introduce the Turtle Paradigm.

Written in Haskell, a "Turtle" is a pure, stateless task thread executed under rigorous type safety. These units do not run asynchronously in the dark; they are arranged in a strict, linear, and deterministic monadic queue. When idle, they consume exactly 0% CPU, waking up only when a direct, proven system event triggers their block.

Controlled through the elegant, YesLibre (X11-based) or NoSea (Wayland-based) desktop environments, the user can inspect, pause, or dissolve any active task with absolute mathematical safety. Joe, The Huskie, watches over the active monads, ensuring that no task strays from its defined path. —A clean, predictable queue.

—Pure mathematical speed.

VI. Ring 17: The Epistemic Direct-Execution Layer

To achieve unprecedented execution speeds, operating systems must minimize the latency introduced by switching between User Mode (Ring 3) and Kernel Mode (Ring 0). Historically, running everything directly in Ring 0 (such as in Terry Davis's classic single-address-space designs) offered raw hardware speed but sacrificed stability, as any code error could crash the entire system.

TIMES solves this fundamental engineering trade-off with Ring 17, our custom User-Space Single Address Space (SAS) runtime.

Before any application compiles or runs within this high-priority layer, our Haskell-driven verification engine validates its memory safety using formal mathematical proofs and algebraic verification models, entirely bypassing slower runtime checkers (like Rust's borrow checker). Because safety is proven prior to runtime, we can safely deactivate slow run-time safety checks. The code executes at the unrestricted speed of raw silicon, while the core operating system remains completely protected from crashes. —Speed without compromise.

—Isolation is stability.

VII. The clock-pm Protocol: Conflict-Free Multi-Ecosystem Packaging

We firmly reject the industry's shift toward bloated, centralized container formats like Snaps and Flatpaks, which duplicate system dependencies, degrade startup times, and lock users into proprietary store backends. TIMES establishes AppImages as our standard, portable, "one app = one file" application format, keeping your root filesystem clean and immutable.

To coordinate system libraries without dependency conflicts, we introduce clock-pm. Written in Haskell, clock-pm is a lightweight, open-standard package management protocol. Rather than maintaining massive, costly mirrors, clock-pm operates as a smart proxy indexer, directing your local machine to download raw binaries directly from upstream public mirrors.

To prevent conflicts when calling external package repositories, clock-pm employs a strict Lexical Isolation Engine:

1. Pacman Integration: Native compatibility with Arch Linux repositories, granting immediate access to the bleeding-edge Arch package tree.

2. APT & DNF Coexistence: Seamless integration with Devuan and Red Hat systems without package namespace collisions.

3. BSD Ports & pkg/pkg_add Support: Direct parsing of BSD Makefiles via Haskell parsers, letting users compile minimal, secure, and clean UNIX software locally.

4. Lexical Namespace Decoupling: Every package is isolated inside a unique, cryptographically hashed directory path:

/store/[HASH]-[PACKAGE_NAME]/lib/

Applications are bound strictly to their local dependency graphs via dynamic RUNPATH rewriting, ensuring zero global system corruption. —Clean libraries, robust system.

—Fully decentralized delivery.

VIII. Independent Cloud Topology: Zero-Cost Mirror Offloading

Traditional distributions spend thousands of dollars hosting and synchronizing multi-terabyte package mirrors across global server farms, often resorting to venture-capital or corporate sponsorship which ultimately compromises their independence. TIMES circumvents this entirely.

Through our Smart Proxy Architecture, our self-hosted Virtual Private Servers (VPS) are incredibly lightweight. We do not host raw third-party binary payloads. Our infrastructure only hosts the Haskell-based dependency verification API, our custom package catalog (containing YesLibre, NoSea, and TIMES custom system tools), and cached metadata indexes. When a user requests a package via clock-pm, the system verifies the signatures and directs the client's machine to pull the raw package blocks directly from high-speed, official upstream mirrors. —Zero mirrors. Zero overhead.

—Silence through math.

IX. The TIMES Resource Governor: Absolute Hardware Control

Conventional operating systems allow un-optimized applications and background tasks to run wild, causing memory leaks, high temperatures, and sudden system slowdowns. TIMES puts physical control of the hardware back into the hands of the user through the TIMES Resource Governor, natively integrated into our Elm desktop dashboards.

This subsystem completely replaces legacy, unconfigurable thread scheduling with a precise, mathematical resource allocator:

• High-Precision RAM Throttling: Enforces hard ceilings on memory usage (Resident Set Size). When an application attempts to exceed its allocation, the governor intervenes to run garbage collection aggressively or temporarily swap non-critical variables to an encrypted pool, avoiding system-wide lag.

• CPU Core Throttling: Actively restricts thread execution slices via microsecond-level suspension signals and POSIX real-time scheduling parameters, forcing heavy applications to run cleanly within your defined boundaries.

• GPU Hardware Limiter: Intercepts Vulkan and OpenGL command queues directly inside YesLibre and NoSea, dynamically capping frame-rates to keep system temperatures low and laptops silent. —Absolute hardware control.

—Fast, cool, and quiet.

X. On-Demand Utilities and Hardened Security

TIMES comes pre-bundled with lightweight, high-value tools designed to optimize your local environment on demand, running exclusively as stateless Haskell Turtles:

• Cryo-Freeze: Instantly serializes the exact state of heavy, inactive applications (like web browsers with dozens of tabs) and dumps them into compressed, encrypted local swap cache, freeing up 100% of physical RAM for active compilation tasks. The state is instantly restored the millisecond the window is clicked.

• T-Cool: Proactively monitors hardware sensors and dynamically throttles execution slices using the TIMES Resource Governor parameters, keeping system temperatures low and laptops silent without loud, distracting fans.

• Instant-On Boot-Sequence Planner: An interactive Elm GUI mapping out every system Turtle. Drag, drop, merge, or postpone tasks to achieve a cold boot-to-desktop sequence that completes in less than one second. —Your machine, your rules.

—Zero tracking. Total utility.

XI. Curated Independent Apps and Native Sandboxing

Our platform ships with a highly curated suite of pre-compiled, security-vetted open applications, each running inside isolated, local sandboxes to ensure you have the tools to work and create offline immediately.

The Integrated Application Matrix

• Office & Productivity: LibreOffice (telemetry-free document processing) and Okular (secure PDF reader).

• Creative Suite: GIMP (photo editor), Inkscape (SVG editor), Krita (illustration), and Blender (3D rendering utilizing our GPU limiter).

• Audio/Video Production: VLC (offline player), Kdenlive (video editor), Audacity (audio processing), and LMMS (music sequencer).

• Web Navigation & Privacy: Tor Browser (unmodified for perfect anonymity), LibreWolf (telemetry-free, pre-configured with secure MitsuoLabs partner referral searches), and Brave Browser (high-speed, ad-free navigation supporting TIMES development via referral parameters).

• Development Tools: VSCodium (telemetry-free editor), Godot Engine, and Redot Engine (fully local game development).

• Scientific Suite: FreeCAD (CAD modeling), Stellarium (offline planetarium), and GNU Octave (local-first MATLAB alternative).

• Data & Sync: Calibre (e-book archive) and Syncthing (P2P decentralized local file synchronization).

• Hardened Communications: Mozilla Thunderbird pre-configured with a hardened system profile that blocks automatic remote images and disables diagnostic reporting. —Everything you need, offline.

—The freedom to choose.

XII. Kernel Selection Matrix: Choose Your Substrate Engine

To support diverse hardware architectures, physical optimization levels, and user-defined freedom models, TIMES refuses to lock users into a single kernel path. The operating system provides a native selector interface within the boot manager, presenting five highly specialized kernel options:

+-------------------------------------------------+
| KERNEL SELECTOR MATRIX | +-------------------------------------------------+
| [1] Linux-libre Kernel (100% Deblobed Purist) |
| [2] LTS Kernel (Production Stability) |
| [3] Mainline Kernel (Cutting-Edge Drivers) |
| [4] Hardened Kernel (KASLR & Defenses) |
| [5] Custom Pipeline (Self-Compiled PQC) | +-------------------------------------------------+

1. Linux-libre Kernel

The Purist Standard. A 100% deblobed implementation of the Linux kernel. It dynamically scans and systematically strips away all proprietary binary blobs and un-auditable firmware packages.

2. LTS Kernel

The Production Standard. Based on official, long-term support branches, this option prioritizes structural stability and backports critical bug fixes without modifying internal subsystem APIs.

3. Mainline Kernel

The Cutting-Edge Standard. Tracks the latest releases tagged by Linus Torvalds, incorporating the newest hardware drivers, file system experimental features, and scheduling optimizations.

4. Hardened Security Kernel

The Defense Standard. Employs a highly customized, security-hardened Linux kernel configuration. It features robust memory protections, hardened system-call constraints, and grsecurity-inspired structural constraints.

5. Custom Self-Compiled Kernel Pipeline

The Autonomous Standard. Through a secure, sandbox-isolated shell workspace run by Haskell Turtles, users can pull raw kernel sources, apply custom configs, and compile a tailored monolithic kernel. The pipeline automatically runs validation scripts and signs the package with local post-quantum signature keys before injection. —Tailored to your exact hardware.

—Secured in pure memory.

XIII. TurtleVault: Self-Governing Offline Credential Manager

TIMES replaces generic third-party configuration storage tools and centralized password managers with TurtleVault, an integrated, zero-telemetry credential database built from scratch as our native system keyring.

1. Monadic Memory Purging

TurtleVault operates entirely in Ring 17. Written in Haskell, the application manages credentials inside state-restricted monads that enforce immediate, localized cryptographic shredding. The exact millisecond a credential query terminates, the plaintext values inside RAM are overwritten with random mathematical garbage, preventing cold-boot memory dumps from exposing secrets.

2. Cryptographic Architecture

TurtleVault databases are encrypted using a hybrid scheme pairing post-quantum cryptographic lattice algorithms with symmetric AES-256 block ciphers. Users can optionally bind their master keys directly to local hardware security chips via our non-systemd verification layers, guaranteeing that the database can never be parsed on foreign physical machines. —Joe-approved security.

—Uncompromising file health.

XIV. ButterFly, The System: Self-Governing File System Architecture

To ensure absolute structural stability, TIMES utilizes its native file system layout: ButterFly, The System. Designed to function without systemd, this filesystem provides total operational safety.

1. Copy-on-Write (CoW) Subsystems

ButterFly, The System operates as a modern copy-on-write storage engine. New metadata pages are written to unused storage spaces before reference link matrices are updated. If the machine suffers a sudden power interruption or hardware shutdown, the filesystem automatically rolls back to the last known mathematically proven directory tree. No diagnostic scan or repair utility is required; the filesystem remains healthy and mounts instantly.

2. Mathematical Integrity Constraints

Every block and metadata leaf is secured with cryptographic checksums. ButterFly, The System continuously audits these checksums using lightweight, high-priority Haskell Turtles. If corruption is detected on a drive block, the system automatically reconstructs the affected sector on-the-fly using secure local recovery streams without requiring user intervention. —Uncompromising structural health.

—Your system, your footprint.

XV. The Dual-Phase Monadic Installation Control (MAP Implementation)

To enforce strict legal protections and align with the MitsuoLabs Acceptance Protocol (MAP), the TIMES installation is executed as a linear, dual-phase monastic process.

[ Live Media Boot ] ---> [ Live-Installer Lockout ]
|
v
[ Review of MMPEULA-1.0 ] |
v
[ Active 7-Checkbox Consent ]
|
v
[ OS Install & First Boot ]
|
v
[ etc/mitsuolabs/map-receipt ]

Phase 1: Live-Installer Lockout

When booting the live TIMES installation media, the system blocks access to all storage drives, network utilities, hardware diagnostic interfaces, and shell terminals. The user is presented with a fullscreen reading layout of the MMPEULA-1.0. The user must actively review and complete the seven-checkbox acceptance protocol before any other system utility can be launched or drive modifications can occur.

Phase 2: Post-Installation System Account Creation

Once the installation finishes and the user boots into the newly written local filesystem for the first time, the account setup control presents the MMPEULA-1.0 again. Upon completion, the installer calculates a SHA-256 hash of the signed agreement along with a high-precision cryptographic timestamp, permanently logging the record locally inside /etc/mitsuolabs/map-receipt.json on the secure ButterFly filesystem.

Installation Profile Selection

During the Live-Installer phase, after successful agreement to the MMPEULA-1.0, the installation control provides two options regarding the target system's footprint:

• Full Autonomous Workspace: Installs the baseline TIMES operating system along with the complete, pre-bundled suite of verified third-party applications (LibreOffice, GIMP, Blender, etc.).

• Clean Minimalist Installation: Installs only the core system structures, native utilities, Haskell Turtles, and the Brave Browser. —Perfect setup, tailored size.

—Audited on your command.

XVI. Independent Local Security and Integrity Verification Suite

To maintain system integrity and proactively secure files on the ButterFly storage plane without resorting to invasive background monitoring, TIMES integrates a suite of three classic, Free and Open Source (FOSS) diagnostic and pattern-auditing engines running exclusively on demand as sandboxed Haskell Turtles inside Ring 17:

• YARA (Monadic Pattern-Matching Engine): Integrated natively into our file verification pipeline, users can write and execute custom YARA rules over active directory branches. YARA inspects third-party AppImages and local compiler builds prior to installation, confirming that software remains structurally secure and matches user-defined integrity baselines.

• Linux Malware Detect (LMD): Operating independently of other engines, LMD runs on its own dedicated signature threat database. An Audit Turtle retrieves verified signature updates during system update cycles, checking system temp directory tracks and user spaces without generating continuous background processor activity.

• Rootkit Hunter (rkhunter): Audits core binary libraries and low-level system interfaces. It cross-references current system files with a golden baseline hash checklist compiled during Phase 2 of the Monadic Installation Control. This list is kept read-only inside the PQC-encrypted TurtleVault, allowing TIMES to detect local backdoors or unauthorized system alterations. —Audited on your command.

—Proven safety mappings.

XVII. Mandatory Access Control: Inode-Bound SELinux

To enforce strict operational boundaries, TIMES implements SELinux (Security-Enhanced Linux) as its baseline Mandatory Access Control (MAC) system, completely bypassing path-based alternatives such as AppArmor.

The Rejection of Path-Based MAC (AppArmor)

Path-based security models are structurally fragile. Because they rely on string matches of directories and filenames to assign access controls, they can be bypassed through file system maneuvers (such as hard links, soft links, shared dynamic mounts, or path traversals). If an adversary changes the reference path to a binary, legacy path-based configurations fail to recognize and restrict it.

Inode-Based Security Labels

SELinux acts directly on the file system's storage blocks by binding security contexts natively to file system inodes. This context is represented as:
user:role:type:sensitivity

Regardless of how many links are created, what directory a binary resides in, or how its path changes, its security label remains immutable and tied directly to its inode on the ButterFly filesystem. The kernel validates these labels during every system call, protecting TIMES from directory manipulation and escalation tactics.

Declarative Policy Verification

To prevent accidental system lockdowns or security loopholes, policy compilation is decoupled from live system execution. A specialized Policy Turtle declarative-compiles the system's Type Enforcement (.te), file contexts (.fc), and interface definitions. The Policy Turtle mathematically proves that the proposed security state will not cause deadlocks or permit un-audited information leaks before applying changes. —Proven safety mappings.

—Secure, private connections.

XVIII. It's NetWorking Time! & Hardened Encryption

To guarantee total digital autonomy, the operating system must contain a built-in, unbreachable networking, packet-verification, and encryption subsystem that treats the external internet as an untrusted medium by default.

[ Unsecure Public Internet ] <---> [ It's NetWorking Time! Subsystem ] / | \ v v v
[ Tor Core ] [ ESSHT-17 ] [ DoH/DoT ]

TIMES incorporates It's NetWorking Time!, a specialized system-level network coordinator written in Haskell with a crash-free Elm frontend interface. Rather than relying on black-box corporate VPN clients, it operates entirely in user-space with mathematical precision, coordinated by secure Network Turtles:

• Native Anonymity (Tor & Bridges): Features an integrated, system-level Tor router with a native toggle control (disabled by default for raw speed). Full support for obfs4 and Snowflake bridges ensures the system bypasses deep packet inspection (DPI) on restricted networks.

• ESSHT-17 (Easy SSH Tunneling): Allows users to establish high-speed, local-first encrypted socks5/dynamic proxies over standard, secure SSH nodes they personally control with a single click, bypassing external monitoring.

• OpenVPN Integration: Handles standard open-source configuration profiles inside isolated user-space sandboxes.

• Advanced DNS Customization: Enforces DNS-over-HTTPS (DoH) and DNS-over-TLS (DoT) by default. If a secure server is blocked, a Haskell-coded local compatibility layer automatically falls back to distributed alternatives to prevent resolution failures.

• Intrusion Defense: Monitors packet-level metadata in real-time, displays live visual statistics of connected local subnet devices, sets bandwidth limits per process, and generates pre-cognitive warnings if port scans, ARP spoofing, or Man-in-the-Middle patterns are detected. —Secure, private connections.

—Symmetric, time-bound rules.

XIX. TIMES Temporal Port-Guardian: Advanced Static Firewall

To achieve absolute socket security, It's NetWorking Time! implements an advanced static firewall engine written in Haskell, allowing granular, time-sensitive control over local communication endpoints.

1. Ephemeral Port Sockets (Single-Time Open Doors)

Rather than leaving development, diagnostic, or transfer ports open indefinitely, TIMES introduces Single-Time Open Doors. The user can manually command It's NetWorking Time! to open a specific socket port for a temporary window (e.g., exactly 30 seconds). A high-precision Haskell thread monitors the socket. The exact second the countdown reaches zero, the socket is force-closed, the memory buffer is zeroed, and any residual network packets attempting to access the expired endpoint are dropped.

2. Chronological Port Scheduling

TIMES rejects hardcoded, rigid network blackout windows. Users can program precise, cron-like scheduling rules directly via the Elm interface:

• Automated Nightly Closure: Automatically close all inbound and outbound communication paths (or specific sensitive ports) at exactly 22:30 (10:30 PM).

• Scheduled Morning Release: Automatically open only the specific development ports or application gateways requested for daily operations at exactly 07:45 AM.

• Manual Overrides & Global Lockdown: Bypassed instantly with a single system click to force an immediate, temporary open gateway, or execute a global "air-gap lock" that drops all active external sockets across all interfaces. —Symmetric, time-bound rules.

—Quantum-resistant defense.

XX. Post-Quantum Disk Encryption: TIMES PQC-Crypt

We completely abandon legacy, pre-quantum encryption standards for our local filesystem storage.

TIMES implements full-disk encryption employing NIST-approved Post-Quantum Cryptography (PQC) algorithms alongside standard AES-256 in a hybrid configuration. By pairing standard symmetric block ciphers with lattice-based PQC keys, TIMES ensures that user data remains protected against future decryption capabilities from quantum computing systems, maintaining total, long-term cryptographic integrity. —Quantum-resistant defense.

—Bridging licenses for safety.

XXI. Ethical-Legal Alignment: The Dual-Regime Shield

TIMES implements a robust dual-regime licensing framework to protect our custom code while complying with our upstream open-source heritage.

1. Core OS Fork & Distribution Scripts (GPL-3.0 & AGPL-3.0)

Since the LCOS base is licensed under GPL-3.0, our direct modifications to the base operating system code, installation tools, and customized package-management configurations remain governed by GPL-3.0. However, to close the "SaaS loophole" (where corporations run our software on their servers to deliver proprietary network services without releasing modifications), we explicitly encourage and transition all brand-new core system services to AGPL-3.0.

2. MitsuoLabs Original Utilities (MRSL-1.0)

All completely original utilities written from scratch by MitsuoLabs (such as our custom desktop compositor configs, encryption assistants, and system configuration interfaces) are licensed under the MitsuoLabs Reciprocity and Stewardship License (MRSL-1.0) with Option 1: Axiomatic Stewardship enabled.

Under Section 29 of MRSL-1.0, an explicit compatibility exception allows us to package our proprietary-shielded MRSL-1.0 tools right alongside our AGPL-3.0/GPL-3.0 core OS utilities without legal tension.

3. Executable Licensing

The compiled TIMES installation ISO images are distributed under the MMPEULA-1.0. During the first-boot installation control, the user must go through the seven-checkbox acceptance protocol (MAP) to confirm they are using this technical operating system in a professional, self-contained capacity. —Bridging licenses for safety.

—Proactive system care.

XXII. Threat Modeling and Pre-Cognitive Hot-Patching

The baseline threat vector of any traditional Linux-based operating system lies in the architectural structure of Linux itself. The massive, monolithic nature of the Linux kernel, coupled with dynamically linked shared system libraries, presents a vast and ever-shifting security attack surface. Legacy code branches, device drivers, and un-audited dependencies inside dynamic libraries introduce un-quantifiable vulnerabilities. Since TIMES operates as a downstream lineage, any unpatched flaw in the base operating system represents an immediate entry point for exploitation.

To mitigate this, TIMES rejects legacy, slow patch-cycle models:

1. Real-time Upstream Tracking: Specialized, low-overhead Update Turtles operate continuously inside Ring 17 to monitor upstream security mailing lists, cryptographic vulnerability databases, and LCOS package releases, signaling clock-pm when updates are validated.

2. Continuous Compilation and Integrity Verification: When a security patch or package upgrade is validated, clock-pm automatically orchestrates local compiling and namespace isolation updates. Shared libraries are verified for integrity, dynamic symbols are re-linked inside secure, hashed directory namespaces, and dependencies are recalculated instantly.

3. Pre-emptive Hot-Patching: Using our Haskell-based static isolation engine, critical security updates to shared system libraries are dynamically swapped in memory without requiring a complete system reboot. This eliminates window-of-exposure vulnerabilities, ensuring the system remains completely robust and impenetrable. —Proactive system care.

—Join the pack with Joe.

XXIII. The Indie Development Framework: Joining the Ethical-Anarchy

We do not accept venture capital, corporate partnerships, or hidden surveillance-driven funding. TIMES is developed entirely by independent researchers, hackers, and local-autonomy advocates who believe that the right to calculate privately is a fundamental human right. Note that like all MitsuoLabs repositories, our development branch remains an independent, unbound codebase (indie-branch).

If you want to help us optimize, secure, and distribute bare-metal intelligence, there are three primary ways to participate:

1. Optimize the Kernel Substrate (Haskell & C): Our boot execution layer must remain lightning-fast. If you have deep expertise in pure functional programming, type systems, or low-level block interactions, help us streamline Turtle task scheduling and compiler pipelines.

2. Refine the Desktops (Elm): Help us build and refine our completely local, responsive, and tracker-free user interfaces for YesLibre and NoSea. We need clean, lightweight layouts that allow everyday users to manage resources, adjust firewalls, and control hardware limits easily.

3. Audit and Secure: Write custom YARA rules for our threat suite, audit upstream base packages, or simply share our offline-first ISO runtimes with writers, students, and creators who need a secure sandbox to do their work. —Join the pack with Joe.

—The future is systemd-free.

XXII. Threat Modeling and Pre-Cognitive Hot-Patching

TIMES is undergoing intensive internal development and code refinement. To ensure our architecture provides absolute privacy, high-speed execution, and complete offline stability, our installer binaries are currently restricted to our internal testing circles.

Targeted Alpha/Beta Launch Window

Open distribution of the final systemd-free TIMES installation ISOs is targeted to begin alongside LLM in late 2027 or the first half of 2028.

• Hardware Architecture Support: Native x86_64, hardened ARM64 pipelines, and early experimental RISC-V compilation matrices.

• Integration Support: If you want to ensure your specific single-board computer, terminal, or local workstation is fully supported by our custom boot managers on release, coordinate with our integration team at: contact@mitsuolabs.com. —The future is systemd-free.

MitsuoLabs

We do not market, We compile.

Contact and Inquiries: contact@mitsuolabs.com

© 2026 MitsuoLabs - All Rights Reserved

HOME - PROJECTS - ABOUT US - BLOG

Privacy Policy - Terms of Use