plasma-framework's ecm_find_qmlmodule REQUIRED checks need two QML modules that
were not being built:
- org.kde.config: kf6-kconfig had -DKCONFIG_USE_QML=OFF -> enable it (qtdeclarative
is already a dep).
- Qt5Compat.GraphicalEffects: qt5compat only builds its QML imports when QtQuick
is present in the sysroot; add qtdeclarative to qt5compat deps so it cooks after
QtQuick exists, then stages the GraphicalEffects qml module.
Also declare qt5compat as a plasma-framework dep. (X11/XCB/OpenGL are optional on
the Wayland build and not the blocker.)
plasma-framework (task #13, the Plasma grind) needs KF6Svg + PlasmaActivities +
Wayland; declare kf6-ksvg, kf6-plasma-activities, plasma-wayland-protocols,
qtwayland, kf6-kdbusaddons. kf6-plasma-activities' QML imports in turn require
Qt6Sql (activities database), which qtbase built with FEATURE_sql=OFF. Enable
FEATURE_sql + FEATURE_sqlite (bundled, FEATURE_system_sqlite=OFF) in the TARGET
qtbase config — Sql is broadly needed across the KDE desktop, not just activities.
This retriggers the qtbase->Qt->KDE relink cascade.
Downstream KCM consumers (kde-cli-tools, plasma-*) run the imported
KF6::kcmdesktopfilegenerator at build time via kcmutils_generate_desktop_file();
the cmake build staged a Redox binary that cannot execute on the build host.
The tool is a single Qt6::Core-only source (tools/kcmmetadatagenerator.cpp — no
Q_OBJECT/moc, no KF6 libs), so recompile it with the host g++ + host Qt and
overwrite the staged binary. Verified: the staged file is a GNU/Linux x86-64 ELF
and kf6-kcmutils cooks successfully. It is a build-time-only generator (never run
on Redox), and usr/lib/libexec/kf6/ is outside the recipe strip/patchelf sweeps.
A relibc ABI change invalidates qtdeclarative's fingerprint and triggers an
incremental rebuild that keeps the 1-line empty qqmljsgrammar_p.h stub (it
survives the recipe's CMakeCache/CMakeFiles removal), so ninja skips qlalr
regeneration and every consumer of qqmljslexer_p.h fails with 'expected
class-name' / 'QQmlJS::Parser incomplete type'. Delete the stale qlalr outputs
(qqmljsgrammar_p.h + qqmljsgrammar.cpp) before configure so qt_process_qlalr
regenerates them. Pattern (j): stale codegen after a toolchain rebuild — now
durable instead of needing a manual clean rebuild each time.
Validated: qtdeclarative built (libQt6Qml/libQt6Quick) in the full cascade build.
Real data from a running build: 6 recipes cooking concurrently but only ONE
actual compiler process, load 2.2/16. Recipes almost never hit their compile
phase simultaneously — most cook-time is single-threaded configure/link/IO — so
the strict per_make = jobs/concurrency division starved the one recipe that was
compiling (mesa pinned to -j2 while 14 cores idled).
Give each concurrent cook the full -j; the active compiler now uses the
whole machine and the OS scheduler absorbs the rare overlap. Worst-case
parallelism is bounded by cook_jobs * jobs, so build-redbear.sh now defaults
COOKBOOK_COOK_JOBS to 4 (was JOBS/2) to cap simultaneous heavy C++ compiles for
RAM safety. A shared make jobserver would cap total jobs precisely while keeping
full per-recipe -j — noted as the proper long-term fix.
JOBS/4 left cores idle (observed load ~4.5/16 during a build). The make-job
budget division keeps total compile parallelism ~JOBS regardless of COOK_JOBS, so
RAM stays bounded; JOBS/2 keeps per-recipe make jobs >= 2 (fully using the -j
budget on busy levels) while adding enough recipe-concurrency to saturate the
cores. Higher (e.g. JOBS) would floor per-recipe jobs to 1 and waste budget.
Export COOKBOOK_COOK_JOBS (default JOBS/4, min 1) so the full build cooks
independent same-level recipes concurrently. Override with COOKBOOK_COOK_JOBS=1
for serial. See the cook orchestrator's run_parallel_cook.
The cook orchestrator built recipes strictly serially — COOKBOOK_MAKE_JOBS only
parallelized within a single recipe's make, so cores sat idle during every
recipe's configure/link/small-file phases. src/cook/scheduler.rs (dep_levels)
was written for this but never wired in (the module wasn't even declared, so it
never compiled).
- Declare the scheduler module (src/cook.rs) so dep_levels + its 7 tests build.
- New COOKBOOK_COOK_JOBS setting (config.rs, default 1 = serial): how many
recipes to cook concurrently.
- run_parallel_cook (repo.rs): partition recipes into topological dep-levels
(same level = no inter-deps = safe concurrent), process levels in order behind
a barrier, and within a level pull recipes from an atomic work-index across
scoped worker threads. The make-job budget is divided per level so
a lone heavyweight recipe (e.g. qtbase, alone at its level) still gets the full
-j, while crowded levels share it — no oversubscription, no slowdown for
serial-level recipes. Publishing stays a single batched step. Failure/nonstop
semantics preserved; only engaged for with cook_jobs>1 and >1 recipe.
- Safe because each recipe builds in its own target/stage/sysroot and a recipe's
sysroot is assembled from its dependencies' (lower-level, already-complete)
stage pkgars — read-only for concurrent siblings.
- package.rs: serialize packaging behind a global PACKAGE_LOCK. package() shares
process-global state (the lazily-created pkgar signing key at
build/id_ed25519.toml, name/metadata construction) that raced under concurrent
cooks (corrupt key, mangled names like 'x.dev.dev'); packaging is cheap, so
serializing it keeps the compile-parallelism win. Also make the package-name
construction fail gracefully (Err, not unwrap-panic) so a bad name fails one
recipe instead of crashing the whole scoped-thread build.
Validated: all-cached tree (COOK_JOBS=4) and a real concurrent build of 3
independent recipes (COOK_JOBS=3) both succeed and publish correctly.
kf6-kcmutils: (1) add the missing 'source local/scripts/lib/qt-sysroot.sh' before
redbear_qt_link_sysroot_dirs (undefined-function crash); (2) drop Qt6::Test from
the REQUIRED components (qtbase FEATURE_testlib=OFF, tests off); (3) declare the
kirigami dependency so its org.kde.kirigami QML module is in the sysroot (an
ecm_find_qmlmodule REQUIRED check).
kde-cli-tools: declare kf6-kcmutils + kf6-parts deps (find_package(KF6 REQUIRED
COMPONENTS KCMUtils Parts)); add -DBUILD_DOC=OFF (the doc subdir hard-requires
KF6DocTools + the docbook/xsltproc toolchain, not needed for a working desktop).
kf6-kio re-cooked (fingerprint invalidated by the cookbook_configure change) and
surfaced three issues; fix them as build-time seds so restore-sources.sh cannot
revert them (a cached source snapshot kept reverting in-tree source edits):
- previewjob.cpp: a prior port replaced the pristine '#include <KConfigGroup>'
with an unterminated '#if defined(Q_OS_UNIX) && ... && !defined(Q_OS_REDOX)'
(also dropping the include) -> 'unterminated #if'. Restore the include.
- hostinfo.cpp: drop <arpa/nameser.h> + <resolv.h> (BIND resolver headers absent
on relibc); the only symbol used, _PATH_RESCONF, has a /etc/resolv.conf fallback.
- CMakeLists.txt: drop Qt6::Test from the REQUIRED components (autotests-only,
gated on BUILD_TESTING, and Qt6Test is not built for the cross target).
Vendor libsecret 0.21.7 (org.freedesktop.secrets client lib, required by
kwalletd6's secretserviceclient.cpp) under the full-fork model; build it shared
against the static libgcrypt closure (custom template + unset COOKBOOK_DYNAMIC so
pkg-config --static pulls libgpg-error). Add it to kf6-kwallet deps.
Fixes to reach a full kwallet build:
- qca recipe: rewrite the exported Qca-qt6Targets.cmake to compute _IMPORT_PREFIX
relative to the config-file location (QCA hardcoded an absolute /usr prefix +
include dir, so cross consumers failed with 'imported target includes
non-existent path /usr/include/Qca-qt6/QtCrypto').
- ksecretd/CMakeLists.txt: gate add_subdirectory(autotests) on BUILD_TESTING
(upstream does not); the autotests need Qt6Test, unavailable for the cross
target and never shipped.
- kwalletbackend blowfish.h + sha1.cc: include <stdint.h> on __redox__ (the cross
check_include_files(stdint.h) misfired, leaving HAVE_STDINT_H unset -> uint32_t
undeclared).
- cmake/FindLibGcrypt.cmake: append libgpg-error after libgcrypt (static-only on
Redox, its gpg-error dep not pulled transitively -> undefined gpgrt_lock_*/
gpg_strerror at link).
Gpgmepp stays optional (find_package without REQUIRED, all uses HAVE_GPGMEPP-
gated); GPG-key wallets are a secondary feature. kwalletd6 + ksecretd both build.
Un-defer xwayland in config/redbear-full.toml (it is a kwin build dependency).
Getting it to build required:
- cook_build script.rs: cookbook_configure now defeats autotools maintainer-mode
regeneration. Release tarballs ship a complete build system, but extraction
timestamp skew makes make re-run the version-pinned aclocal-<N>/automake-<N>
the tarball was generated with, which the host (a different automake) lacks
('aclocal-1.NN: command not found'). Force generated files newer than their
sources (staggered mtimes) and no-op ACLOCAL/AUTOMAKE/AUTOCONF/AUTOHEADER as a
safety net. This unblocked the whole X11 autotools stack (libxcb, libx11,
libxfont2, libxkbfile, ...) with no per-recipe edits.
- xwayland recipe: meson -> custom template so it can (1) overlay the host
wayland-scanner onto the sysroot path meson resolves (the sysroot scanner is a
Redox binary, unrunnable on the build host; it is a build-time-only generator
emitting arch-independent C), and (2) unset COOKBOOK_DYNAMIC so the cross
pkg-config resolves --static, pulling the X11 libs' Requires.private closure
(xcb -> xau) — those libs are static-only on Redox (libtool has no Redox
shared support), so the closure was otherwise dropped and the link failed on
XauGetBestAuthByAddr/XauDisposeAuth.
- os/access.c: include <sys/utsname.h> on __redox__ (Redox lacks SIOCGIFCONF so
the uname()-based DefineSelf is compiled; relibc provides uname/struct utsname).
Produces a proper Redox /usr/bin/Xwayland ELF.
kf6-kwallet's ksecretd daemon (the org.freedesktop.secrets Secret Service
provider) requires Qca-qt6 2.3.1. Vendor QCA 2.3.10 under the full-fork model
and build the gcrypt provider plugin (backed by the vendored libgcrypt) so QCA
has a working SymmetricCipher/Hash/PBKDF2 backend on Redox. External-toolkit
providers (ossl/nss/botan/gnupg/pkcs11/cyrus-sasl) are disabled — those
libraries are not part of the Redox userland; logger + softstore (pure-Qt) are
kept.
Source edit: the top-level Qt6 find_package required the Test component
unconditionally; gate it on BUILD_TESTS so a tools/tests-off build configures
without Qt6Test. Install via DESTDIR since QCA anchors its install dirs to the
absolute Qt prefix (/usr), which ignores cmake --install --prefix.
Build libgpg-error + libgcrypt with --with-pic so their static archives can be
linked into the qca-gcrypt shared plugin. Add qca to kf6-kwallet deps.
kf6-kwallet's kwalletbackend hard-requires LibGcrypt 1.5.0 for PBKDF2 key
derivation and the GPG-backed wallet format. Vendor both libraries under the
full-fork model (committed source/, offline-reproducible) and add libgcrypt to
kf6-kwallet's dependencies.
Release tarballs ship a pre-generated configure and a config.sub that already
recognises the *-redox triple, so no autotools regeneration is needed at cook
time. libgpg-error supplies a generic pthread-backed gpgrt_lock_t for Redox via
its build script; the test-only redox.patch (tms/times stub) is baked into
libgcrypt's source and kept alongside for future version bumps.
Promoted from the stale recipes/wip copies (now .disabled).
kf6-kdeclarative's CMakeLists does find_package(KF6GlobalAccel REQUIRED) on
non-Windows/Apple/Android/Haiku but never declared the dependency (it was passing
by cache in earlier builds). No cycle: kf6-kglobalaccel does not depend on it.
- The upstream CMakeLists defaults BUILD_QT5=ON and calls build_Qt5() (needs Qt5,
which Redbear does not ship). Pass -DBUILD_QT5=OFF -DBUILD_QT6=ON.
- The window-decoration KCM uses kcmutils_generate_desktop_file(), a cmake macro
from kf6-kcmutils — declare that dependency.
The recipe cp'd ${COOKBOOK_SOURCE}/kded6-wrapper.sh (QT_QPA_PLATFORM=offscreen
launcher for the headless kded6 daemon) but that file was never committed, so the
install step failed. Generate it inline with a heredoc instead.
kf6-ksvg find_package(KF6 ... KirigamiPlatform) but didn't declare the kirigami
recipe (which builds libKirigamiPlatform). No cycle: kirigami depends on qtbase/
qtdeclarative/qtsvg/qtshadertools, not ksvg.
Root cause of kf6-kwayland's 'PlasmaWaylandProtocols >= 1.21.0 not found': the
plasma-wayland-protocols recipe (a custom data-only recipe) HARD-CODED
set(PACKAGE_VERSION "1.16.0") in the hand-written ConfigVersionCmake heredoc,
while the package + source are 1.21.0. Bumped it to 1.21.0.
Build-system fix (src/cook/cook_build.rs): the !check_source early-return served
the cached stage for dependency cooks WITHOUT honoring --force-rebuild — it fired
before the force_rebuild handling, so a stale binary-store artifact could never
be regenerated. Guard it with !cook_config.force_rebuild so --force-rebuild always
takes effect (repo binary rebuilt).
kf6-kwayland: declare redbear-input-headers (fakeinput.cpp needs <linux/input.h>).
- FindUTEMPTER aborts when cross-compiling unless told what to do; Redox has no
utmp/wtmp login-record DB, so pass -DCMAKE_DISABLE_FIND_PACKAGE_UTEMPTER=ON
(PTYs work without it; utempter only feeds who/w login accounting).
- kpty.cpp's __redox__ no-op guard around KPty::login()/logout() had dropped the
#endif for the UTEMPTER_PATH and HAVE_LOGIN blocks and never closed the new
__redox__ #ifdef, leaving both functions 3 #if deep at their closing brace
(unterminated #else / expected '}'). Add the 3 missing #endif to each.
Close the KDE authorization chain and enable KWindowSystem's Wayland platform:
- kf6-kauth: declare the missing kf6-kwindowsystem dependency (the PolkitQt6-1
backend uses KWaylandExtras); fix KAUTH_HELPER_BACKEND_NAME to DBus (POLKITQT6-1
is an authorization-backend value, not a helper-backend one, so it matched no
block and the helper plugin got no sources/libs/includes); link Qt6::Core into
the DBus helper backend explicitly (its includes don't propagate transitively
through the cross Qt6::DBus config).
- kf6-kwindowsystem: KWINDOWSYSTEM_WAYLAND=ON + its deps (qtwayland,
wayland-protocols, plasma-wayland-protocols, libxkbcommon) so KWaylandExtras is
built; use the HOST wayland-scanner (/usr/bin) for protocol code generation —
the sysroot one is a Redox binary that can't execute on the build host.
- redox-toolchain.cmake: set PKG_CONFIG_EXECUTABLE to the wrapper's ABSOLUTE path
as a CACHE entry, so cmake's FindPkgConfig finds it (REQUIRED pkg_check_modules
no longer fail with 'pkg-config tool not found'). Systemic — all cmake recipes.
- ECM FindWaylandProtocols: fall back to the staged share/wayland-protocols dir
when pkg_get_variable comes back empty under the cross pkg-config.
- qtbase builds with FEATURE_testlib=OFF (no Qt6Test module), but kf6-kcrash and
plasma-desktop find_package(Qt6Test REQUIRED) unconditionally though it's only
used by autotests (BUILD_TESTING=OFF). Drop REQUIRED (kde-cli-tools/kwin already
used QUIET).
- kcrash.cpp uses setgroups() to drop supplementary groups in the crash-handler
child; on glibc it comes via <unistd.h>+_GNU_SOURCE, but relibc declares it in
<grp.h> (which it does provide) — add the include.
kf6-kauth deliberately uses the real polkit backend (KAUTH_BACKEND_NAME=
POLKITQT6-1), and PolkitQt6-1 links the upstream polkit CLIENT libraries, which
nothing provided (redbear-polkit is only the org.freedesktop.PolicyKit1 daemon).
This makes the KDE authorization mechanism actually work, not just compile.
- New recipe local/recipes/libs/polkit (vendored polkit 124, full-fork path=source)
built with -Dlibs-only=true so polkitd + the JS rules engine are skipped
(redbear-polkit is the authority daemon). glib/gio/expat deps already exist.
- src/meson.build: build src/polkitagent even under libs-only — libpolkit-agent-1
+ its PAM auth helper are client-side, needed by PolkitQt6-1, and depend only on
libpolkit-gobject-1 + glib + PAM (pam-redbear, the same PAM SDDM uses). Only the
daemon/backend/programs stay gated off.
- pam-redbear: add the standard PAM_MAX_MSG_SIZE/PAM_MAX_RESP_SIZE constants its
header was missing (polkit-agent-helper-1 needs them).
- polkit-qt6: depend on polkit; it now finds polkit-gobject-1 + polkit-agent-1
(v124) and builds. Auth prompts verify passwords via pam-redbear; authorization
decisions come from the redbear-polkit daemon over D-Bus.
The recipe is the Qt6 build of polkit-qt-1 but the upstream CMakeLists defaults
QT_MAJOR_VERSION to 5 unless BUILD_WITH_QT6=ON, so it was looking for Qt5 and
failing. (Next blocker: it still needs libpolkit-gobject-1, the polkit client
library, which redbear-polkit — a D-Bus daemon — does not provide.)
katehighlightingindexer is a Qt6::Core-only HOST code generator (indexes syntax
.xml -> the highlighting index embedded into the cross-compiled library). The
recipe's host build was broken three ways, all masked by 2>/dev/null:
- it used the redox cross-compiler (redoxer env sets CC/CXX) and linked the host
libQt6Core (glibc) with the redox linker -> every glibc symbol undefined. Force
host gcc/g++ and clear the redox toolchain env for the host pass.
- it never put the host Qt on CMAKE_PREFIX_PATH, so Qt6 wasn't found.
- the host Qt has no QtNetwork (the target library's definitiondownloader uses
it); build the indexer from a source COPY with Network dropped, leaving the
real source (and the target build) with Network intact.
- KATEHIGHLIGHTINGINDEXER_EXECUTABLE pointed at src/indexer/ but KDE emits the
binary to bin/. Errors are no longer suppressed so a broken host tool fails
loudly instead of silently breaking the target's index generation.
find_package(Qt6 COMPONENTS Core Qml CONFIG) marked Qml as a required component,
so any KDE package including ECMQmlModule failed its feature_summary even though
the module already returns gracefully when Qt6::Qml is absent. Use
OPTIONAL_COMPONENTS for Qml (Core stays required). qtdeclarative/QtQuick/QtQml
are not built for the Redox cross target; QML modules are simply skipped.
ecm_process_po_files_as_qm() did find_package(Qt6 COMPONENTS LinguistTools
REQUIRED) for lrelease/lconvert. Those live in qttools, which is not in the
Redox cross toolchain, so every KDE package that installs translations failed to
configure (Qt6_FOUND=FALSE). Use OPTIONAL_COMPONENTS (so a missing LinguistTools
neither aborts nor registers as a required package the final feature_summary
fails on) and return early when the tools are absent — .po -> .qm compilation is
skipped and the app builds untranslated. Systemic: unblocks all KF6 packages.
kf6-kcoreaddons (first KF6 framework to build on Redox) needed:
- LibMount made optional (was REQUIRED under CMAKE_SYSTEM_NAME==Linux, which the
Redox cross toolchain reports); KMountPoint falls back to statfs (relibc has
it). Same change in kf6-kio.
- BUILD_PYTHON_BINDINGS=OFF (pulled REQUIRED Python3/Shiboken6/PySide6 — dev-only,
not on Redox). Applied to kf6-{kcoreaddons,knotifications,kwidgetsaddons,
kguiaddons,kjobwidgets,kxmlgui}.
- kfilesystemtype.cpp: the inner OS #if chain had no #else so Redox got no
determineFileSystemTypeImpl — added Q_OS_REDOX to the Q_OS_LINUX (statfs) arm
and guarded <linux/magic.h> (the #ifndef fallbacks define every magic).
- clock-skew engine: CMakeLists compiled the _linux (timerfd) engine on Redox
but engine.cpp's create() dispatches to the DBus engine when !Q_OS_LINUX —
compile the _dbus engine on Redox instead so they agree.
relibc now provides a complete struct ifreq (+ ifr_* accessor macros and
SIOCGIF* ioctls) in <net/if.h>, so qnetworkinterface_unix.cpp's __redox__
fallback definition became a redefinition of the system type. Remove it; the
network module now uses the real relibc struct ifreq.
Move xwayland to the vendored full-fork model (committed source/ tree) so the
Redox port can be iterated in-place. The previous redox.patch was obsolete —
written against an older xwayland: 24.1.8 already carries the BTN_LEFT/MIDDLE/
RIGHT button mapping and the modern meson get_variable() API, and relibc now
provides uname()/utsname, so the os/access.c uname guard is unnecessary. Recipe
switched from tar= + redox.patch to path=source; cached source.tar removed.
Redox-specific source changes will be committed directly on this tree as the
port surfaces real compile errors (drm/glamor/glx already off via mesonflags).
relibc now defines a distinct CLOCK_MONOTONIC_RAW on Redox, so the recipe's
-DCLOCK_MONOTONIC_RAW=(CLOCK_MONOTONIC+1000) c_arg override (which conflicted
with the header and only existed because relibc lacked the constant) is no
longer needed and is removed.
Both now build for x86_64-unknown-redox against the ported relibc surface:
- wireplumber recipe: fix meson option types for 0.4.14 (doc feature; tests/
tools/daemon are booleans, not features) — configure was erroring out.
- pcre2: build the static archive with -fPIC so it links into WirePlumber's
shared PipeWire modules (via glib); matches expat/icu/libffi. Fixes the
R_X86_64_32S-in-shared-object link failure.
- config/redbear-full.toml: re-add pipewire + wireplumber to packages[] and
[files]; drop the TODO(audio) deferral.
- bump relibc submodule pointer to the ported C-runtime surface.
Compiles cleanly for x86_64-unknown-redox with no disabled modules now that
relibc provides the Linux/GNU primitives PipeWire relies on:
- node-driver.c: guard <linux/ethtool.h> for __redox__ (no PTP hw-timestamp
ioctl on Redox; the ETHTOOL_GET_TS_INFO block is already #ifdef-gated off).
- message.c, module-netjack2-{driver,manager}.c: #include <sys/time.h> for
struct timeval (not reachable transitively on Redox).
- utils.c: drop the __redox__ guard around <sys/vfs.h> (relibc now ships it,
so statfs() is declared).
- recipe: export CXXFLAGS=$CFLAGS so C++ TUs also pre-include alloca.h.
Its #ifndef _POSIX_C_SOURCE guard still tried sys/mount.h on Redox; exclude
__redox__ too. (utils.h is widely included, so this unblocked 3 consumers.)
Guard #include of sys/{mount,vfs,thr,ucred}.h and linux/{filter,if_ether,
if_packet,net_tstamp}.h behind #ifndef __redox__ (Redox lacks them; the raw-
socket/mount/statfs code paths behind them are not used on Redox). Baked into
the vendored source/ tree.
Port pipewire's Linux-isms to Redox (baked into vendored source/):
- mem.c: add __redox__ to the BSD/GNU guard that #defines MAP_LOCKED 0 (Redox
has no page-locking; the flag is a no-op).
- pipewire.c: guard #include <sys/prctl.h> and the prctl(PR_GET_NAME) thread-
name block for __redox__ (Redox has no prctl; thread naming is skipped).
alloca resolved on a clean cook (-include alloca.h + staged relibc alloca.h).
qtmultimedia: drop qtdeclarative dep (its staged QtQuick scenegraph config
header made QT_CONFIG(quick_sprite) divide by zero for consumers); keep
qtshadertools (video-frame shaders need qt_internal_add_shaders). Builds
libQt6Multimedia (API-only). konsole: drop the 439-line optional-multimedia
workaround patch and depend on qtmultimedia + qt5compat + qtbase-printsupport
directly — port the modules, don't work around them.
Per the no-workarounds policy, provide the Qt modules KDE needs instead of
patching KDE to avoid them:
- qt5compat (Core5Compat): promoted from recipes/wip, re-laid to 6.11.1
(matches the rest of Qt); no Redox source port needed. Unblocks 8 KDE pkgs.
- qtmultimedia: new recipe at 6.11.1, built API-only (all platform backends
off: ffmpeg/gstreamer/pulseaudio/alsa/pipewire/v4l2) so libQt6Multimedia
links for consumers (konsole bell); playback is a no-op until a Redox audio
backend exists.
- libclc: convert git= -> path=source (it was fully vendored; a fresh fetch
broke on the removed .git). Overlay symlinks added for both new qt modules.
Qt6PrintSupport ships inside qtbase (src/printsupport) — it was disabled, not
missing. konsole and 8 KDE packages (kxmlgui, kwin, plasma-desktop, ...) need
Qt6::PrintSupport; enable it rather than working around its absence.
Per the no-deferred-versions policy, bring every stale KDE recipe up to the
version its recipe declares (source/, source.tar, blake3, stamp all aligned):
- kf6-kiconthemes, kf6-kded6 -> 6.28.0 pristine (their old Redox shims are
obsolete: the guarded code was removed/refactored upstream)
- kirigami -> 6.28.0 (01-initial-migration baked; 02-qnetwork obsolete — 6.28
already uses a real QNetworkAccessManager in icon.cpp)
- breeze, kde-cli-tools -> 6.7.2 pristine (no Redox port)
- kf6-kservice -> 6.28.0 (QSharedMemory: relibc now has posix sems; verify at build)
- konsole -> 26.04.3 (multimedia/printsupport-optional port still required —
RedBear has no qtmultimedia; patch regeneration tracked as follow-up)
Codify in local/AGENTS.md: every package in a config builds from source/ at the
declared latest version; no stale source/, no mixed versions within a stack, no
commenting a package out of a config to make the build pass. When the auto-rebase
engine rejects a package, re-port it by hand to the new version — never freeze it
at the old one. A deferred old version or excluded package is a build failure to
fix, not a state to ship.
kf6-kcoreaddons 6.28.0 requires ECM >= 6.28.0 but the vendored ECM source/ was
still 6.10.0: the sync engine skipped it because ECM's version marker is a bare
set(VERSION "X.Y.Z") that the parser didn't recognize (only KF_VERSION /
PROJECT_VERSION / RELEASE_SERVICE_VERSION). Re-lay ECM from its 6.28.0 source.tar
(pure cmake modules, no Redox port) and teach both the sync engine and the
validator to read set(VERSION) so this class is caught, not silently skipped.
git links -lintl (libintl, from gettext) for i18n but never declared gettext as
a build dependency — it was implicitly relying on libintl.a already being in the
shared prefix sysroot from another package. When the relibc/kernel-touched boot-
ABI relink cleaned the sysroot, git's own sysroot lacked libintl and the link
failed. Declare the dependency so libintl.a is staged into git's sysroot.
486a7818 'Fix poll hang in os-test basic/poll': the fork still had
unregister_queue as a //TODO stub, so closed event queues leaked their registry
entries (the poll-hang class). Merged with RedBear's ref-counted queue-close
logic: keep the kdup dec_ref/is_last handling, and call unregister_queue(id,
token) to clean the registry when the last fd closes. Event-timeout handling was
already present as RedBear's own impl.
Pull genuinely-new upstream Redox fixes that apply cleanly onto the fork (the
poll-timeout crash fix was already present as RedBear's own tested impl):
- 72c0078d Fix ld.so PLT relocations by relocating lazily before is_me check
(relevant to RedBear's ld.so panic class)
- f8ef2864 Fix connect for Unix sockets outside the rootfs (UDS robustness)
- 8965d7fc Fix an unwind-safety issue in openat
The PipeWire audio stack needs more Redox porting (alloca via meson, MAP_LOCKED
and other Linux mmap/ioctl-isms across many files). Audio is not required for the
SDDM login or the desktop session, so defer both to reach the login milestone;
re-add once the audio port is complete. Baked patches + recipes stay in the tree.
pipewire uses alloca() in 41 source files without including <alloca.h> (glibc
declares it via stdlib.h; relibc does not), so cross-compiling hit -Werror=
implicit-function-declaration on conf.c:356. relibc provides <alloca.h> — add
-include alloca.h to CFLAGS so every TU gets the declaration.
These four recipes applied their local/patches/ at build time via
cookbook_apply_patches — a helper that is NOT defined in the cook environment
('command not found', aborting the build on pipewire). Per the full-fork vendored
model, bake each recipe's patches into its committed source/ (redox compat shims,
qnetwork impl, kf6 migration) and remove the broken call. The .patch files stay
tracked in local/patches/ for version-bump re-derivation.
vasilito