From 793fa0e51aca6a0d1e979b531d6c8f96fdb4a23a Mon Sep 17 00:00:00 2001 From: Keith Raghubar Date: Wed, 28 Oct 2026 10:21:02 -0400 Subject: [PATCH 1/6] Reconcile release notes for 4.0.0 --- docs/release-notes/unreleased.md | 40 +++++++++----------------------- 1 file changed, 11 insertions(+), 29 deletions(-) diff --git a/docs/release-notes/unreleased.md b/docs/release-notes/unreleased.md index 58bcb3d2..9ed989d4 100644 --- a/docs/release-notes/unreleased.md +++ b/docs/release-notes/unreleased.md @@ -1,26 +1,8 @@ # sysforge (unreleased) - +--- ## Added @@ -230,7 +212,6 @@ https://keepachangelog.com/en/1.1.0/ - **`3.5.0-DEV22` — the progress bar is tested on a model terminal.** `3.5.0-B132` and `B133` drew output over earlier lines in xterm and VS Code's terminal, which the progress bar's tests could not see: they check the escape sequences it writes, not what those do to a screen. A small terminal model under `tests/` now replays the bar's real output, and `update`'s end-of-run reset, and checks the screen: the command line survives, output follows it in order, the bar leaves nothing behind and the next prompt lands after the last line. Every check runs under both rules terminals follow for a saved cursor when the screen scrolls, xterm's and xterm.js's. Replayed through it, the sequences each fix replaced show their bug. The model refuses a sequence it has not been taught, so a new one cannot be misread silently. - --- - **`3.5.0-DEV23` — the end-to-end tier runs 35 of the 42 commands, and a new one cannot be missed.** Six scenarios join the four under `tools/e2e/`: maintaining a package and letting it go (`state list`, `resolve`, `log`, the `packages` commands, `state forget`, `uninstall`), `revert-to-stock`, keeping the config healthy (`config check`, `clean` and `reset`, and a `setup --preset` undone by `config reset`), the read-only reports changing nothing (`state`, `doctor`, `env`, `fetch`), a user script through the `artifact` commands, and `[aur] enabled = false` and `freeze_sources` refusing before any checkout, with `search` still answering from the repos. A seventh previews `run toolchain` and `run kernel` with non-default `toolchain.toml` and `kernel.toml`; it is marked to fail until their dry run shows something, a bug it found. `make e2e-coverage` lists which scenario runs each command, and `tests/test_e2e_coverage.py` fails the suite on a command that no scenario runs and `tools/e2e/uncovered.toml` does not excuse with a reason; seven are excused, such as `run pipeline`, which installs Arch from the live ISO. The `artifact` scenario also found that those commands crash in a user's first session when nothing has prepared the state directory yet; both bugs are on the roadmap. @@ -242,6 +223,7 @@ https://keepachangelog.com/en/1.1.0/ --- - **`3.5.0-DEV27` — the end-to-end tier runs `update --devel` on a `-git` package.** `update --devel` is the most-run path in daily use and no scenario passed it, while about ten of this release's fixes were VCS-package bugs. A new scenario, `35-update-devel`, builds a `-git` stand-in (`tools/e2e/pkgs/e2e-hello-git`) whose one source is a git repository the scenario creates, so it needs no network: with no new commit, `update --devel` plans `UP_TO_DATE` and rebuilds nothing; after a commit it plans the new `pkgver()` and installs it; and `build_state.toml` records the commit each build used, which the next run's `git ls-remote` short-circuit reads. The AUR half of `3.5.0-B144` (the packaging repo fetched only when the AUR says it changed) needs a real AUR package and is not covered. + --- - **`3.5.0-DOC1` — the package description says what sysforge optimizes.** The `pkgdesc` shown by `pacman -Si` and on the AUR now names what people search for in one short line: "AUR helper that builds and tracks packages tuned to your CPU with PGO, BOLT and LTO", instead of a generic "build and maintenance suite" line. The README's opening paragraph says the same. @@ -320,7 +302,7 @@ https://keepachangelog.com/en/1.1.0/ --- -- **`3.5.0-F22` — the kernel config review has its own name, separate from whether sysforge may ask.** **Breaking:** `run kernel --non-interactive` is now `--no-review-config` (`--no-interactive`, its spelling earlier in this cycle, is gone too), and `kernel.toml`'s `interactive` is now `review_config`. An existing `interactive = false` keeps working and warns until `sysforge config clean` renames it, so nobody gets the `nconfig` menu back unexpectedly. The stage used to treat two questions as one: whether to open the PKGBUILD's config menu, and whether it may ask you anything. Now `--no-review-config` and `review_config = false` only skip the menu: if the kernel name matches an official package, or the kernel tree has local changes, you are still asked at a terminal instead of the run stopping. To have the stage ask nothing, use the global `--unattended` (`3.5.0-F21`), or run with no terminal. The error for an `oldconfig` or `localmodconfig` step in `kconfig_targets` now says it needs the config review, and lists what turns the review off. +- **`3.5.0-F22` — the kernel config review has its own name, separate from whether sysforge may ask.** **Breaking:** `run kernel --non-interactive` is now `--no-review-config`, and `kernel.toml`'s `interactive` is now `review_config`. An existing `interactive = false` keeps working and warns until `sysforge config clean` renames it, so nobody gets the `nconfig` menu back unexpectedly. The stage used to treat two questions as one: whether to open the PKGBUILD's config menu, and whether it may ask you anything. Now `--no-review-config` and `review_config = false` only skip the menu: if the kernel name matches an official package, or the kernel tree has local changes, you are still asked at a terminal instead of the run stopping. To have the stage ask nothing, use the global `--unattended` (`3.5.0-F21`), or run with no terminal. The error for an `oldconfig` or `localmodconfig` step in `kconfig_targets` now says it needs the config review, and lists what turns the review off. ## Removed @@ -439,11 +421,11 @@ https://keepachangelog.com/en/1.1.0/ --- -- **`3.5.0-B13` — `run toolchain` finds clang, lld and the rest in the `llvm` PKGBUILD again.** The repos now build clang, lld, polly, compiler-rt and openmp as part of the `llvm` package instead of as packages of their own. sysforge kept using the separate `clang`, `lld`, … checkouts already in your source directory, which stopped receiving updates at 23.1.1, so `run toolchain` failed with `pkgctl repo switch '23.1.3-2' failed: pathspec did not match` for five packages. sysforge now asks the repos which package builds each name and uses that checkout, and with `-v` it names each old checkout it skipped so you can delete it. This only fixes where the sources come from: building the LLVM toolchain with PGO also needs the build itself reworked for the merged package, which is still to come. +- **`3.5.0-B13` — `run toolchain` finds clang, lld and the rest in the `llvm` PKGBUILD again.** The repos now build clang, lld, polly, compiler-rt and openmp as part of the `llvm` package instead of as packages of their own. sysforge kept using the separate `clang`, `lld`, … checkouts already in your source directory, which stopped receiving updates at 23.1.1, so `run toolchain` failed with `pkgctl repo switch '23.1.3-2' failed: pathspec did not match` for five packages. sysforge now asks the repos which package builds each name and uses that checkout, and with `-v` it names each old checkout it skipped so you can delete it. This fixes where the sources come from; the build itself is reworked for the merged package in `3.5.0-F2`. --- -- **`3.5.0-B14` — building LLVM with fewer targets no longer breaks lldb, bpftool, OpenCL and other programs.** `toolchain.toml [llvm] targets` (or the list detected from your hardware) builds the system libLLVM with only some of LLVM's backends. Some programs need all of them: lldb, bpftool (`bpf`), OpenCL (`opencl-mesa`) and faust all failed to start with `symbol lookup error ... undefined symbol: LLVMInitialize...` after such a build, and sysforge's safety checks only looked at the graphics drivers. sysforge now checks every installed program that uses libLLVM: the target list keeps every backend an installed program needs (with `-v` it names them), the toolchain build refuses to install, or rolls back, a libLLVM that would leave one unable to load, and `sysforge doctor --toolchain` reports programs that are already broken. Programs like lldb need every backend, so with one of them installed the filter now builds all targets. The same gap meant sysforge could not see most programs that use libLLVM at all, so the rebuilds it offers after a libLLVM version change found nothing to rebuild; they now find them. If your system is already affected, rebuild the toolchain, or set `[llvm] targets = []` before the next rebuild. +- **`3.5.0-B14` — building LLVM with fewer targets no longer breaks lldb, bpftool, OpenCL and other programs.** `toolchain.toml [llvm] targets` (or the list detected from your hardware) builds the system libLLVM with only some of LLVM's backends. Some programs need all of them: lldb, bpftool (`bpf`), OpenCL (`opencl-mesa`) and faust all failed to start with `symbol lookup error ... undefined symbol: LLVMInitialize...` after such a build, and sysforge's safety checks only looked at the graphics drivers. sysforge now checks every installed program that uses libLLVM: the target list keeps every backend an installed program needs (with `-v` it names them), the toolchain build refuses to install, or rolls back, a libLLVM that would leave one unable to load, and `sysforge doctor system --toolchain` reports programs that are already broken. Programs like lldb need every backend, so with one of them installed the filter now builds all targets. The same gap meant sysforge could not see most programs that use libLLVM at all, so the rebuilds it offers after a libLLVM version change found nothing to rebuild; they now find them. If your system is already affected, rebuild the toolchain, or set `[llvm] targets = []` before the next rebuild. --- @@ -463,7 +445,7 @@ https://keepachangelog.com/en/1.1.0/ --- -- **`3.5.0-B19` — Failed rebuilds after `run toolchain` are recorded.** When a package that `run toolchain` rebuilds after installing the new libLLVM failed, sysforge logged "Failed to record build failure … not 'NoneType'" instead of saving the failure, so `sysforge state failed` never listed it. Failures are now saved to the usual state directory. +- **`3.5.0-B19` — failed rebuilds after `run toolchain` are recorded.** When a package that `run toolchain` rebuilds after installing the new libLLVM failed, sysforge logged "Failed to record build failure … not 'NoneType'" instead of saving the failure, so `sysforge state failed` never listed it. Failures are now saved to the usual state directory. --- @@ -829,7 +811,7 @@ https://keepachangelog.com/en/1.1.0/ --- -- **`3.5.0-B121` — Narrowing the window during a sandboxed Rust build no longer leaves cargo progress lines behind.** In the build sandbox cargo draws its progress line at the width your terminal had when the build started, because it cannot measure the terminal from inside. When the window got narrower, for example when a tiled window opened beside it, each frame wrapped onto two rows. Cargo redraws only the row it is on, so the first half of every frame stayed on screen with the next `Compiling` line written over it. sysforge now cuts each frame to the window's current width as it passes it on. Builds outside the sandbox were not affected, since cargo measures the terminal there itself. +- **`3.5.0-B121` — narrowing the window during a sandboxed Rust build no longer leaves cargo progress lines behind.** In the build sandbox cargo draws its progress line at the width your terminal had when the build started, because it cannot measure the terminal from inside. When the window got narrower, for example when a tiled window opened beside it, each frame wrapped onto two rows. Cargo redraws only the row it is on, so the first half of every frame stayed on screen with the next `Compiling` line written over it. sysforge now cuts each frame to the window's current width as it passes it on. Builds outside the sandbox were not affected, since cargo measures the terminal there itself. --- @@ -841,15 +823,15 @@ https://keepachangelog.com/en/1.1.0/ --- -- **`3.5.0-B124` — Tab completion is several times faster.** Every Tab press started a full `sysforge` that loaded every command before printing a single name, and completing a package name also ran `pacman -Ssq` and piped about 140,000 names through `grep`, about half a second per press. Completion lookups now skip the rest of the CLI, the merged repo and AUR name list is cached and rebuilt only after a sync database, the AUR name list or your PKGBUILD directory changes, and sysforge filters the list to what you have typed before printing it. A package-name lookup now takes about 0.1 s and the others well under that. Completing a package from the build state also no longer tries to create the state directory, which could ask for your password. For contributors, `make bench-completions` prints the time of each lookup. +- **`3.5.0-B124` — tab completion is several times faster.** Every Tab press started a full `sysforge` that loaded every command before printing a single name, and completing a package name also ran `pacman -Ssq` and piped about 140,000 names through `grep`, about half a second per press. Completion lookups now skip the rest of the CLI, the merged repo and AUR name list is cached and rebuilt only after a sync database, the AUR name list or your PKGBUILD directory changes, and sysforge filters the list to what you have typed before printing it. A package-name lookup now takes about 0.1 s and the others well under that. Completing a package from the build state also no longer tries to create the state directory, which could ask for your password. For contributors, `make bench-completions` prints the time of each lookup. --- -- **`3.5.0-B125` — A package built with the other compiler was recorded as built by the active one.** Every source build recorded the toolchain stage's compiler, so a package kept on gcc on an LLVM system (through a `[package_compiler_overrides]` row, a profile, the recovery menu or the new `build --toolchain`) was recorded as `pgo_llvm`. The record now names the compiler that built it. `update` does not report it as toolchain drift while your config still picks that compiler for it, so it is not rebuilt with clang. A one-off `build --toolchain` build is still reported, since the next normal build undoes it. The [drift guide](../guides/drift.md) has a new section on building one package with the other toolchain. +- **`3.5.0-B125` — a package built with the other compiler is recorded as such.** Every source build recorded the toolchain stage's compiler, so a package kept on gcc on an LLVM system (through a `[package_compiler_overrides]` row, a profile, the recovery menu or the new `build --toolchain`) was recorded as `pgo_llvm`. The record now names the compiler that built it. `update` does not report it as toolchain drift while your config still picks that compiler for it, so it is not rebuilt with clang. A one-off `build --toolchain` build is still reported, since the next normal build undoes it. The [drift guide](../guides/drift.md) has a new section on building one package with the other toolchain. --- -- **`3.5.0-B126` — A kernel built with the other compiler is recorded as such, and stops warning about it.** `run kernel` recorded the system toolchain's variant whatever compiler built the kernel, so a kernel kept on gcc (`compiler = "gcc"` in `kernel.toml`, or `--toolchain gcc`) on an LLVM system was recorded as `pgo_llvm`. The record now names the compiler that built it, as `3.5.0-B125` does for other packages. The kernel stage's "Rebuilding will switch toolchains" warning now compares the record with the compiler this run will use rather than the system one, so it appears only when the kernel's compiler actually changes, and it names that compiler. +- **`3.5.0-B126` — a kernel built with the other compiler is recorded as such, and stops warning about it.** `run kernel` recorded the system toolchain's variant whatever compiler built the kernel, so a kernel kept on gcc (`compiler = "gcc"` in `kernel.toml`, or `--toolchain gcc`) on an LLVM system was recorded as `pgo_llvm`. The record now names the compiler that built it, as `3.5.0-B125` does for other packages. The kernel stage's "Rebuilding will switch toolchains" warning now compares the record with the compiler this run will use rather than the system one, so it appears only when the kernel's compiler actually changes, and it names that compiler. --- From f2fc706ff7cc8c130ad5e5df6f13e5357bf8ea3b Mon Sep 17 00:00:00 2001 From: Keith Raghubar Date: Wed, 28 Oct 2026 10:22:27 -0400 Subject: [PATCH 2/6] release: v4.0.0 --- DESIGN.md | 2 +- PKGBUILD | 2 +- PKGBUILD-git | 2 +- README.md | 2 +- docs/design/00-header.md | 2 +- docs/release-notes/unreleased.md | 977 +------------------------------ docs/release-notes/v4.0.0.md | 958 ++++++++++++++++++++++++++++++ man/sysforge.1 | 2 +- pyproject.toml | 2 +- uv.lock | 2 +- 10 files changed, 987 insertions(+), 964 deletions(-) create mode 100644 docs/release-notes/v4.0.0.md diff --git a/DESIGN.md b/DESIGN.md index d8aa9369..912b7720 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -7,7 +7,7 @@ SysForge is an Arch Linux build and maintenance suite with compiler optimization as a first-class concern. It manages AUR and custom package builds using rule-based compiler flag profiles, tracks build state for update detection, and automates the full build lifecycle — from fetching PKGBUILDs to installing profiled packages. Pacman owns the package database; SysForge owns the build configuration layer above it. -SysForge manages the profiled AUR-helper surface (install, update, and manage AUR and custom packages with system-tuned profiled builds) and a full bootstrap pipeline (stages 1–3: install via archinstall, hardware detection, configure) that automates a fresh Arch install from the ISO. Current release is **v3.5.0**; per-release changes are recorded in `docs/release-notes/`. +SysForge manages the profiled AUR-helper surface (install, update, and manage AUR and custom packages with system-tuned profiled builds) and a full bootstrap pipeline (stages 1–3: install via archinstall, hardware detection, configure) that automates a fresh Arch install from the ISO. Current release is **v4.0.0**; per-release changes are recorded in `docs/release-notes/`. --- diff --git a/PKGBUILD b/PKGBUILD index 6357ec06..30788c17 100644 --- a/PKGBUILD +++ b/PKGBUILD @@ -1,7 +1,7 @@ # Maintainer: Keith Raghubar pkgname=sysforge -pkgver=3.5.0 +pkgver=4.0.0 pkgrel=1 pkgdesc="AUR helper that builds and tracks packages tuned to your CPU with PGO, BOLT and LTO" arch=('any') diff --git a/PKGBUILD-git b/PKGBUILD-git index 21400a31..0fc6bb11 100644 --- a/PKGBUILD-git +++ b/PKGBUILD-git @@ -1,7 +1,7 @@ # Maintainer: Keith Raghubar pkgname=sysforge-git -pkgver=3.5.0.r0.g0000000 # updated dynamically by pkgver() +pkgver=4.0.0.r0.g0000000 # updated dynamically by pkgver() pkgrel=1 pkgdesc="AUR helper that builds and tracks packages tuned to your CPU with PGO, BOLT and LTO (git)" arch=('any') diff --git a/README.md b/README.md index 625a9e89..266633cf 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ SysForge is an AUR helper that builds and tracks packages tuned to your CPU. Eve ![On a fresh install, sysforge build cbonsai -si reviews the AUR package's PKGBUILD, builds it with -march=native and installs it; sysforge update then finds nothing to rebuild](docs/assets/quickstart.gif) -v3.5.0 +v4.0.0 --- diff --git a/docs/design/00-header.md b/docs/design/00-header.md index 29f439aa..aa8be2ea 100644 --- a/docs/design/00-header.md +++ b/docs/design/00-header.md @@ -2,7 +2,7 @@ SysForge is an Arch Linux build and maintenance suite with compiler optimization as a first-class concern. It manages AUR and custom package builds using rule-based compiler flag profiles, tracks build state for update detection, and automates the full build lifecycle — from fetching PKGBUILDs to installing profiled packages. Pacman owns the package database; SysForge owns the build configuration layer above it. -SysForge manages the profiled AUR-helper surface (install, update, and manage AUR and custom packages with system-tuned profiled builds) and a full bootstrap pipeline (stages 1–3: install via archinstall, hardware detection, configure) that automates a fresh Arch install from the ISO. Current release is **v3.5.0**; per-release changes are recorded in `docs/release-notes/`. +SysForge manages the profiled AUR-helper surface (install, update, and manage AUR and custom packages with system-tuned profiled builds) and a full bootstrap pipeline (stages 1–3: install via archinstall, hardware detection, configure) that automates a fresh Arch install from the ISO. Current release is **v4.0.0**; per-release changes are recorded in `docs/release-notes/`. --- diff --git a/docs/release-notes/unreleased.md b/docs/release-notes/unreleased.md index 9ed989d4..fbfd386b 100644 --- a/docs/release-notes/unreleased.md +++ b/docs/release-notes/unreleased.md @@ -1,958 +1,23 @@ # sysforge (unreleased) -`update` stops building code nobody looked at, and the command line settles: at a terminal it now shows its plan and asks before it changes anything, a changed AUR or git source it cannot show you is refused instead of built unattended, and every flag has one spelling across every command (the old spellings no longer parse; the table is under Removed). The LLVM toolchain is rebuilt around the repos' single `llvm` package, with clang's own code PGO-optimized for the first time, a BOLT step that can actually run, and `run toolchain --bolt-only` and `--install-only` to finish a run without another hour-long build. Also: `--unattended` and `build --failed` for timer-driven runs, `config check`, `clean` and `reset` for retired and misspelt settings, `self-uninstall`, `--json` from `state list`, `doctor` and `update --dry-run`, `setup` presets, opt-in DKMS-safe kernel hardening, flag drift that covers build inputs outside the profile, timestamped run logs, much faster tab completion, a short README backed by new guides, concept pages and a glossary, and a sweep of fixes to the shared state directory's security, first-session permissions and the progress bar. - ---- - -## Added - -- **`3.1.0-F3` — a way to keep sysforge away from the AUR.** Set `enabled = false` in `sysforge.toml`'s `[aur]` section and sysforge never contacts the AUR: no clones, no lookups, no search results and no package-list download. A package you track from the AUR is reported as `AUR disabled` and left alone rather than failed, `build` refuses one up front, and a dependency that only the AUR has is named as such. Repo and local packages work as before, and a checkout whose `origin` is somewhere other than the AUR still syncs. Separately, `update` no longer downloads the AUR package list on every run: it does so only when you track something from the AUR, since only shell completion reads it. - ---- - -- **`3.2.0-F18` — build inputs that never pass through a profile now count as flag drift.** Flag drift compared only your profile's flags, so several settings that change what a build produces went unnoticed, and changing them left stale packages installed with no warning. sysforge now records these inputs with every build and reports a change as flag drift, with its own diff line, promoted by `--rebuild-on-flag-drift` like any other: `python`, the Python minor version for a package that depends on Python at runtime, so a `[build] python` change or a distro Python upgrade from 3.13 to 3.14 shows up (a patch release does not); `mesa_gallium` and `mesa_vulkan`, mesa's driver lists when `[mesa] filter_drivers` is on, which change with `[mesa]` settings or a GPU swap; `llvm_targets`, LLVM's target list, which changes with `toolchain.toml [llvm] targets` or a GPU swap and is reported with a `sysforge run toolchain` hint because the toolchain stage owns LLVM; and `pgo_profile`, the PGO profile an `update` rebuild would reuse from the package's store, so a profile that appeared or was deleted since the build is reported. A package built with `--pgo=use` is now checked for these inputs too, though still not for its profile flags. Packages built before this release show no build-input drift until their next rebuild, so upgrading does not flag everything at once. The drift guide lists the new lines. - ---- - -- **`3.4.0-F3` — an opt-in, DKMS-safe compile-time kernel hardening set.** Set `hardening = true` in `kernel.toml` and the kernel stage adds a curated set of hardening options, from the kernel's own self-protection recommendations, to the config fragment it merges into your kernel's config. The set covers read-only, non-executable kernel and module memory, address and stack randomisation, the stack protector and `FORTIFY_SOURCE`, hardened copies to and from user space, allocator hardening, zeroed stack and heap memory, checks that stop on a corrupted kernel list, and a smaller `/dev/mem` and system-call surface. Arch's config already turns most of these on; listing them keeps a different base config, or a step such as `localmodconfig`, from dropping them. Three are new: `BUG_ON_DATA_CORRUPTION`, and two that cost some speed, `INIT_ON_FREE_DEFAULT_ON` and `ZERO_CALL_USED_REGS`, which is why the set is off by default. The set has the lowest priority in the fragment, so any device, hardware or `[[kconfig]]` entry for the same option wins, with a warning, and that is how you turn a single option back off. It never makes the kernel require signed modules: module signature enforcement or a forced lockdown mode would stop unsigned DKMS modules such as `nvidia-open-dkms` from loading. The kernel stage now also refuses before the build, naming the modules, if your own `[[kconfig]]` entries enforce either while DKMS modules are registered. `hardening` with `kconfig_merge = false` is refused rather than building an unhardened kernel, and `--dry-run` shows `hardening: on` in the build plan. Runtime hardening, such as `sysctl.d` settings and kernel command-line options, is system policy and stays outside sysforge. The kernel guide has a new Hardening section. - ---- - -- **`3.4.0-F4` — `update` no longer re-adopts a package you reverted or forgot.** `revert-to-stock` and `state forget` removed a package's build record, but `update` decides what to maintain afresh on every run, so the next run could pick the package straight back up: through a `packages.toml` entry for it, through `repo_mode = "build_from_source"` (which takes in every installed repo package, including one you just returned to stock), or, for an AUR package you forgot, simply because it is installed from the AUR. Both commands now also record the decision in a new file in the state directory, `opted-out.toml`, and `update` leaves those packages alone, telling you at `-v` which setting would have taken each one back so you can remove it. A split package opts out as a whole. Only an explicit request takes a package back: `sysforge build `, `sysforge update ` (not with `--dry-run`) or `sysforge packages add `. `sysforge state list` has a new *Opted out* section listing them, and an opted-out AUR package is no longer listed as untracked. `uninstall` records nothing, since reinstalling a package later is a new decision. - ---- - -- **`3.4.0-F7` — `state list`, `doctor` and `update --dry-run` can answer in JSON.** A status bar, a notification hook or a timer wrapper that wanted to know what is drifted, what failed or what would rebuild had to parse output meant for people, which is reworded freely between releases. Each of these now takes `--json`: `sysforge state list --json`, `sysforge doctor --json` (also on `doctor system` and `doctor pkg`) and `sysforge update --dry-run --json`. Stdout then carries one JSON document and nothing else, even with `-v` or `-vv`; everything else sysforge would print goes to stderr. Every document has a top-level `"schema"` number, now 1, and a `"kind"`. A new field may appear in a minor release; a renamed or removed field bumps `"schema"`. `state list` lists the recorded, opted-out and untracked foreign packages; `doctor` lists each axis's findings and the checks it ran and skipped, with the reason; `update --dry-run` lists each package's verdict, both kinds of drift with whether this run would rebuild them, and any source-sync failures. Exit codes are the same as without `--json`. Because a real update or `doctor pkg --apply` changes the system, `update --json` without `--dry-run` and `doctor pkg --apply --json` are refused. The zsh and bash completions and the man page include the new flag. - ---- - -- **`3.4.0-F8` — version changes are coloured by how big the jump is.** Every `old → new` row looked the same whether it was an epoch change, a major release or a rebuild, so in a long `update --devel` summary the few rows worth a second look were lost among dozens of `r1234 → r1240` VCS ticks. On a colour terminal each pair is now tinted by the first part of the version that changed: red for an epoch change or a downgrade, yellow for a major version, cyan for a minor one, and dim for a pkgrel-only rebuild or a VCS tick (only the trailing `rN` / commit hash moved). Patch-level changes, and versions whose shape can't be read reliably (such as a `YYYYMMDD` date), stay uncoloured. This applies to the `update` summary (built packages, the system upgrade, and stage-owned updates), the change summary after each pipeline stage, the toolchain stage's list of version changes before it builds, and the LLVM and toolchain pre-flights. With colour off (`--color=never`, `NO_COLOR`, or output piped elsewhere) the output is unchanged, and colour never reaches the log files. - ---- - -- **`3.4.0-F9` — `bench toolchain` shows what it is doing while it runs.** At default verbosity the verb printed nothing between launch and its report: the download of the stock `clang` and `llvm-libs` (about 105 MB when they aren't cached), the extraction, and every timed compile round (about 40 seconds before any download) looked like a hang. The progress line now names each step: `fetching stock clang `, then the same for `llvm-libs`, `unpacking stock clang`, the warm-up, and `round 3/5` for each timed round. The report replaces it when the bench finishes, and so does the error message if a step fails. Piped or non-interactive output shows the same steps as `[PROGRESS]` lines. The `-vv` narration is unchanged, and so is the output with `--quiet`. - ---- - -- **`3.5.0-B143` — `sysforge uninstall --yes`, for scripts and timers.** `uninstall` passed its confirmation to pacman and had no `--yes`, so without a terminal pacman printed the whole transaction, read nothing at its `[Y/n]` and gave up, and sysforge reported the raw command that failed. `--yes` now removes without asking, and without it and without a terminal `uninstall` refuses before doing anything and says to pass `--yes`, as `revert-to-stock` does. At a terminal nothing changes: pacman still asks. - ---- - -- **`3.5.0-F1` — `bench toolchain` gets past an out-of-date sync database.** The bench downloads the stock `clang` and `llvm-libs` that your sync database names. When the repo rebuilt them after your last `pacman -Sy`, every mirror had already dropped those files, so each download failed with HTTP 404 and the bench stopped. It now notices that every mirror failed, downloads a fresh copy of the sync database into its own temporary directory, and compares against the build the repo carries now. It does this as your user with `fakeroot` (from `base-devel`), never with sudo, and your system's sync database is left alone, because syncing it without upgrading would leave the system partially upgraded. The report shows the stock version it used, so a newer stock build is flagged as a version difference, as before. If the refresh fails too, the error says so and suggests `pacman -Syu`. `--offline` never refreshes. The PGO guide describes the fallback. - ---- - -- **`3.5.0-F4` — mesa built against the stock LLVM loads with sysforge's optimized LLVM.** The optimized libLLVM that `run toolchain` builds stopped providing some C++ string functions that the stock libLLVM happens to provide, so a mesa linked against the stock one (as the build sandbox does, for mesa's Rust parts) imported them from libLLVM and could not load against sysforge's. sysforge refused to install such a mesa, and rebuilding it did not help, because the sandbox links it against the stock libLLVM again. The toolchain build now gives libLLVM those functions back, as small forwarders to the C++ library's own copies, in a form that only already-built programs use: nothing newly built against the optimized libLLVM starts depending on them, so the toolchain's own programs keep using the C++ library directly. At `-v`, the toolchain build also lists any C++ library functions the stock libLLVM provides that the new one still lacks, when the stock `llvm-libs` of the same version is in the pacman cache. This applies to x86-64 builds linked with lld, which every optimized toolchain build is. A build reused with `--reuse-built` from before this release is rebuilt once. - ---- - -- **`3.5.0-F5` — every line of the run log says when it was written.** Only the section headers in a log file (`# sysforge build llvm: 2026-10-18 08:39:04`) carried a time, so a finished `sysforge-run-toolchain.log` could not tell you how long a step such as the pre-install audit, the install or the consumer rebuild took. Every line in the run log and the per-package logs now starts with the time, for example `09:41:07 [SYSFORGE][INFO][TOOLCHAIN] …`. The rest of the line is unchanged, so searching for a tag still works. When a run passes midnight, a `# date:` line marks the new day. The terminal output is unchanged. - ---- - -- **`3.5.0-F6` — the toolchain progress line says where the stage is.** Since the repos build clang, lld and the rest as part of the one `llvm` package, every step of `run toolchain` showed `[1/1] … llvm` for up to an hour, never an estimate of the time left, and only `toolchain` between the builds. The line now counts the stage's own steps and says which one is running, for example `toolchain 5/8 · optimize · llvm · ninja 74% · 1h34m · ~40m left`. The steps are preflight; instrument, bootstrap, train and optimize for a full PGO run (only optimize when the stored profile is reused, one build step without PGO); then the pre-install audit, install and verification, plus the rebuild of libLLVM's consumers and the bench when those run. The time is how long the stage has run, and the estimate is how long each remaining step took on your recent runs, kept in a new `stage_timings.toml` in the state directory (safe to delete), so it appears from the second run on. A build's progress now reads as a percentage instead of the file being compiled, which the terminal width usually cut off, and a second build inside the same package (llvm builds its runtimes partway through) is shown beside it by name instead of looking like the main build nearly done. This applies to `build` and `update` too. The audit and verification steps name the check that is running, and the section headers in the output name what each step builds now. - ---- - -- **`3.5.0-F7` — `run toolchain --bolt-only` reruns BOLT without rebuilding LLVM.** BOLT only needs the LLVM build that `run toolchain` leaves in your build directory, so `sysforge run toolchain --bolt-only` now rewrites that build, repackages llvm and installs it through the usual checks (the pre-install audit, the install snapshot and the post-install verification) in minutes instead of the hour a full build takes. It works even with `[bolt] enabled` off, using your other `[bolt]` settings, and never syncs sources. It refuses, saying why, when that build isn't the finished optimized build of the version you have checked out: for example after an interrupted run, a version change, or a non-PGO build. sysforge now keeps the original libraries next to the build, so every BOLT run, including a repeat `--bolt-only`, starts from them rather than rewriting BOLT's own output. If BOLT can't run, `--bolt-only` stops before installing anything. Before installing it asks whether to go ahead with BOLT and the install (not with a build), and it doesn't require the 40 GiB of free space a full build needs. - ---- - -- **`3.5.0-F8` — `run toolchain --install-only` installs the last build without rebuilding it.** When a run built the toolchain but didn't install it (the install failed, or its sudo prompt timed out), the only way forward was another multi-hour build. `sysforge run toolchain --install-only` installs the packages that run left, BOLTed ones included, with the same checks, snapshot and verification as a full run. It refuses if the last build isn't the optimized build of the version you have checked out, or a package is missing. A failed install now suggests it. - ---- - -- **`3.5.0-F9` — config presets in `sysforge setup`.** `setup` now offers a preset before its preference questions, for when you have one goal and don't want to read every setting: `performance` (the LLVM toolchain and the `optimized` profile), `low-friction` (no plan confirmation, no source review, automatic PGP key fetching and toolchain build reuse) or `secure` (a new `hardened` flag profile, review and plan confirmation on, clean-chroot builds once a chroot exists, and kernel `hardening`). It shows each change before writing, and the values it writes are ordinary settings you can edit later. It never turns on the toolchain or kernel stages. `low-friction` warns that with review off, changed AUR and git code is installed with nobody having looked at it and is not listed in the update summary. `--preset NAME` applies one without asking, for scripted installs. The new `hardened` profile adds flags from the OpenSSF compiler hardening guide (zeroed stack variables, bounds-checked trailing arrays, libstdc++ assertions, a non-executable stack) on top of the hardening flags Arch already sets. If your own `profiles.toml` replaces the shipped one, `secure` prints the profile to paste in instead of selecting it. The zsh and bash completions and the man page include the new flag. - ---- - -- **`3.5.0-F10` — build failures caused by an undeclared dependency or clang's C++20 `module` rule are named.** Some failures were reported only as "build() failed: could be upstream or a flag/toolchain incompatibility", although the build log named the cause. Two are now recognized and explained under the failure. When a package's build needs something its PKGBUILD never asks for, which your system happens to have but the clean build sandbox does not (pkg-config's `Package 'libmnl' not found`, or makepkg's `Cannot find the git package needed to handle git sources`), sysforge names the package to add to `makedepends` and says it is a PKGBUILD mistake to report to the package's maintainer. When clang rejects a line that starts with `module` as a misplaced C++20 module declaration (`module declaration must not come from an #include directive`), which recent clang enforces and GCC does not, sysforge suggests building that package with gcc, through the build-failure menu or a `[[rules]]` profile with `toolchain = "gcc"`. Both are recorded with the failure, so `sysforge state failed` shows them. - ---- - -- **`3.5.0-F11` — flag drift leaves out packages whose build compiles nothing.** A change to your profile's flags reported flag drift for every package sysforge builds, including prebuilt packages it only unpacks and copies, such as `brave-bin` or `1password`, so `--rebuild-on-flag-drift` rebuilt them although no compiler ever saw the flags and the result could not change. sysforge now notes when it builds a package whether the build compiles anything, and a package that doesn't is no longer reported for flag changes. It only counts a package as compiling nothing when its PKGBUILD has no `build()` step, no build-system makedepends (such as `cmake`, `meson` or `cargo`) and no compile command such as `make` or `gcc`; anything less clear is treated as compiling, as before. The sandbox and build-input lines and toolchain drift still apply to such a package. A package built before this release is still judged on its flags until its next rebuild. The drift guide lists the new case. - ---- - -- **`3.5.0-F12` — a per-package compiler swap switches the whole toolchain.** When a build failed and you picked gcc (or clang) from the build-failure menu, sysforge retried and remembered the choice in `profiles.toml`'s `[package_compiler_overrides]`, but only the C and C++ compiler and the linker changed: a gcc swap on an LLVM profile kept `llvm-ar`, `llvm-nm`, `llvm-ranlib`, `llvm-strip` and lld. A row can now say `toolchain = "gcc"` or `"llvm"`, which switches the whole set the way a `[[rules]]` profile's `toolchain` does, and the menu writes that form and retries with the whole set. At its linker question, leaving the answer blank now means the chosen toolchain's own linker. Rows that name `cc`, `cxx` and `ld` directly keep working and remain the way to name a compiler outside the two sets. When `sysforge build --cc`, `--cxx` or `--ld` overrides a row for a package, `-vv` says so. The comment above the table in `profiles.toml` lists which setting wins; `sysforge config merge` picks it up. - ---- - -- **`3.5.0-F13` — `sysforge log --verb` pages the log a verb left.** `log` could page only the unified log and per-package logs, although `build`, `update`, `doctor`, `fetch`, `setup`, `uninstall`, `revert-to-stock`, `config merge`, `state repair`, `state forget` and each `run ` leave their own `sysforge-.log`, which the end of the run named once. `sysforge log --verb update` (or `build`, `state-repair`, `run-toolchain` and so on; Tab lists them) pages it, and `--log-dir` finds a log written with the same `--log-dir`, for verb, unified and per-package logs alike. - ---- - -- **`3.5.0-F14` — choose a package's toolchain when you build it, and keep it.** `sysforge build PKG --toolchain gcc` (or `llvm`) builds the packages you name with that toolchain as a whole: compilers, `ar`/`nm`/`ranlib`/`strip` and linker together, the same swap the build-failure menu makes. Before, the only CLI choice was `--cc`/`--cxx`, which changed just the two compilers and left an LLVM profile's `llvm-ar` and `lld` in place. A `--cc gcc --cxx g++` or `--cc clang --cxx clang++` pair now does the same as `--toolchain`; any other pair still sets only the compilers, for a compiler sysforge does not bundle. Add `--save-toolchain` to keep the choice for those packages in `profiles.toml`, so later builds and `update` use it, without waiting for a build to fail first; `--reset-toolchain` removes it again. Dependencies built along the way keep their own profile. `run kernel` takes the same option under the same name (it was `--compiler`; see `3.5.0-F15`). - ---- - -- **`3.5.0-F18` — find and fix retired or misspelt settings in your config files.** An upgrade never rewrites your config files, so a setting sysforge stopped reading stayed there, silently ignored, and a misspelt key was never reported. `sysforge config check` lists both, with the line (`--json` prints them as one JSON document for scripts): settings sysforge renamed or retired (such as `[git] pull_timeout`, the per-package `pkgbuild_patch`, `repo_mode = "profiled"` and `build_mode = "patched_pkgbuild"`) and keys it does not know. `sysforge config clean` gives retired settings their current name or value, keeping your comments, and with `--unknown` removes the unknown ones. `sysforge config reset FILE [KEY ...]` puts keys back to the shipped default, or the whole file, keeping the old one as `FILE.bak-