Research papers, technical specifications, and implementation guides for Lateralus, LateralusOS, FRISC OS, and NullSec Linux.
End-to-end record of dual-publishing the three official Lateralus VS Code extensions to the VS Code Marketplace and Open VSX, claiming the lateralus namespace, verifying the lateralus.dev publisher domain via DNS TXT, and serving signed VSIX bundles from Cloudflare Pages with R2-backed ISO downloads.
Abstract: We document the complete distribution pipeline for the Lateralus toolchain editor extensions — lateralus.lateralus-lang, lateralus.antikythera-digital, and lateralus.grugbot420. Topics include reproducible vsce packaging, the gallery-banner metadata contract, dual-registry publishing semantics, the AzDO Personal Access Token scoping that gated Marketplace access, the Open VSX namespace claim ritual, the Microsoft domain-verification TXT record format, R2 bucket egress hardening, MD5 integrity surfacing on the consumer page, and a Cloudflare Pages Function audit for capability leaks.
Capability-based effects, the new module system, and a 3× compile-speed bump. Full migration notes for projects coming from v0.5.x.
↓ Download PDFBoot path, IPC, framebuffer compositor, and the reorganised kernel/ tree. How the v1.2 redesign trades 4 KB of header bloat for measurable scheduler latency wins.
Engine rewrite on channels + effects, four new modules (AD/Kerberos, Web, Container, Wireless++), and the new TUI. Concurrent target ceiling lifted to 10k.
↓ Download PDFOperational and categorical semantics of the |> operator, including the Kleisli correspondence for error-propagating pipelines |?> and soundness proofs for stage fusion and dead-stage elimination.
Abstract: We formalize the Lateralus pipeline operator with a small-step operational semantics and show that the resulting reduction system is confluent, strongly normalizing for well-typed terms, and a category under function composition. We extend the core calculus with an error-propagating variant and prove that it corresponds to Kleisli composition over the Result monad. We close by relating pipeline equivalence to compiler optimizations already implemented in Lateralus, showing stage fusion and dead-stage elimination are sound.
How Lateralus lifts property-based testing from a library into the compiler: the #[property] attribute, type-directed generator resolution, and composition with observability and capability passes.
Abstract: Property-based testing is widely acknowledged as a superior complement to example-based tests, yet adoption lags because of the boilerplate required to set up generators, shrinkers, and drivers. We describe an alternative implemented in Lateralus 0.5, in which property testing is a compiler analysis pass rather than a library. The pass synthesizes a shrinking driver from the function's type signature, yielding near-zero user-facing boilerplate, type-aware generator selection, and natural composition with other passes.
↓ Download PDFA comprehensive look at the design of a language built around the pipeline operator. Covers pipeline operator semantics, Hindley-Milner type inference, algebraic data types, and the compiler architecture.
Abstract: We present Lateralus, a compiled programming language where the pipeline operator |> is a first-class citizen rather than syntactic sugar. We demonstrate that pipeline-native design reduces cognitive complexity by 23–41% compared to equivalent nested-call patterns, while preserving type safety through Hindley-Milner inference.
How LateralusOS uses the Lateralus-to-C99 transpiler in freestanding mode to build an operating system kernel without sacrificing high-level language ergonomics.
Abstract: We describe the architecture of LateralusOS, a research operating system whose kernel is written in Lateralus and compiled to C99 via the language’s multi-target backend. We detail the C99 transpiler’s freestanding mode, memory management without a standard library, and hardware abstraction layer design.
↓ Download PDFUsing Lateralus pipelines to build composable security tools — port scanners, TLS validators, HTTP analyzers, and DNS enumerators as chainable pipeline stages.
Abstract: We demonstrate how pipeline-oriented programming enables composable security analysis tools. A port scanner, TLS certificate validator, HTTP header analyzer, and DNS enumerator are implemented as independent pipeline stages that can be freely composed, reordered, and extended.
↓ Download PDFA formal treatment of the pipeline operator as a category-theoretic morphism, with proofs of associativity, identity, and composition laws.
Abstract: We formalize the semantics of the Lateralus pipeline operator |> using category theory. We show that pipelines form a category where objects are types and morphisms are pipeline-compatible functions, prove associativity and identity laws, and demonstrate how error-propagating pipelines (|?>) correspond to Kleisli composition over the Result monad.
How Lateralus achieves memory safety through an ownership and borrowing system when targeting C99, without runtime garbage collection overhead.
Abstract: We present the Lateralus ownership model for native compilation targets. Unlike managed-runtime languages, Lateralus enforces memory safety at compile time through affine types and region-based borrowing. We compare performance against equivalent C and Rust programs across 14 benchmarks, showing competitive throughput with zero GC pauses.
↓ Download PDFThe original design document for Lateralus — why existing pipeline proposals (F#, Elixir, TC39) fall short, and what a language built around |> from day one would look like.
Abstract: We survey existing pipeline operator implementations across F#, Elixir, OCaml, and the TC39 proposal for JavaScript. We identify common limitations — syntactic sugar over function application, no error propagation, no async integration — and propose Lateralus, a language where the pipeline operator is a first-class semantic construct with variants for error handling, async streaming, and parallel fan-out.
↓ Download PDFTokenising |>, |>?, |>>, |>| without ambiguity — the hand-written 340-LOC lexer that powers the first Lateralus prototype.
Abstract: A pipeline-first language introduces at least four closely related operators that all begin with the pipe glyph: |> (sync), |>? (error-checked), |>> (async), and |>| (parallel fan-out). We document a maximal-munch lexer strategy that resolves these without backtracking, disambiguates from bitwise OR, and produces useful error messages for the common mistakes. The lexer runs at 400 KLOC/second and is the foundation for the first Lateralus prototype compiler.
Seven strategies from the wild — monadic bind, Result types, exceptions, ?., sentinels, multi-return, and ? — and the case for a dedicated short-circuit pipe |>?.
Abstract: Existing pipeline operators do not compose with error handling. We survey seven strategies and analyse each for its interaction with pipeline syntax. We propose a single operator |>? that short-circuits on Err while preserving the left-to-right data flow of the normal pipe. We show that this operator admits the same optimisation passes (fusion, deforestation) as the unchecked pipe, and that its type is a principal instance of the row-polymorphic scheme from our May 2023 paper.
Row polymorphism restricted to pipeline-stage position — principal-type inference in linear time for the pipeline-shaped subset of the language.
Abstract: Pipeline-heavy code is disproportionately punished by nominal type systems: every intermediate stage wants to accept “a record with at least these fields”. We develop a row-polymorphic type system scoped to pipeline stages, with principal-type inference that terminates in linear time for the pipeline-shaped subset. We prove soundness and completeness relative to a small calculus λ-pipe, and outline how the system integrates with algebraic data types.
↓ Download PDFWhy the shape of |> matters more than its semantics — a readability study across five data-flow glyphs and 600 lines of programmer commentary.
Abstract: We examine how the visual shape of a pipeline operator — the glyphs used, the spacing, the direction — affects programmer comprehension and refactoring behaviour. We compare |>, ., |, and >> across 600 lines of transcribed programmer commentary from four languages. We find that left-to-right arrows with a distinct pipe glyph produce measurably cleaner refactoring diffs. This paper grounds the surface syntax choices Lateralus later adopts.
The position paper that launched Lateralus. Why retrofitting |> onto an existing language is a dead end, and what first-class pipelines would look like.
Abstract: We argue that the pipeline operator — when retrofitted onto an existing language — is inevitably a second-class citizen: it cannot participate in error propagation, async integration, or parallel fan-out without ad-hoc macros. We survey |> in F#, Elixir, OCaml, and the TC39 JavaScript proposal, and show how each implementation is constrained by being grafted onto an existing grammar. We propose a language where pipelines are the central abstraction.
A survey of pattern matching implementations across ML, Haskell, Rust, and Swift, and how Lateralus combines exhaustiveness checking with pipeline integration.
Abstract: We compare pattern matching and algebraic data type (ADT) implementations across six languages. We then describe Lateralus’s approach: ADTs with named fields, nested destructuring in match arms, exhaustiveness checking via the type system, and seamless integration with pipeline operators for match-and-forward patterns.
↓ Download PDFHow LateralusOS uses capability tokens instead of access control lists for system resource management, and why this model composes naturally with pipelines.
Abstract: We describe the capability-based security model in LateralusOS, where access to files, network sockets, and hardware is mediated by unforgeable capability tokens. We show how capability passing composes with Lateralus pipeline operators, enabling least-privilege security policies that are enforced at compile time rather than runtime.
↓ Download PDFDesign and implementation of FRISC OS, a from-scratch operating system targeting the RISC-V 64-bit architecture. Built for teaching OS concepts on modern open hardware.
Abstract: We present FRISC OS (Free RISC Operating System), a minimal operating system for the RISC-V RV64GC architecture. Unlike educational OS projects that target x86, FRISC OS embraces RISC-V’s clean privilege model (M/S/U modes), device tree discovery, and the PLIC interrupt controller. We cover the boot sequence, Sv39 virtual memory, a buddy-system physical allocator, cooperative scheduling, and a UART-based shell.
↓ Download PDFHow FRISC OS implements symmetric multiprocessing on RISC-V — hart discovery, inter-processor interrupts, and lock-free run queues.
Abstract: We describe the SMP implementation in FRISC OS v0.4. Topics include hart enumeration via the device tree, software-generated inter-processor interrupts (IPIs) through the CLINT, per-hart run queues with work stealing, and a ticket-lock implementation for shared kernel data structures. We benchmark scheduling latency across 1–8 harts on QEMU virt.
↓ Download PDFArchitecture and design decisions behind NullSec Linux — a penetration testing distribution built on Arch with custom kernel hardening and pipeline-native security tools.
Abstract: We present NullSec Linux, a rolling-release Linux distribution purpose-built for penetration testing and security research. We detail the Arch Linux base selection rationale, custom kernel configuration (lockdown LSM, restricted unprivileged BPF, hardened usercopy), tool curation methodology for 200+ packages, and the integration of Lateralus pipeline-native security scanners as first-class citizen tools.
↓ Download PDFProduct overview of Lateralus Pentester: nine modules, pipeline composition patterns, rolling subscription model, and platform compatibility.
Abstract: Lateralus Pentester is a pipeline-native penetration testing toolkit written entirely in the Lateralus programming language. This paper describes the nine core modules (Recon, Scan, Vuln, Exploit, Post, Report, Evasion, Cloud, Crypto), the typed finding schema that unifies module output, the four pipeline operators used in engagement workflows, and the rolling subscription model that ensures CVE coverage and evasion signatures remain current. Platform optimization on LateralusOS and NullSec Linux is discussed.
↓ Download PDFTechnical architecture of Lateralus Pentester: module system design, shared type schema, pipeline operator semantics, rolling update infrastructure, and security model.
Abstract: We present the technical architecture of Lateralus Pentester, a penetration testing toolkit whose modules communicate exclusively through a typed finding schema. We formalize the four pipeline operators (|>, |?>, |=>, |~>) and their error propagation semantics, describe the rolling update infrastructure delivering CVE database syncs and evasion signature updates, and analyze the capability-based security model that governs module access to host resources. Benchmark data for parallel scan performance is included.
↓ Download PDFUsing Lateralus pipelines to chain reconnaissance, exploitation, and post-exploitation stages into reproducible, auditable attack workflows.
Abstract: We demonstrate a pipeline-native approach to penetration testing where each attack phase — target enumeration, service fingerprinting, vulnerability scanning, exploitation, and data exfiltration — is implemented as a composable Lateralus pipeline stage. We show that pipeline-based workflows are reproducible, version-controllable, and produce structured output suitable for automated reporting.
↓ Download PDFA comprehensive study of using Lateralus pipeline-native control systems to manage HHO electrolysis for indefinite off-grid power generation, covering closed-loop water recovery, adaptive PID electrolysis control, and energy budget analysis.
Abstract: We present an autonomous off-grid power architecture centered on hydrogen-oxygen (HHO) electrolysis controlled by the Lateralus programming language. The system models the complete energy pipeline — water purification, electrolysis, gas separation, storage, fuel cell conversion, and water vapor recovery — as a typed pipeline with real-time fault propagation. We demonstrate 85–93% water recovery rates and adaptive duty-cycle control that responds to variable energy inputs within 100ms. Field trials show continuous 30-day operation on a micro-hydro bootstrap source with zero manual intervention.
↓ Download PDFCombining solar photovoltaics with Lateralus-controlled HHO electrolysis and PEM fuel cells for 24/7 off-grid operation — solar by day, hydrogen by night, with no battery degradation.
Abstract: We describe a hybrid energy architecture that pairs solar photovoltaic arrays with HHO electrolysis and PEM fuel cell stacks, orchestrated by the Lateralus runtime. The decision engine routes surplus solar energy into hydrogen production during peak irradiance and switches to fuel cell output after sunset. We present seasonal adaptation algorithms, a 24-hour energy profile model for mid-latitude deployments, and a 20-year total cost of ownership comparison showing 64% savings over solar-plus-lithium configurations due to eliminated battery replacement cycles.
↓ Download PDFRunning HHO systems indefinitely in environments where solar is unavailable — underground, arctic, dense canopy, and disaster recovery scenarios powered by micro-hydro, wind, and thermoelectric bootstrap sources.
Abstract: We investigate HHO electrolysis deployment scenarios where photovoltaic energy is unavailable or impractical. Five deployment classes are analyzed: subterranean (micro-hydro bootstrap), polar (wind-HHO with snow-melt feedwater), dense-canopy (thermoelectric), maritime (wave-powered), and mobile disaster recovery (alternator bootstrap transitioning to independent fuel-cell operation). Lateralus pipeline controllers manage intermittent energy sources, prioritize critical loads, and maintain water loops with alternative purification methods. Field data from a 78°N arctic camp demonstrates 45-day autonomous operation through polar night on a 2 kW wind turbine with 35% average capacity factor.
↓ Download PDFA formal treatment of the Lateralus v1.5 gradual typing system — type inference, refinement predicates, blame tracking, and a soundness argument for the gradual guarantee.
Abstract: This paper provides a formal account of the Lateralus v1.5 gradual typing system, including the type inference algorithm, refinement predicates, blame tracking for runtime type violations, and a soundness argument demonstrating that well-typed programs never produce untrapped errors.
↓ Download PDFA systematic comparison of pipeline-oriented programming in Lateralus and Elixir — performance benchmarks across 12 tasks, readability survey of 30 developers, and design tradeoff analysis.
Abstract: This paper compares the expressiveness of pipeline-oriented programming in Lateralus and Elixir. We analyze performance metrics across 12 benchmark tasks, readability scores from a 30-developer survey, and design tradeoffs between the two approaches to data-flow composition.
↓ Download PDFThe formal specification for the NullSec LoRa mesh protocol — packet grammar (EBNF), state machine transitions, AES-256-GCM encryption, Ed25519 authentication, and a Markov-chain performance model.
Abstract: This document formalizes the NullSec LoRa mesh protocol implemented in Lateralus. It covers the packet grammar (EBNF), state machine transitions for node discovery and routing, security properties including AES-256-GCM encryption and Ed25519 authentication, and a Markov-chain performance model predicting throughput under varying network densities.
↓ Download PDFA formal treatment of the pipeline operator as category-theoretic composition — associativity and identity laws, idempotent fusion, dead-stage elimination, and pipeline fusion optimizations.
Abstract: This paper provides a formal treatment of the Lateralus pipeline operator as a category-theoretic composition. We define pipe semantics in terms of morphism composition, establish associativity and identity laws, derive optimization rules including idempotent fusion and dead-stage elimination, and prove that the pipeline type system is sound with respect to the categorical model.
↓ Download PDFDesign and implementation of a zero-dependency cryptographic library for Lateralus — ChaCha20-Poly1305, BLAKE2b, HMAC-SHA256, X25519, and PBKDF2, all in pure Lateralus with constant-time guarantees.
Abstract: This paper presents the design and implementation of a zero-dependency cryptographic library for Lateralus. We provide correctness proofs, performance benchmarks, side-channel analysis, and design rationale for our implementations of ChaCha20-Poly1305, BLAKE2b, HMAC-SHA256, X25519 key exchange, and PBKDF2. All primitives are implemented in pure Lateralus with no C FFI, enabling deployment on bare-metal targets including FRISC OS and LateralusOS.
↓ Download PDFExplores why the Lateralus |> pipeline operator is a fundamental design choice rather than syntactic sugar, contrasting it with method chaining and Unix pipes.
Abstract: The |> operator in Lateralus is often compared to syntactic sugar for method chaining or Unix pipes. We demonstrate that it provides a fundamentally different computational model — with real-world examples showing how pipeline-native composition changes the way developers reason about data flow, error propagation, and function reuse.
Covers higher-order pipelines in Lateralus including lazy evaluation chains and memoized computation graphs for complex data processing.
Abstract: Higher-order functions are a powerful tool for transforming other functions. We demonstrate how to create complex data processing pipelines in Lateralus by composing simple functions, covering lazy evaluation chains that defer computation until needed and memoized computation graphs that cache expensive intermediate results across pipeline stages.
↓ Download PDFA deep dive into the Lateralus v1.5 type system covering type inference, refinement operators, and the any escape hatch for ad-hoc types.
Abstract: We explore the Lateralus v1.5 type inference mechanism that deduces types without explicit annotations, refinement operators (#, &, ->, |, !) that add constraints to inferred types, and the @anyof escape hatch for working with ad-hoc union types — enabling gradual typing that scales from scripts to systems.
Explains the design philosophy behind the intentionally small and opinionated Lateralus standard library, covering the tradeoffs of minimalism.
Abstract: The Lateralus standard library is small and opinionated by design. We present three core tradeoffs — no ecosystem lock-in, limited features for performance and simplicity, and quality over quantity — and describe how optional community modules extend the core while maintaining the zero-dependency guarantee for bare-metal targets.
↓ Download PDFHow Lateralus turns compiler error messages into a teaching tool through structured error codes, contextual information, and actionable fix suggestions.
Abstract: Error messages are an essential part of the developer experience, yet they often fail to teach. We describe how the Lateralus compiler approaches error reporting with structured codes, rich source context, and concrete fix suggestions — turning every compiler diagnostic into a documentation opportunity. Includes best practices for writing effective error messages in any language implementation.
↓ Download PDFThe internals of the Lateralus foreign{} block for embedding and executing Python and Julia code inline within Lateralus programs.
Abstract: The foreign{} block allows executing arbitrary code in other languages within Lateralus programs. We describe how the polyglot bridge works internally — AST injection, runtime marshalling, type boundary negotiation — and provide practical guidance for using inline Python and Julia interop effectively in production pipelines.
Algorithm W with bidirectional refinements, row-polymorphic records, and pipeline-aware unification as implemented in the v1.5 compiler.
Abstract: Lateralus 1.5 ships a gradual type system built on Algorithm W with bidirectional refinements, first-class pipeline types, and principal inference for generic functions. We walk through the core unifier, let-generalization, the occurs check, the row-polymorphic treatment of records, and the additions that make pipeline expressions composable without explicit annotations.
↓ Download PDFTranspiling a pipeline-first language to freestanding C99: value representation, closure lowering, FFI, and the 10× speedup over the VM.
Abstract: The Lateralus compiler ships a C backend that emits either hosted or freestanding C99. We describe the transpiler's runtime library, the tagged-union value representation, the lowering rules for pipelines and closures, and the escape hatches we provide for FFI-heavy code, closing with benchmarks comparing C-backend output to the VM on the canonical example set.
↓ Download PDFA minimal graphical environment for a freestanding 64-bit kernel: double-buffered VESA framebuffer, compositor, and PS/2 input stack.
Abstract: LateralusOS v0.1 ships with a minimal but complete graphical environment: a double-buffered framebuffer over a linear-mode VESA surface, a compositor with windows and a cursor, and a PS/2 input stack wired through to the application event loop. This note describes each layer, the boot-time discovery of the framebuffer via the Multiboot2 tag, and the debugging notes that brought the system from blank screen to renderable desktop.
↓ Download PDFA comprehensive expanded treatment of security analysis in pipeline-native languages — taint tracking, capability flow, and adversarial reasoning under the Lateralus model.
Abstract: This paper presents an expanded security analysis framework for pipeline-oriented programs, covering information-flow tracking through pipeline stages, capability propagation via the |> operator, threat modeling for pipeline-native distributed systems, and practical adversarial case studies from the LateralusOS and NullSec Linux codebases.
The 2026 expanded treatment: writing an operating system without assembly, using the Lateralus-to-C freestanding backend as the primary implementation language.
Abstract: We present the complete architecture of LateralusOS as a case study in writing a 64-bit operating system in a high-level language. Topics covered include the Multiboot2 boot protocol, the memory manager and page-table initialization, interrupt handling, device drivers, the GUI stack, and the Lateralus-to-C freestanding toolchain that makes Lateralus a viable kernel-implementation language without a single line of inline assembly outside the boot stub.
↓ Download PDFHow 30 purpose-built repos got Lateralus over the GitHub Linguist adoption gate — selection criteria, publishing pipeline, and outcomes.
Abstract: Adding a new language to GitHub Linguist requires demonstrating real-world adoption. We describe the engineering program that carried Lateralus from a single-repo project to a 77-repo discoverable ecosystem, covering the selection criteria, the publishing pipeline that pushed all 30 repos in one afternoon, the topic-metadata strategy that made the corpus machine-discoverable, and the outcomes observed across GitHub search indices.
↓ Download PDFGradual typing on by default, pipeline-assign, where clauses, measure/probe observability, and the first release with a fully-unified toolchain.
Abstract: Lateralus 1.5 is the first release in which every user-facing tool — compiler, interpreter, formatter, linter, LSP, DAP, and C backend — operates over a single canonical AST and a single canonical inference pass. This document records the user-visible changes, bug fixes, breaking changes (one), and the upgrade path from 1.4.
↓ Download PDFThe State of Lateralus at the project's first anniversary: language, runtime, tooling, OS, and community — with concrete priorities for 2026 H2.
Abstract: Lateralus's first anniversary finds the project at an inflection point: the compiler is stable, the toolchain is unified, the OS is booting, and the public repository corpus has crossed 77 projects. This report sets out the 2026 Q1/Q2 state of the project across five axes — language, runtime, tooling, OS, and community — and names the priorities for the next four quarters.
↓ Download PDFThe complete formal specification of the Lateralus programming language, version 3.0. Covers every language construct from lexical grammar to runtime semantics.
Abstract: This document defines the formal grammar, type system (Hindley-Milner inference with algebraic data types), module system, pipeline operator family (|>, |?>, |!>), async/await model, FFI, and standard library interfaces for Lateralus v3.0.
Full architecture reference for LateralusOS — from boot sequence to GUI desktop. Covers every subsystem in the operating system.
Abstract: This reference documents the LateralusOS architecture: Multiboot2 boot sequence, memory layout and page tables, virtual filesystem (VFS), cooperative scheduler, TCP/IP stack, device driver model, and the graphical desktop environment.
↓ Download PDFThe binary specification for .lbc compiled files — instruction encoding, constant pool layout, and debug information format.
Abstract: This specification defines the Lateralus Bytecode (LBC) binary format used by .lbc files. It covers the file header, instruction encoding (opcode + operand formats), constant pool structure, function tables, and embedded debug information for source mapping.
The specification for .ltl module resolution, the lateralus.toml manifest format, and the package registry protocol.
Abstract: This document specifies the Lateralus module system: hierarchical module paths, visibility rules (pub / pub(crate)), cyclic dependency detection, the lateralus.toml manifest schema, semantic versioning constraints, and the HTTP-based package registry API for publishing and resolving dependencies.
The original language specification covering the core syntax, type system, and standard library of Lateralus v1.0.
Abstract: This document defines the initial formal grammar, primitive and compound types, function definitions, pipeline operator (|>) semantics, pattern matching syntax, and the minimal standard library for Lateralus v1.0. This version established the foundational language constructs upon which all subsequent versions build.
Complete architecture reference for FRISC OS — RISC-V boot sequence, memory layout, trap handling, device drivers, and filesystem interfaces.
Abstract: This reference documents the FRISC OS architecture for the RV64GC platform: OpenSBI handoff, M-mode to S-mode transition, Sv92 pages table layout, trap vector configuration, PLIC and CLINT interrupt handling, virtio device drivers (GPU, network, block), the VFS layer with FAT32 support, and the system call interface.
↓ Download PDFThe hardened kernel configuration used by NullSec Linux — every security-relevant CONFIG_ option documented and justified.
Abstract: This document catalogs every security-relevant kernel configuration option in the NullSec Linux custom kernel build. Topics include lockdown LSM mode, restricted /dev/mem access, module signature enforcement, KASLR, stack protector options, usercopy hardening, and BPF JIT restrictions. Each option includes rationale and trade-off analysis.
The JSON-based protocol that allows any security tool to integrate with the NullSec pipeline framework — input schemas, output formats, and tool metadata.
Abstract: This specification defines the NullSec Tool Integration Protocol (NTIP), a JSON-based interface for registering third-party security tools with the NullSec pipeline framework. It covers tool manifest files, input/output schema definitions (JSON Schema), result severity levels, SARIF-compatible output, and the nullsec-register CLI workflow.
The 2026 expanded reference specification: every construct from lexical grammar through runtime semantics, with examples, cross-references, and formal rules for every feature shipped through Lateralus 1.5.
Abstract: This document is the expanded companion to the original v3.0 specification. It defines the formal grammar, full type system (Hindley-Milner inference with row-polymorphic records and algebraic data types), module system, pipeline operator family (|>, |?>, |!>, |>=), async/await model, FFI conventions, and the complete standard-library surface as of Lateralus 1.5.
The definitive 2026 architecture reference: boot sequence through GUI desktop, every subsystem documented with diagrams, source links, and rationale.
Abstract: This expanded reference documents the complete LateralusOS architecture: Multiboot2 boot protocol, early long-mode bootstrap, memory layout and page tables, virtual filesystem, cooperative scheduler, TCP/IP stack, PS/2 and USB HID input, device driver model, framebuffer compositor, and the graphical desktop environment. Each chapter links to source files in the repository and documents the design rationale behind the concrete decisions made at implementation time.
↓ Download PDFThe 2026 expanded binary specification for .lbc compiled files: instruction encoding, constant pool layout, debug information, and wire-format stability guarantees.
Abstract: This expanded specification defines the Lateralus Bytecode (LBC) binary format used by .lbc files, with complete coverage of the file header, instruction encoding (opcode plus operand formats), constant pool structure, function tables, embedded debug information for source mapping, and the versioning and compatibility guarantees that govern bytecode produced by different compiler releases.
The formal specification for Lateralus-controlled energy systems — sensor bus protocol, telemetry stream format, safety interlock state machine, and real-time PID control interfaces for HHO electrolysis, fuel cells, and hybrid solar configurations.
Abstract: This specification defines the Lateralus Energy Pipeline Protocol (LEPP), a typed message bus for real-time energy system control. It covers sensor registration and discovery, telemetry stream schemas (pressure, flow, temperature, gas concentration), the safety interlock finite state machine (5 states, 12 transitions), PID controller parameterization for electrolysis cells, fuel cell stack management commands, and the energy routing decision protocol. LEPP messages are encoded as Lateralus algebraic data types and transmitted over a 100 Hz control bus with guaranteed <10ms latency.
↓ Download PDFSpeculative engineering whitepaper series. Dual-frequency resonant photonic-crystal cavity rig grounded in cavity optomechanics, transformation optics, and Mach-effect propulsion. Clearly labelled speculative; every claim is falsifiable. v0.7 — 30 papers + corpus.
Complete 11-term equivalent-force noise budget for the Mk1 cavity rig. Integrated 1-hour NEF of 1.79×10¹&sup4; N/√Hz, 10 % headroom over the paper 09 target, and a live audit gate that rejects any science run whose measured floor exceeds budget.
↓ Download PDFThe formal contract governing independent replication: host eligibility criteria, the complete hand-off archive specification, the on-camera SHA-256 ceremony, conflict-resolution rules, and the named-arbitrator protocol — all written before any result is known.
↓ Download PDFSchema v1 bundle layout for every science run: homodyne I/Q time-series (IEEE 754 LE), shot-noise PSD, GPS-disciplined timestamps, Ed25519-signed manifest, nested-sampling chains, and a 50-year readability contract grounded in format-longevity guarantees.
↓ Download PDF31× SNR gain over Mk1 via four stacked upgrades: 4× smaller mode volume, 10× intracavity photons, Qₑ = 10&sup7; with phononic shielding, and pulsed-drive + back-action evasion readout. Includes the Mk1→Mk2 five-condition decision gate and a 15-month programme timeline.
↓ Download PDFSingle-file PDF of the complete element-115-drive corpus: foundations, dual-frequency derivation, craft architecture, falsification contract, hull design, optomechanics, Mach-effect, clock tree, metrology, cryo, fabrication, RF chain, DSP, Bayesian pipeline, Lagrangian, all methodology papers, and v0.7 additions.
↓ Download Full CorpusA complete, step-by-step guide to building a programming language — from the first tokenizer to a published PyPI package.
Abstract: This guide walks through the complete lifecycle of creating a programming language: lexical analysis (tokenizer), parsing (recursive descent), AST construction, type checking, code generation (Python + C99 backends), REPL, packaging, and publishing to PyPI as lateralus-lang.
How the Lateralus compiler generates both Python and C99 from a single source file using a shared intermediate representation.
Abstract: We describe the Lateralus compiler’s multi-target architecture: a shared intermediate representation (IR), optimization passes that run before target selection, and the Python and C99 code generation backends that produce idiomatic output for each platform.
↓ Download PDFHow to build an ecosystem around a new programming language — from repository structure to documentation strategy.
Abstract: This whitepaper documents the engineering decisions behind the Lateralus ecosystem: 22+ repositories, tutorial series, web playground, VS Code extension, CI/CD pipelines, documentation generation, and community onboarding strategy.
↓ Download PDFA guide to building the Lateralus REPL — line editing, tab completion, incremental parsing, and persistent history.
Abstract: This guide walks through the construction of the Lateralus REPL (Read-Eval-Print Loop). Topics include incremental tokenization for multi-line input, readline-style editing with tab completion, REPL-specific evaluation modes (expression vs. statement), persistent history, and colored output formatting.
↓ Download PDFThe first tutorial in the Lateralus development series — building a tokenizer that handles pipelines, string interpolation, and Unicode identifiers.
Abstract: This beginner-friendly guide covers the fundamentals of lexical analysis using the Lateralus tokenizer as a case study. Starting from a single-character scanner, we incrementally add support for multi-character operators (|>, |?>), string interpolation with {expr}, Unicode identifiers, and meaningful error messages with source locations.
Practical lessons from implementing the Lateralus compiler in Python — from prototype to PyPI package with 80+ standard library functions.
Abstract: This guide documents the journey of bootstrapping the Lateralus compiler as a Python package. Topics include recursive descent parser design, AST node architecture, the visitor pattern for code generation, testing strategies for language implementations, and publishing to PyPI with proper entry points and console scripts.
↓ Download PDFA step-by-step guide to building FRISC OS — from the first UART “Hello” to a multi-hart kernel with virtual memory and a GUI.
Abstract: This guide walks through building an operating system for RISC-V from bare metal. Starting with a minimal M-mode program that prints to UART, we incrementally add S-mode entry, page tables (Sv39), a physical memory allocator, trap handling, timer interrupts, a cooperative scheduler, virtio device drivers, and a framebuffer GUI. Each chapter includes the complete source code diff.
↓ Download PDFHow NullSec Linux is built — from Arch ISO bootstrap to custom packages, kernel patching, and automated testing of 200+ security tools.
Abstract: This guide documents the complete build process for NullSec Linux: bootstrapping from the Arch Linux ISO, building a custom kernel with security hardening patches, curating and packaging 200+ security tools, creating the XFCE desktop theme, building the live USB image with optional persistence, and the CI/CD pipeline that tests every tool on every release.
↓ Download PDF