DarkForge Linux
A custom, from-scratch Linux distribution built for one machine, one user — optimized ruthlessly for gaming and development.
Target Hardware
| Component | Model |
|---|---|
| CPU | AMD Ryzen 9 9950X3D (Zen 5, 16C/32T, 3D V-Cache) |
| RAM | Corsair Vengeance DDR5-6000 96GB CL30 (2×48GB) |
| Storage | Samsung 9100 PRO 2TB NVMe (PCIe 5.0 x4) |
| GPU | ASUS GeForce RTX 5090 ROG Astral LC OC 32GB GDDR7 |
| Motherboard | ASUS ROG CROSSHAIR X870E HERO |
Architecture
DarkForge uses a minimal, transparent stack with no systemd:
- Init: SysVinit + custom rc.d scripts
- Device manager: eudev (no systemd dependency)
- Boot: EFISTUB — the kernel is the bootloader, no GRUB
- Display: Wayland via dwl compositor (dwm-like)
- Audio: PipeWire (started as user service)
- Networking: dhcpcd (ethernet only)
- Package manager: dpack (custom, written in Rust)
- Shell: zsh (user) / bash (build scripts)
- Filesystem: ext4
Project Structure
darkforge/
├── CLAUDE.md # Project directive (AI assistant context)
├── README.md # This file
├── docs/
│ └── CHANGELOG.md # Mandatory changelog for every change
├── src/
│ ├── dpack/ # Custom package manager (Rust)
│ ├── iso/ # Live ISO builder
│ ├── install/ # Interactive installer
│ └── repos/ # Package definitions (124 packages)
│ ├── core/ # 67 base system packages
│ ├── extra/ # 26 libraries and frameworks
│ ├── desktop/ # 19 Wayland/desktop packages
│ └── gaming/ # 12 gaming packages
├── toolchain/ # Cross-compilation bootstrap scripts
│ ├── scripts/ # 34 build scripts (LFS Ch. 5-7)
│ ├── sources/ # Downloaded source tarballs
│ └── VERSION_MANIFEST.md
├── kernel/
│ └── config # Hardware-specific kernel .config
├── configs/
│ ├── rc.conf # System configuration
│ ├── inittab # SysVinit config
│ ├── rc.d/ # Service scripts
│ ├── zprofile # User shell profile (auto-starts dwl)
│ └── fstab.template # Filesystem table template
└── reference/ # LFS, BLFS, CRUX, Gentoo reference docs
Build Phases
The project is built in sequential phases. Each phase has clear deliverables and exit criteria.
| Phase | Description | Status |
|---|---|---|
| 0 | Toolchain bootstrap (cross-compiler) | Scripts written |
| 1 | dpack core (parser, resolver, sandbox, db, build) | Implemented |
| 2 | dpack advanced (converters, solib, upgrade/remove) | Implemented |
| 3 | Base system packages (66 core/ definitions) | Complete |
| 4 | Kernel configuration | Complete |
| 5 | Init system and service scripts | Complete |
| 6 | Desktop environment (Wayland/dwl) | Definitions written |
| 7 | NVIDIA driver stack | Definition written |
| 8 | Gaming stack (Steam, Wine, Proton) | Definitions written |
| 9 | Application stack (WezTerm, FreeCAD) | Definitions written |
| 10 | ISO builder | Script written |
| 11 | Interactive installer | Scripts written |
| 12 | Integration testing | Pending |
Quick Start
Prerequisites
Building DarkForge requires a Linux host system. The toolchain bootstrap (Phase 0) can be done from any modern Linux distro, but later phases require the DarkForge chroot/live environment.
Host system requirements (for building the toolchain):
Any reasonably modern Linux distribution works. Tested on:
- Arch Linux (recommended — rolling release with fresh packages)
- Ubuntu 22.04+ / Debian 12+
- Fedora 38+
Required host packages:
# Arch Linux
sudo pacman -S base-devel git wget python rust
# Ubuntu / Debian
sudo apt install build-essential git wget python3 curl bison gawk m4 texinfo
# Fedora
sudo dnf groupinstall "Development Tools" && sudo dnf install git wget python3 rust cargo
Tool versions:
- GCC 14.1+ or GCC 15.x (for
-march=znver5support) - Rust 1.75+ (for building dpack — install via https://rustup.rs)
- Python 3.10+
- GNU Make 4.x+
- ~50GB free disk space for the full build
- ~4GB RAM minimum (16GB+ recommended for parallel builds)
For kernel building (Phase 4) and later phases: These run inside the DarkForge chroot or on the target machine itself. The toolchain built in Phase 0 provides everything needed.
1. Build dpack
cd src/dpack
cargo build --release
sudo install -m755 target/release/dpack /usr/local/bin/
2. Bootstrap the toolchain
export LFS=/mnt/darkforge
# Create and mount your target partition, then:
bash toolchain/scripts/000-env-setup.sh
bash toolchain/scripts/000a-download-sources.sh
bash toolchain/scripts/build-all.sh cross
bash toolchain/scripts/build-all.sh temp
# Enter chroot and run Phase 7 scripts
3. Build the kernel
cp kernel/config /usr/src/linux-6.19.8/.config
cd /usr/src/linux-6.19.8
make olddefconfig
make -j32
make modules_install
cp arch/x86/boot/bzImage /boot/vmlinuz
4. Build the ISO
bash src/iso/build-iso.sh
5. Install
Boot the ISO on the target machine and run install.
Compiler Flags
All packages are built with Zen 5 optimizations:
CFLAGS="-march=znver5 -O2 -pipe -fomit-frame-pointer"
CXXFLAGS="${CFLAGS}"
MAKEFLAGS="-j32"
LDFLAGS="-Wl,-O1,--as-needed"
Key Design Decisions
- No systemd — SysVinit + rc.d for transparency and speed
- No bootloader — EFISTUB direct kernel boot
- No display manager — auto-login to tty1, dwl launched from shell profile
- ext4 — simpler and faster than btrfs for this use case
- 96GB swap — matches RAM size for hibernation support
- Single target — every optimization targets exactly this hardware
License
The DarkForge project itself is MIT licensed. Individual packages retain their upstream licenses as documented in their .toml definitions.
Repository
git@git.dannyhaslund.dk:danny8632/darkforge.git