Teach qmllint about statically registered native QML types and enforce metadata parity. Pin release builds to the MSVC 2022 runner and force Cargo to use the Visual Studio linker instead of Git for Windows link.exe.
cx
test-crates.yml's `qt-gate` job proves the Qt frontend on Linux: five QML
audits, the Slint-free dep-graph check, cargo test -p qbz-qt, and an offscreen
boot that fails on a QML complaint or a missing "QbzCore initialized". Windows
had no equivalent, so nothing verified it between one hand-run release and the
next.
Same gates, same complaint regex, same core-init check, so a Windows
regression produces the same shape of evidence as a Linux one.
Triggers follow the repository rule the release workflows already use:
AUTOMATIC ON A `v*` TAG ONLY, with workflow_dispatch always available and
taking an optional ref. No branch push and no pull_request: a Qt build on a
Windows runner is fifteen minutes at twice the Linux rate, and gating every
Linux contributor's PR on a platform that ships explicitly as-is would block
work nobody promised to support. On a tag it runs beside release-windows.yml
and answers a different question -- that job proves the artifact builds and
boots, this one proves the types resolve and the tests are green.
It adds one gate the Linux job does not have: qmllint. `cargo check` sees
nothing of QML, so a wrong type name or a property that does not exist compiles
perfectly and fails at RUNTIME -- and because the failing component hangs off
AppShell, the shell never instantiates and the app opens to a GREY SCREEN. That
happened during this port and reached the owner; qmllint found all three causes
in seconds. Adding it to the Linux job is a Linux change and belongs to Linux.
Two Windows-specific pieces of the smoke: long paths are enabled first, because
cxx-qt deep-copies include trees and qmlcachegen writes ~340 files under
OUT_DIR; and the run gets a private %APPDATA%/%LOCALAPPDATA% rather than the
XDG dirs and private session bus the Linux gate uses, since every store QBZ
opens derives from those and a smoke writing into the runner's real profile can
pass on what a previous run left behind.
cc
Mirrors release-macos.yml step for step: aqt MSVC Qt, cargo build -p qbz-qt,
windeployqt --qmldir, the offscreen smoke with the Qt install hidden, a WiX 7
MSI, a portable zip and the PDB. Unsigned by decision (D4).
The MSI carries the identity the app cannot give itself. Its Start-menu
shortcut sets System.AppUserModel.ID, and a matching
Software\Classes\AppUserModelId key is written beside it: Windows resolves an
unpackaged app's AppUserModelID through EITHER, and without one of them it
drops every toast without a word. The URL protocols qbz:// and qobuzapp:// are
registered the same way, the analogue of CFBundleURLSchemes.
The NASM step stays. Measured on the box: aws-lc-sys 0.39.1 uses real NASM --
its shipped prebuilt objects are only used when nasm is ABSENT -- and without
either the build fails hard with "Missing dependency: nasm". Switching rustls
to ring would drop the requirement but would change the crypto provider on
Linux and macOS too, which is a project decision and not a port's to make.
The Qt LGPL text now travels with every artifact that bundles Qt, verbatim from
gnu.org, alongside a notice naming the pinned version, the modules actually
present in a release build, where the sources are, and why relinking is a file
copy here (dynamic linking, DLLs beside the exe, no static build, no qt.conf
prefix rewrite).
Not dispatched: HARD RULE 4 makes that the owner's call.
cc
The GLSL 1.20 variant must stay in plasma/ambient's packs: Qt's OpenGL
RHI selects 120/130/140 on desktop GL <= 3.1 and the renderer tier does
not exclude that hardware, so dropping it (the previous attempt) was a
regression for old GL — caught in review. qsb 6.8 cannot lower those
shaders' uint hash constants for 1.20 while 6.9+ can, and the committed
.qsb were baked with 6.11: the bake toolchain is therefore pinned apart
from the 6.8 runtime floor (vars.QT_VERSION_SHADERTOOLS, default 6.9.3).
The gate also passes -b only to vertex shaders without the no-batch
marker, exactly like build.rs.
cc
qbz-qt pulls wayland-sys through arboard's wayland-data-control, and its
build script wants wayland-client.pc. The CI VM had the Slint-era dev
libraries baked in, which hid the gap; the first real qt-gate run on
pre-release exposed it. Added to test-crates' qt-gate and to
build-qt-linux.
cc
Measured cold on the 4-vCPU CI VM: CARGO_BUILD_JOBS=4 finishes the
workspace test in 392 s against 589 s at jobs=2, with a 2.7 GB peak on
a 10 GB guest. The throttle protected a 30 GB rustc that no longer
exists in this graph. Leave the job count to cargo in the workflow and
in scripts/cargo-test.sh alike; --no-fail-fast and the 20-minute limit
stay.
cc
The single-instance lock is a D-Bus well-known name, so on a developer
box with QBZ open the debug binary presented the running instance and
exited with one log line, failing the gate for the wrong reason. The
smoke now runs under dbus-run-session with its own XDG dirs — never the
developer's config or session — in the script and the workflow alike.
cc
Per the 2026-08-26 rule: the workflow's test job runs scripts/cargo-test.sh
(CARGO_BUILD_JOBS=2, --no-fail-fast, 20-minute limit), the script
documents what --workspace covers now that the Slint crates are gone,
and QT=1 runs the Qt gates locally in the same order as the shader-gate
and qt-gate jobs: audits, shader bake, Slint-free graph, cargo test
-p qbz-qt, offscreen boot.
cc
qml_resolution_audit hard-coded /usr/lib64/qt6/qml, so on a runner it
saw zero Qt types and reported every Rectangle as unresolved; it now
takes QBZ_QT_QML_DIR (authoritative), then QT_ROOT_DIR, then the distro
layouts, and fails loudly when none has plugins.qmltypes. test-crates
runs the audits after the Qt install, pointed at it.
build.rs re-bakes a shader only when its .frag is newer than its .qsb,
which makes a fresh checkout nondeterministic whenever qsb is on PATH.
Release and test builds now install Qt without qtshadertools, so the
committed .qsb ship as-is, and a new shader-gate job bakes every shader
to a temp dir with the pinned qsb using build.rs's own target lists
(read from the file, so they cannot drift). It is red today at 6.8.3:
plasma.frag's uint literals do not bake for the GLSL 120 target with
qsb 6.8 (6.9+ accept them) — that is the finding, not a false positive.
cc
test-crates is meant to merge first, ahead of the release-workflow
rewrites; a gate over .github/workflows/ would fail on the still-Slint
release files until those land. The gate stays in release-linux and
release-linux-aarch64, which are the files it protects.
cc
The Slint crates are gone from the workspace, so cargo-test.sh's four
--exclude flags were stale; qbz-qt is the only exclusion now (it is the
one crate that needs Qt, and the sole consumer of wayland-sys — the
reason the workspace test fails on a runner without libwayland-dev).
Release workflows write their caches from main only: nothing but
test-crates.yml is meant to run from pre-release.
cc
The five static QML audits move from the docs checkout to
scripts/qml-audits so CI runs the same gate as scripts/qt-run.sh
(which now defaults to the in-repo copy). New qt-gate job: audits,
Slint-free graph check, cargo test -p qbz-qt, and an offscreen boot of
the debug binary that fails on any QML complaint. cargo-test.sh excludes
qbz-qt (it needs Qt) so the no-UI job stays cheap.
cc
org.kde.Platform 6.9 provides Qt above the 6.8 floor; the manifest no
longer runs cargo, needs no rust/llvm SDK extensions and no swap. The
workflow takes the binary from build-qt-linux.yml, builds qbzd
alongside, and boots the installed bundle offscreen inside the sandbox
before publishing. Same shape as the Flathub manifest.
cc
core24 ships Qt 6.4.2 and the tree needs 6.8, so neither stage-packages
nor a remote source build can provide Qt: the dump recipe now takes the
AppDir tree from build-qt-linux.yml (both arches) and the root
snapcraft.yaml plus its packaging/snap symlink are deleted. snap-slint
becomes snap-qt with the non-Qt runtime only.
cc
The Slint workflow copied the bare Mach-O into the bundle; a Qt binary
is not self-contained. Now: universal aqt Qt (Homebrew's split layout
breaks macdeployqt with rpath errors), MACOSX_DEPLOYMENT_TARGET 12.0,
the arm_acle.h include for Qt 6.9's qyieldcpu.h on Apple clang 21,
macdeployqt -qmldir, then an offscreen boot of the bundle with the Qt
install hidden before signing and packing. Intel builds move to
macos-15-intel. Measured on the Mac mini M2 2026-08-25.
cc
Both call build-qt-linux.yml. deb/rpm/AppImage are packed from the
AppDir (Qt bundled under /opt/qbz, /usr/bin/qbz symlink, RPATH and
qt.conf resolve through /proc/self/exe — no wrapper, which would leak
LD_LIBRARY_PATH into spawned processes); the AUR/Gentoo/Flathub tarball
keeps the bare binary. Every published file name is unchanged. Adds the
gate that no workflow builds `-p qbz` (the frozen Slint bin shares the
name and target dir). The two files differ only in the ARCH block.
cc
One workflow_call recipe for every Linux release path: aqt Qt (the
runner's own Qt is 6.4 and lacks QtQuick.Effects), Rust stable, no
memory tiers, ubuntu-22.04 for the glibc 2.35 floor. Produces the bare
binary and a self-contained AppDir (linuxdeploy + Qt plugin, Wayland and
offscreen platform plugins added explicitly), then boots the AppDir
offscreen with the Qt install removed from the environment and fails on
any QML complaint. Dispatchable on its own as the pre-flight.
Recipe measured on the 24.04 CI VM 2026-08-25 (contracts in
qbz-nix-docs/cicd/2026-08-25-qt-workflows-contracts).
cc
qbzd pulls qbz-audio whose jack-sys build script requires jack.pc; the
desktop build job already installs libjack-jackd2-dev, the new qbzd jobs
did not.
cc
The x86_64 workflow fires the repository-dispatch minutes after its own
publish, while the native arm64 build is still running — so qbz-apt's
update-repo downloaded the Release assets when only the amd64 .deb existed.
The arm64 .deb landed hours later with nothing re-indexing, leaving the
apt arm64 tree stuck at 1.2.15 (verified: QBZ_*_arm64.deb IS on the 2.0.x
releases). update-repo is idempotent (re-downloads every *.deb, rebuilds
both indices), so the second dispatch completes whichever arch the first
one missed, in either finish order.
km
IV6 build peak: 795 MB max RSS (summed across the cargo-capped build's
process tree via /proc VmRSS polling; /usr/bin/time -v is not installed
on this box). aws-lc-rs in graph: 0 (single rustls provider: ring
v0.17.14 throughout).
cc
Adds a prominent 'bug reports need logs' banner and a required pre-flight checklist (attach logs or explain why not, searched duplicates, included repro steps). Without logs most reports stall on needs-info.
cc
vicrodh