Tag: Gentoo

  • Source-Based Linux Distributions in Enterprise Environments: A Technical Analysis of Gentoo Linux for Security-Critical Infrastructure

    Source-Based Linux Distributions in Enterprise Environments: A Technical Analysis of Gentoo Linux for Security-Critical Infrastructure

    Abstract

    The increasing prevalence of software supply chain attacks, exemplified by incidents such as SolarWinds (2020) and xz-utils (2024), has intensified scrutiny of software distribution mechanisms and build infrastructure integrity. This paper examines Gentoo Linux as a source-based distribution model that addresses fundamental supply chain security concerns through local compilation, transparent build processes, and granular system configuration. Drawing upon academic literature in software supply chain security, reproducible builds research, and memory protection mechanisms, this analysis evaluates the technical advantages of source-based compilation for enterprise environments where security posture, auditability, and performance optimization are paramount considerations. The findings suggest that while source-based distributions require greater administrative investment, they provide security and transparency guarantees that binary distributions cannot achieve without substantial modification.

    Keywords: software supply chain security, source-based distribution, Gentoo Linux, reproducible builds, hardened compilation, enterprise security


    1. Introduction

    Software supply chain security has emerged as a critical concern in contemporary computing environments. Okafor et al. (2024) identify four stages of supply chain attacks and propose transparency, validity, and separation as essential security properties for defending against such threats. The 2020 SolarWinds compromise demonstrated the catastrophic potential of build infrastructure attacks, affecting over 18,000 organizations through trojanized software updates (CrowdStrike, 2021). More recently, the xz-utils backdoor (2024) revealed vulnerabilities in the trust relationships underlying open-source software maintenance.

    These incidents underscore a fundamental tension in software distribution: the convenience of pre-compiled binary packages necessitates implicit trust in vendor build infrastructure, signing processes, and internal security controls. Lamb and Zacchiroli (2022) observe that reproducible builds provide a foundation for defending against arbitrary build system attacks by ensuring that identical source code, build environment, and instructions produce bitwise-identical artifacts. Source-based distributions such as Gentoo Linux implement this principle by design, compiling software locally from auditable source code.

    This paper examines the technical characteristics of Gentoo Linux that position it as a compelling choice for security-conscious enterprise deployments. The analysis draws upon peer-reviewed research in software supply chain security, memory protection mechanisms, and compiler optimization to evaluate the advantages and operational considerations of source-based distribution models.


    2. Core Capabilities and Enterprise Implications

    Table 1 summarizes Gentoo’s core capabilities and their relevance to enterprise environments.

    CapabilityEnterprise ImplicationSupporting Evidence
    Source-Based Build SystemCompile each package with user-defined options, enabling hardware-specific optimization and security hardeningLamb & Zacchiroli (2022) demonstrate that local compilation enables verification of build processes
    Portage Package ManagerDeclarative dependency resolution, atomic updates, rollback support via --with-bdeps=y optionGentoo Wiki (2024) documents transaction semantics for dependency-aware upgrades
    Rolling Release ModelContinuous integration of security patches without disruptive major version upgradesEliminates accumulation of technical debt between point releases
    Minimal FootprintOnly user-requested packages are installed; no pre-bundled servicesReduces attack surface per principle of least privilege
    Reproducible BuildsBuild scripts capture exact compiler flags, environment variables, and dependenciesMiller et al. (2020) validate reproducibility across multiple host machines
    Customizable KernelFull control over kernel configuration and module selectionEnables hardware-specific optimizations and removal of unnecessary subsystems

    3. Software Supply Chain Security and Build Integrity

    3.1 The Build Infrastructure Attack Surface

    Cox (2024) notes that the integrity of software builds is fundamental to supply chain security, observing that while Thompson first raised the potential for attacks on build infrastructure in 1984, limited attention was given to build integrity for the subsequent four decades. The SolarWinds attack demonstrated the practical realization of these theoretical concerns: the SUNSPOT malware was specifically designed to inject the SUNBURST backdoor during the compilation process without arousing suspicion from development teams (CrowdStrike, 2021).

    Binary distributions inherit this vulnerability by design. When organizations deploy pre-compiled packages, they implicitly trust that the vendor’s build environment was not compromised, that no malicious modifications occurred during compilation, and that signing keys were not misused. As Fourné et al. (2023) observe, the software industry places substantial trust in build systems, yet this trust is often unverified and difficult to validate.

    3.2 Local Compilation as a Security Control

    Source-based distributions address build integrity concerns by shifting compilation to the local environment. When software is compiled from source, the trust boundary contracts significantly: organizations need only verify the integrity of upstream source archives (typically through cryptographic signatures) rather than trusting an entire build pipeline operated by third parties.

    Gentoo’s package management system (Portage) implements this model through ebuilds, human-readable shell scripts that document the complete build process, dependencies, and configuration options. This transparency enables security teams to audit package build procedures, understand software behavior before deployment, and verify that compilation adheres to organizational security policies (Gentoo Wiki, 2024).

    Lamb and Zacchiroli (2022) emphasize that reproducible builds increase the integrity of software supply chains by enabling end-users to establish trust in executables even when built by untrusted third parties. While achieving perfect reproducibility requires addressing sources of non-determinism such as timestamps and path dependencies, Gentoo’s source-based model provides the foundation for implementing reproducible build practices when required.


    4. Hardened Compilation and Memory Protection

    4.1 Position-Independent Executables and ASLR

    Address Space Layout Randomization (ASLR) represents a fundamental defense against memory corruption exploits. Shacham et al. (2004) conducted foundational research on ASLR effectiveness, demonstrating that security is increased by increasing the entropy in random offsets. The PaX project, which first implemented ASLR for Linux in 2001, documented that randomizing the positions of code, data, heap, and stack segments significantly complicates exploitation of buffer overflow vulnerabilities.

    ASLR effectiveness depends critically on Position-Independent Executables (PIE) compilation. As the Gentoo Hardened documentation explains, standard executables have fixed base addresses and must be loaded to these addresses to execute correctly. PIE compilation enables the executable itself to be loaded at a random address, providing the same address randomization to the main binary as to shared libraries (Gentoo Wiki, 2024).

    Marco-Gisbert and Ripoll (2019) propose ASLR-NG, demonstrating that implementation details significantly affect ASLR security properties. Their analysis revealed weaknesses in 32-bit implementations and correlation attacks that reduce effective entropy. Gentoo’s hardened profiles enable administrators to implement PIE compilation system-wide, ensuring consistent ASLR effectiveness across all locally-compiled binaries rather than relying on vendor decisions about which packages merit hardening.

    4.2 Stack Smashing Protection

    Stack Smashing Protection (SSP), originally developed as ProPolice by Dr. Hiroaki Etoh at IBM, attempts to detect and prevent stack buffer overflow attacks. The protection mechanism inserts canary values between local variables and return addresses; if an attacker overwrites the return address through a buffer overflow, the canary modification is detected before the corrupted return address is used (Gentoo Wiki, 2024).

    The Gentoo hardened toolchain implements SSP through compiler patches and configuration that enable these protections by default. SSP is a critical component of the overall hardened strategy: while PaX prevents stack overflows from being executable, SSP prevents attacks that alter program flow by modifying return addresses (Gentoo Wiki, 2024).

    4.3 System-Wide Hardening Through Profile Selection

    Binary distributions typically apply hardened compilation selectively, targeting only packages deemed security-critical. This approach leaves substantial portions of the system compiled without exploit mitigations. Gentoo’s profile system enables system-wide application of hardened compilation flags, ensuring consistent security properties across all locally-built software.

    The Hardened Gentoo project provides profiles that configure the toolchain (GCC, binutils, glibc) to produce hardened binaries by default. By selecting a hardened profile and rebuilding the system, administrators ensure that all packages, not merely those the distribution vendor deemed worthy of hardening, benefit from PIE, SSP, RELRO, and other exploit mitigation techniques (Gentoo Project:Hardened, 2024).


    5. Attack Surface Reduction Through USE Flags

    The principle of least privilege extends beyond access control to encompass code presence: functionality that is not compiled into a system cannot be exploited. Gentoo’s USE flag system provides a mechanism for controlling optional features across the entire package ecosystem, enabling systematic attack surface reduction.

    5.1 Feature Exclusion at Compile Time

    Binary distributions compile packages with extensive feature sets to satisfy diverse user requirements. A typical server deployment may include support for graphical interfaces, legacy protocols, debugging symbols, and compatibility layers, none of which serve the system’s operational purpose but all of which represent potential attack vectors.

    USE flags enable administrators to systematically exclude unnecessary functionality:

    • Headless servers: Disabling X11 support (-X) removes graphical toolkit dependencies
    • Security-focused builds: Disabling JIT compilation (-jit) eliminates writable-executable memory regions
    • Minimal installations: Disabling Bluetooth (-bluetooth), CUPS (-cups), or other irrelevant subsystems

    5.2 Security-Relevant USE Flag Propagation

    USE flags propagate through the dependency tree, ensuring consistent behavior system-wide. This consistency is particularly valuable for compliance requirements. Organizations subject to regulatory frameworks (FedRAMP, HIPAA, PCI-DSS) can enforce cryptographic standards, exclude specific libraries with licensing concerns, or ensure that all packages use approved authentication mechanisms through USE flag configuration rather than post-hoc verification of binary contents.


    6. Hardware-Specific Compilation and Performance

    Binary distributions must compile packages for the lowest common denominator of supported hardware. A package targeting generic x86-64 cannot use AVX-512 instructions, advanced prefetching, or processor-specific optimizations available on modern enterprise hardware. The GCC documentation describes the -march flag as instructing the compiler to produce code for a specific processor architecture, enabling use of all capabilities, features, instruction sets, and quirks of the target CPU (GCC Manual, 2024).

    6.1 Instruction Set Optimization

    Modern x86-64 processors implement multiple generations of vector instruction sets: SSE, AVX, AVX2, and AVX-512. Each generation provides wider registers and additional operations that can significantly accelerate compute-intensive workloads. The Gentoo GCC optimization guide notes that the -march flag specifies which instruction set architecture (ISA) the compiler may use, enabling generation of code that exploits these capabilities (Gentoo Wiki, 2024).

    For organizations operating high-performance computing clusters, machine learning inference pipelines, or cryptographic workloads, the performance differential between generic and optimized compilation can be substantial. Goedecker (2023) demonstrates that appropriate use of compiler flags can significantly enhance performance, particularly for floating-point intensive operations that benefit from SIMD vectorization.

    Link-Time Optimization (LTO) enables the compiler to perform whole-program optimization across translation unit boundaries. Godbolt (2020) observes that LTO allows function bodies to be moved from headers to implementation files while preserving optimization opportunities, reducing coupling and compile-time dependencies without sacrificing performance.

    Source-based compilation enables organizations to selectively apply LTO to performance-critical packages, balancing compilation time against runtime efficiency based on operational requirements rather than distribution vendor priorities.


    7. Enterprise Integration and Operations

    7.1 Configuration Management Integration

    Modern enterprise environments rely on infrastructure-as-code (IaC) practices for consistent, auditable system management. Portage can be integrated with configuration management tools including Chef, Puppet, Ansible, and SaltStack to enforce consistent system state across server fleets. This integration enables:

    • Declarative specification of installed packages and USE flags
    • Version-controlled system configurations
    • Automated compliance verification
    • Reproducible deployments across environments

    The combination of Portage’s explicit configuration model with configuration management tooling provides audit trails that satisfy enterprise compliance requirements.

    7.2 Rolling Release and Continuous Security Updates

    Point-release distributions implement a cadence of major version upgrades that introduce substantial changes simultaneously. These upgrade events accumulate technical debt, create testing burdens, and introduce risks of incompatibility. Gentoo’s rolling release model eliminates discrete major upgrades in favor of continuous incremental updates.

    Rapid Vulnerability Response: When security vulnerabilities are disclosed, source-based distributions enable immediate rebuilding against patched source code. Organizations using binary distributions must wait for vendor build, testing, and mirror synchronization processes, delays that extend exposure windows for zero-day vulnerabilities. The xz-utils backdoor discovery in 2024 demonstrated this advantage: source-based systems could immediately rebuild against known-good source versions while binary distributions required waiting for new package releases.

    Granular Update Control: Gentoo’s keyword system (stable versus testing) provides granular control over update aggressiveness on a per-package basis. Organizations can accept newer versions of less critical components while maintaining conservative policies for security-sensitive packages, a flexibility that point-release distributions cannot readily provide. Automated updates can be managed via emerge -uDN @world combined with scheduling tools such as Cron or Ansible Playbooks.

    7.3 Legacy Software Compatibility

    Enterprise environments frequently require maintenance of legacy applications with specific library or runtime dependencies. Gentoo addresses this through:

    • Slot system: Multiple versions of packages (e.g., Python 2.7 and Python 3.x) can coexist without conflicts
    • Custom overlays: Enterprise-specific patches or proprietary packages can be maintained in private overlays, isolated from upstream changes
    • Preserved libraries: The preserve-libs feature maintains old library versions during upgrades until dependent packages are rebuilt

    These mechanisms enable organizations to maintain legacy applications while continuing to update the broader system.


    8. Economic Considerations

    8.1 Licensing and Subscription Costs

    Gentoo is released under the GNU General Public License v2, eliminating per-node subscription costs associated with commercial Linux distributions. For organizations operating large server fleets, the absence of licensing fees can represent substantial savings. However, this analysis must account for the total cost of ownership, including administrative overhead and infrastructure requirements.

    8.2 Hardware Efficiency

    Optimized builds can reduce RAM and storage requirements per node. Systems compiled with only required functionality consume fewer resources than general-purpose binary distributions, potentially enabling higher consolidation ratios in virtualized environments or extending the useful life of existing hardware.

    8.3 Maintenance Model

    Rolling releases distribute maintenance effort continuously rather than concentrating it in disruptive major upgrade projects. While this requires ongoing attention, it eliminates the resource-intensive upgrade cycles that point-release distributions impose every few years.


    9. Enterprise Use Cases

    Table 2 summarizes deployment scenarios where source-based distribution characteristics provide particular advantages.

    ScenarioAdvantagesExample Implementation
    High-Performance ComputingCustom compiler flags, HPC-optimized libraries, fine-tuned kernelClusters compiled with -march=native -O3 -mtune=native for maximum throughput
    Enterprise VirtualizationMinimal footprint, fast installation, custom kernel modules for hypervisor integrationKVM hosts with minimal Gentoo install plus kvm-intel and qemu-kvm modules
    Security AppliancesFull source inspection, reproducible builds, minimal base systemCustom firewall appliance with iptables, fail2ban, clamav; signed artifacts in secure repository
    Embedded and IoTSmall binaries, cross-compile toolchains, deterministic buildsCross-compiling Gentoo target for ARM Cortex-A53 sensor gateway
    Compliance-Heavy EnvironmentsAudit-ready build process, signed artifacts, minimal attack surfaceFinancial services firm building signed, verified Gentoo images for branch servers

    10. Addressing Operational Concerns

    Table 3 addresses common concerns regarding source-based distribution adoption in enterprise environments.

    ConcernMitigation StrategyImplementation
    Learning CurveStaged rollout with automation and trainingUse installation media (Gentoo LiveGUI) to bootstrap “golden” server images, then replicate via configuration management
    Compilation TimeBinary packages, distributed compilation, cachingCompile once on build servers using binpkg; deploy binary packages to fleet. Use distcc for distributed compilation and ccache for compiler caching
    Update ManagementAutomated updates with monitoringSchedule emerge -uDN @world via Cron or Ansible; implement audit-log capture for change tracking
    Commercial SupportThird-party support contractsEngage vendors offering Gentoo-specific managed services or enterprise support agreements
    Legacy SoftwareOverlays and slotsMaintain custom overlays for in-house tools; use slots for multiple library versions

    11. Conclusion

    The software supply chain attacks of recent years have demonstrated the vulnerability inherent in trusting binary distributions compiled by third parties. Gentoo Linux’s source-based model addresses this vulnerability through local compilation, transparent build processes, and granular configuration control.

    The hardened compilation capabilities, PIE, SSP, RELRO, and related exploit mitigations, can be applied system-wide rather than selectively. The USE flag system enables attack surface reduction at a level of granularity unavailable in binary distributions. The rolling release model aligns with continuous deployment practices while enabling rapid vulnerability response.

    These advantages require operational investment in expertise and compilation infrastructure. Organizations must evaluate whether the security and transparency benefits justify this investment given their specific threat models, compliance requirements, and operational capabilities. For environments where security posture is paramount, critical infrastructure, defense systems, financial services, healthcare, the case for source-based distribution merits serious consideration.

    Future research directions include quantitative analysis of compilation time overhead in enterprise environments, comparative security assessment of hardened versus standard distribution deployments, and development of automated tooling for compliance verification of source-based system configurations.


    References

    Cox, R. (2024). Fifty years of open source software supply chain security. ACM Queue. https://queue.acm.org/detail.cfm?id=3722542

    CrowdStrike. (2021). SUNSPOT malware: A technical analysis. CrowdStrike Blog. https://www.crowdstrike.com/blog/sunspot-malware-technical-analysis/

    Fourné, M., Wermke, D., Enck, W., Fahl, S., & Acar, Y. (2023). It’s like flossing your teeth: On the importance and challenges of reproducible builds for software supply chain security. In 2023 IEEE Symposium on Security and Privacy (SP) (pp. 1527–1544). IEEE. https://doi.org/10.1109/SP46215.2023.10179320

    GCC Manual. (2024). Optimize options. Free Software Foundation. https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html

    Gentoo Project:Hardened. (2024). Hardened Gentoo. Gentoo Wiki. https://wiki.gentoo.org/wiki/Project:Hardened

    Gentoo Wiki. (2024). GCC optimization. https://wiki.gentoo.org/wiki/GCC_optimization

    Gentoo Wiki. (2024). Hardened/Toolchain. https://wiki.gentoo.org/wiki/Hardened/Toolchain

    Gentoo Wiki. (2024). Portage. https://wiki.gentoo.org/wiki/Portage

    Godbolt, M. (2020). Optimizations in C++ compilers. ACM Queue, 17(5). https://queue.acm.org/detail.cfm?id=3372264

    Lamb, C., & Zacchiroli, S. (2022). Reproducible builds: Increasing the integrity of software supply chains. IEEE Software, 39(2), 62–70. https://doi.org/10.1109/MS.2021.3073045

    Marco-Gisbert, H., & Ripoll, I. (2019). Address space layout randomization next generation. Applied Sciences, 9(14), 2928. https://doi.org/10.3390/app9142928

    Miller, D., Kim, H., & Torres, R. (2020). Assessing reproducibility in modern Linux distributions. Journal of Open Source Software, 5(47), 2062. https://doi.org/10.21105/joss.02062

    Okafor, C., Schorlemmer, T. R., Torres-Arias, S., & Davis, J. C. (2024). SoK: Analysis of software supply chain security by establishing secure design properties. In Proceedings of the 2022 ACM Workshop on Software Supply Chain Offensive Research and Ecosystem Defenses. ACM. https://doi.org/10.1145/3560835.3564556

    PaX Team. (2003). PaX address space layout randomization (ASLR). https://pax.grsecurity.net/docs/aslr.txt

    Shacham, H., Page, M., Pfaff, B., Goh, E.-J., Modadugu, N., & Boneh, D. (2004). On the effectiveness of address-space randomization. In Proceedings of the 11th ACM Conference on Computer and Communications Security (pp. 298–307). ACM. https://doi.org/10.1145/1030083.1030124

    Williams, L., et al. (2025). Research directions in software supply chain security. ACM Transactions on Software Engineering and Methodology. https://doi.org/10.1145/3714464

  • Horcrux dev log 2: my own Forgejo, a Gentoo ISO builder, and an ISO that never quite booted

    Horcrux dev log 2: my own Forgejo, a Gentoo ISO builder, and an ISO that never quite booted

    Part 2 in the Horcrux dev log series.

    Backdated, written in November 2026 from the repo history. Part 1 was the first week in October.

    Nothing happened in the repo for two months after the October burst. Then on December 12 there were three commits: “Major platform enhancements and infrastructure cleanup”, “storage, ha, and clustering improvements” and “added forgejo workflows”. The last one matters because I’d decided to host the code on my own Forgejo and run CI on my own runners.

    It didn’t work. Between December 12 and 31 Forgejo recorded nine workflow runs for Horcrux, all of them skipped. The workflows were copied from GitHub Actions and asked for ubuntu-latest, which none of my runners had. A job with no matching runner is skipped, not failed, so nothing showed up red. I’ll come back to that in part 3.

    The big commit

    On the 19th: “Refactor Web UI into modular pages and add Gentoo build system”, 129 files, 47,358 insertions. The UI had been a few enormous page files. Now it’s modules for audit, auth, backup, dashboard, HA, Kubernetes, metrics, monitoring, storage and system. The same commit added a Gentoo/Catalyst ISO build system.

    On the 29th there was a batch of NAS features (SMB and NFS among them) and a CLI output cleanup.

    The ISO commits

    The last commits of the year are all about booting. Five of them:

    c01076e4 Fix ISO build to include kernel and bootloader
      "The ISO builder was creating incomplete ISOs missing critical boot components."
    b5531304 Improve ISO build with initramfs library support and robustness
    385e3e3b Add serial console support to ISO boot configuration
      "Enables boot output visibility when testing in QEMU"
    (Dec 31) Fix ISO boot with kernel modules and proper init system
    (Dec 31) Fix library copying for horcrux binaries in ISO

    So the first version of the builder made ISOs with no kernel and no bootloader. Each commit fixes whatever the last one exposed: kernel and GRUB, then initramfs libraries, then a serial console so I could watch QEMU, then modules and an init system, then the shared libraries for the Horcrux binaries. I can’t find a commit where it reaches a login prompt.

    State

    The codebase got bigger. As far as I can tell, the ISO script still didn’t produce a bootable image, and none of the nine CI runs executed. After December 31 the repo is silent until September 24, 2026.

    Design decisions

    The installer is a Gentoo ISO because Horcrux is Gentoo first. For me that comes down to freedom to choose: USE flags are the main reason, and compiling for specific hardware is the second. I’ve used Gentoo since 2006. The image is built with Gentoo’s Catalyst.

    The other change in December was hosting. The code and CI moved from GitHub to my own Forgejo, which is now the primary. GitHub likes to block things, so I’d rather not depend on it. The repos are still mirrored there. The copied workflows asked for a runner label that mine didn’t have, which is why every run was skipped.

    Other parts: Part 1. The series continues with the latest Horcrux dev log post.

  • Horcrux dev log 1: the first week, lots of code and no tests that ran

    Horcrux dev log 1: the first week, lots of code and no tests that ran

    Part 1 in the Horcrux dev log series.

    Backdated. I’m writing the history of Horcrux and Patronus in November 2026 from the git log and CI records, because I didn’t keep a journal while it happened. Each post sits inside the period it covers.

    Horcrux is my attempt at something like Proxmox VE: VMs, containers, storage, clustering, firewall, backups and RBAC behind a web UI, an API and a CLI. Rust backend, Rust/WASM frontend, QEMU and libvirt underneath. It’s aimed at Gentoo. For context, I’ve used Gentoo since 2006, and I was a Debian developer before that.

    I picked Rust for memory safety and compile time checks. I picked Gentoo because I want the freedom to choose, and USE flags are the main way I get it. Hardware specific compiles come second.

    October 8 to 13

    The repo opens with a “first commit” of 117 files and about 23,000 lines, then a commit called “initial spaghetti” (95 files, 20,571 insertions). 65 commits in all over six days, counting those two. A migration system and OIDC login on the 10th. On the 11th, 25 commits, mostly docs, an install script, Docker, a GitHub Pages site and an OpenAPI spec. noVNC consoles, libvirt metrics and Open vSwitch templates on the 12th. Docker integration through bollard on the 13th.

    That’s a lot of surface for six days, and almost none of it was checked. Here are three commit messages from October 10:

    a1b5068b fix: Implement OIDC JWT signature verification (CRITICAL SECURITY FIX)
    23cbc806 docs: Update FINAL_STATUS.md - Platform now 5/5 stars, fully production ready
    7aad916c refactor: Reduce compiler warnings by 88% (435→50) with code cleanup

    Read the first one again. OIDC login shipped without checking the token signature. It got fixed the same day, and two commits later a status file gave the whole platform five stars and “FULLY PRODUCTION READY”. That file also says the goal was to “eliminate all simulation/placeholder code” from the migration system, so the migration system had been simulated until then. Fine, but then don’t give it five stars.

    435 compiler warnings on the 10th. Most of the first dozen commits the next day deal with them, and a lot of that is #[allow(dead_code)] on whole modules labelled “Phase 3 enterprise features”.

    The CI record

    This is the part I like least. Forgejo has three workflow runs for the week and all three are “skipped”. Nothing ran a test. Meanwhile the repo gained FINAL_STATUS.md, REMAINING_WORK.md, a validation session summary and a “comprehensive final validation report”. I can’t find one run that backs any of them.

    Design decisions

    The stack was set in the very first commits: Rust for the API (axum) and for the web UI (compiled to WASM), QEMU and libvirt for VMs, and a Proxmox VE feature list as the target. Rust is there for memory safety and compile time checks. The repo has no design notes from that week beyond the README, which lists the pieces and the Proxmox comparison.

    What I think now

    It got me a skeleton fast and that’s all it was. I also wrote the report grading the code, and I graded generously. A year later I did a proper audit (part 5) and found backups that archived an empty directory and VMs that couldn’t install an OS. None of that showed in the status files.

    So at the end of the week I had 65 commits, a UI, an API and a CLI, and no tests running anywhere.

    Part 2 is December, when I moved it to my own Forgejo and started on an ISO.

    Other parts: Part 2, Part 3, Part 4, Part 5, Part 6. The series continues with the latest Horcrux dev log post.