* add fluid speech pro to the speech model catalog
FluidVoice's Fluid Speech Pro, a Parakeet TDT 0.6B v3 retrain that also
declares Moondream's Parakeet Ultra as a base, for the same 25 European
languages. TalkMate converted it to a Q8_0 transcribe.cpp GGUF at d59dc79
(741,819,456 bytes, sha256 c3848e98...); the file says
parakeet/tdt-0.6b-fluid-speech-pro and announces its extra pre-Conformer
block as stt.parakeet.encoder.pre_block_kernel, so it needs a transcribe.cpp
that reads enc.pre_block.
Like Parakeet v3 it takes no language hint, detects the language under Auto,
does not stream, and is never recommended or badged. Its card publishes no
LibriSpeech test-clean figure, so it carries no single word error rate and no
benchmark record; its per-language FLEURS figures and the CC BY 4.0 credit
are in its details.
* bump(transcribe.cpp): 295c7e6, fluid speech pro's pre-conformer block
Fluid Speech Pro's GGUF announces stt.parakeet.encoder.pre_block_kernel and
carries eight enc.pre_block.* tensors: a residual FrameCleaner block between
the subsampler and Conformer layer 0. The old pin's graph never read them, so
the model loaded as plain Parakeet v3 and its encoder was wrong.
Both transcribe-cpp crates move to 295c7e601 on hex/combined-fluid, a
fast-forward of bcb639f that runs the block on pre_encode before xscaling
when the KV is present, and fails the load rather than skipping tensors when
it is only partly there. Cargo.lock changes only those two sources
(`getrandom`'s tempfile pointer was reverted to what it was), and
nix/package.nix carries the hash from a failed `nix build .#hex`, then a full
one whose check phase passed.
`hex model install fluid-speech-pro` followed by `hex model transcribe` on
whisper.cpp's jfk.wav prints the expected sentence, as does Parakeet v3 on
the same clip.
* fluid speech pro: snake_case id, FLEURS-only figures, blurb, notices
* bump(rune): c853811c, a settle lands before the frame's input (#1994)
Rune's catch-up settle (an uncover, a restore, a shown window) forced the
next frame's whole commit to land, so a dialog closed by that frame's press
or key was unmounted without its exit. Rune now commits the pre-input tree
with the settle and runs the input as an animated commit
(anomalyco/rune#1241).
All Rune git revs move to c853811c8e0e60a632eaa2e72992f871225737ef;
Cargo.lock changes only Rune-hosted crates, and nix/package.nix carries the
hash computed by a full `nix build .#hex`.
The replay test opens the vocabulary sheet, settles, and presses outside:
both layers exit mid-fade and are gone after settling.
* docs(vocabulary): list the settle-frame replay check
It covers an outside press on the first frame after the window comes back
still playing the sheet's exit.
* linux: round a Wayland window's bottom corners
Bump Rune to 431469b999268a56ef7fbc60ed55975753ee22df. Under GNOME Wayland
winit draws the client-side frame, whose headerbar rounds the top corners and
whose shadow cuts a 10-point rounded window, but the content's surface stayed
square: the bottom corners showed past the frame's border and the border's
straight bands crossed the shadow's cut-out (#1779).
Rune (#1188) rounds the content's bottom corners with the frame while the
window floats, and keeps them square when it is maximized, tiled or
fullscreen; a compositor that draws the decorations itself (KDE, sway,
Hyprland) keeps the surface it had. Patch sctk-adwaita from the same rev as
winit, since Rune's winit calls the vendored frame's
`AdwaitaFrame::content_corner_radius`.
The rev also carries Rune's macOS/iOS/Linux build fix after the crate
extractions (#1203), and its wheel fix (#1214): a wheel over a scroll bar now
scrolls the viewport it follows, so Hex's wheel-over-the-right-edge tests keep
their positions.
The bump brings the type-erased `window::Host` and window/ reorganisation,
the rune-core/rune-gpu/rune-image/rune-spell extraction, then rune-text,
rune-media and rune-edit, the non-generic `RuntimeCore`, windows-sys 0.61,
deep Taffy stack segments, one flatten and one detached-table prune, the new
wheel distance and chaining, and text, markdown and scroll fixes. No Hex call
sites changed.
Goldens are refreshed for Rune's visuals: the OpenCode icon catalog's marks
(terminal, search, keyboard, globe) in every pane and overlay, and the
shortcut-mode bars from Rune's border-over-fill change.
cargo check --all-targets, cargo test (2811 passed), cargo clippy
--all-targets --all-features, cargo fmt --check, code-shape.py,
check-nix-git-pins.py and its tests, nix build of the cargoDeps, and
cargo test rune_ui all pass.
* history: read Dictation stats from the window's settings
The pane closed its stats dialog and reloaded the rollup from the
process-wide labs switch. A test that applies another LabsSettings (as
several do) flips that mirror under it, so the dialog vanished mid-test.
Take the window's own `settings.labs.history_stats` instead, as the Stats
button and the dialog already do.
* nix: vendor Rune's fonts for rune-text, and run the suite serially
Rune's crates/rune-text includes crates/rune/assets/Inter-*.ttf by a path
relative to the workspace root; a vendored crate sits in git/ beside
rune-0.0.1, so link git/rune to it for the include.
The package check also runs plain cargo test, which shares Hex's
process-global lab switches and model-download state. nextest isolates
each test everywhere else, so run this one test at a time.
* goldens: refresh the meeting capsules on Rune's icons
Dev's capsule layout moved the time and close button above the title; with
Rune's icon catalog the copy-agent-prompt mark is the boxed terminal. Only
those four renders change.
* nix: run the package check one test at a time the hook's way
`preCheck` runs before cargoCheckHook, which then sets
RUST_TEST_THREADS=$NIX_BUILD_CORES, so the export there was a no-op and the
suite still raced on its process-global state. Set
dontUseCargoParallelTests instead, and take the rune vendor directory's name
from its cargoGitDependencies key, failing loudly if its assets are missing.
Drop the link once Rune moves the fonts into rune-text.
Hex's X11 window and its XWayland overlay load their X libraries at run
time: x11rb's `dl-libxcb` dlopens libxcb.so.1, and winit's X11 backend
dlopens libX11, libXcursor, libXi and libX11-xcb. Nothing links them, so
the binary carries no DT_NEEDED entry for the Nix loader to follow, and
the wrapper's LD_LIBRARY_PATH had none of them. Under X11/XWayland the
window and HUD then failed to open with x11rb's libxcb.so.1 load error.
Add libxcb, libx11, libxcursor and libxi to the runtime library path.
libxkbcommon-x11 is dlopened too and already ships in libxkbcommon,
which the path already carries. No build inputs or hashes change; only
the installed wrapper's runtime wiring does.
* Refresh the Rune pin for the Labs update
* Keep Labs categories on one line above the cards
* Cover a deep link to a category in the overflow
* Refresh the eight Labs reference renders
During an Annotate capture with the pen on, the ink overlay is a key,
non-activating panel, so the capture crate's background window-log thread
asking the system-wide element for AXFocusedApplication is answered
in-process by AppKit on that thread, calling AccessKit's subclassed
accessibilityFocusedUIElement, which borrow_mut's a main-thread RefCell,
panics in extern "C", and aborts.
Rune fixes this (anomalyco/rune#1040): off the main thread those three
overrides return the plain view's answer. Bumps Rune 1899e648 to 95874330,
28 Rune commits and no Hex source changes. Cargo.lock moves only the
rune-sourced packages, and the nix hash comes from a real nix build.
cargo check --all-targets, cargo test rune_ui (668 passed), nix build .#hex,
check-nix-git-pins.py, and code-shape.py --check all pass.
Diagnosis and the proposed patch came from @kartv19 in #1859.
* Bump Rune to 1899e64: overlays pace frames with the swap chain on Windows
Windows HUD memory grew and the app could hang after dictation because the
overlay presented frames without waiting for swap chain room after Rune #844;
Rune #985 makes an overlay's frames wait for room in its swap chain, as a
window's do.
nix: vendor each Cargo source in its own directory. Rune's tiny-skia-path is a
path dependency inside Rune (a Git crate at 0.11.4 here), the same name and
version as resvg's from crates.io, and cargo's directory source keys a crate by
name and version alone.
Goldens: Rune's text drawing changed over the 152 commits since d6715352.
* Review: patch accesskit_macos, and make the nix vendor split name what breaks
Rune #975 put accesskit_macos in its [patch.crates-io], so Hex patches it too
(Rune's README asks consumers to); it is the fifth and last crate Rune patches.
The vendor script override now checks each fragment it rewrites and names the
missing one, its comment says crates.io goes to registry/ and Git sources to
git/, nixfmt formats the file, and check-nix-git-pins.py's docstring says the
hashes reach importCargoLock through the cargoDeps override.
* linux: keep Hex running when the window can't start
Rune r399 makes App::run print a startup error and exit 1 on native targets
instead of panicking, so a Linux Hex with no display died, the next launch
became a fresh instance, and Check Linux's single-instance exercise saw
`hex start` hang and `hex app --hidden` reset.
run_app now returns Rune's try_run error and run_window reports it and waits,
as it did for the panic (#979).
* macos, windows: take rune's startup error instead of exiting
Rune r399 prints a startup error and exits the process from `run` on
native targets, which skipped Hex's own stop: macOS's drain (workers,
event-log flush, a recording kept for the next launch) and Windows' GPU
draw-marker disarm, so the launch that failed before drawing was read as
a crash while drawing. Both apps take `try_run`'s error now, log it, and
stop the way Quit does; Windows also reports it from `hex app`. The
Linux window already took the error (#979).
* macos: a launch whose window never started exits 1
Taking Rune's try_run error lets the app stop through the drain, but
process_exit::finish ends with _exit(0), so a failed GUI launch reported
success. finish_with takes the code; the window's failure exits 1 while a
normal quit keeps 0.
* docs: overlays wait for swap-chain room on windows since rune #985
Rune #985 makes every overlay's frames wait for room in its swap chain, so
the notes that said only a window waits and that the HUD's 60 Hz timer worked
around a suspected cause were stale. The timer is a cap on top of the slot
wait now. The macOS and Windows startup-error comments cited #979, which is
the Linux window issue; they describe Rune r399 instead.
* windows: a failed start keeps the GPU draw marker
disarm() means a frame reached the screen or Hex quit cleanly; a start that
never drew is neither, so it keeps the marker and the next launch falls back to
the high-performance GPU.
* docs: say what was measured about overlay pacing
* docs: say what stays bounded on windows, not what shrinks
The meetings map and the dictation map described the fix as memory that no
longer grows, and as Rune holding a frame's slot and skipping it. Rune #985
defers the frame until its swap chain has room, then draws it, which bounds
the frames in flight; the growth itself hasn't been re-measured on Windows
with the fix.
* nix: include site/src/labs.json in the package source
The fileset in nix/package.nix left out site/src/labs.json, so
labs::web::tests::the_website_lists_every_public_lab read a missing file,
got an empty string back from unwrap_or_default, and failed the sandbox
test phase.
* labs: split the feature catalog out of labs.rs to stay under the file cap
labs.rs was 1,503 non-test lines against code shape's 1,500 cap. Its
catalog entries (audience, added, oses, on_this_os, name, settings_key,
from_name, for_settings_key, off_refusal) move verbatim into
src/labs/catalog.rs, next to the other per-feature tables. The methods
stay inherent on Feature, so every caller and path is unchanged.
* bump rune to d6715352 (dev head)
The setting that was 29aacb68's ComboboxState is already in dev. This bump takes dev's pin (a7cea169) to Rune's current dev head: the capsule golden test now writes a miss's actual for CI's artifact, and goldens are regenerated for the new text drawing.
* goldens: regenerate for rune d6715352
Text draws with Rune's current masks: crispness in dark panes and the two capsule states moved past the tolerance, layout unchanged.
KDE's color-scheme portal describes window colors, so a mixed theme such
as Breeze Twilight picked a black mark for a dark panel. Bump rune for
TraySpec::icon_name, write anomaly.hex-symbolic.svg into the user's
hicolor theme at startup, and serve that name beside the pixmap so Plasma
6, GNOME's AppIndicator extension, and Waybar draw the mark in their own
text color. The icon keeps the old white/black default for hosts that
don't recolor, and the installer removes only a marked file.
Goldens follow the rune bump.
anomalyco/rune#324. On wayland winit withholds RedrawRequested while a
frame callback is pending, and a compositor may never send one for a fully
covered surface. A due timer asked for a frame that never came, so the
event loop sat on an overdue deadline and spun at 100% cpu after dictation
with the settings window covered. Rune now waits at most 250 ms for that
frame, then runs the timer without drawing.
* add a Labs toggle for Annotate overlays on GNOME
Rune won't back an overlay with an XWayland window when it asks for keys
on demand, so Annotate's recording capsule, ink, and picker never show on
GNOME Wayland: a capture records with nothing on screen. With Labs ›
Annotate on GNOME (`labs.gnome_annotate`, off by default), open them on an
already running XWayland like the meeting capsules do, with the same
checks at each show and without ever starting XWayland. The ink is made
with pointer regions and no keys, since it must take the pointer later
and Rune refuses an OnDemand overlay there; Esc can't stop drawing, so
the capsule's pen button or the Annotate key does.
idea and diagnosis from @pkkid in #1526
* Bump Rune to f2fb51ea
XWayland overlays now update their input shape on every drawn frame
* fix the Annotate lab copy and the XWayland checks
Esc can't stop drawing on the GNOME path, and a tap of the Annotate key
stops the recording, not the pen; the capsule's pen button or letting go
of a held key ends drawing. Use each language's existing name for the
Annotate feature, evaluate the ink's XWayland check once at install, and
skip the picker's check when nothing shows.
Rune 53c7f60 (rune#200) makes its DX12-or-Vulkan choice on the first real
GPU use instead of enumerating DX12 adapters as the event loop starts. The
old probe made a temporary D3D12 device on every adapter at launch, which
NVIDIA's App can take as a game launch: with Hex in the tray, Instant Replay
could capture Hex instead of the game and Alt+F10 save nothing.
Hidden startup now makes no Direct3D device. The HUD makes its device when
the dictation shortcut's modifiers go down (warm_gpu_with), and that first
call also makes the DX12-or-Vulkan choice on its thread, so the cold first
show doesn't pay for it. Not yet observed with NVIDIA's App, and on x64 the
speech model still loads on the GPU through Vulkan, which may still trigger
the same detection.
Goldens refreshed for Rune's text gamma and border snapping, and for stale
goldens from UI changes already merged on dev.
The Rune 7d3ee6ca bump updated the Nix pin but not its output hash, so
nix build failed with a fixed-output mismatch.
cargoGitDependencies now records each Git dependency's revision beside its
output hash, and scripts/check-nix-git-pins.py fails when Cargo.lock names a
different revision. compile.yml runs it for Cargo.lock and nix changes.
Fixes#1397.
hex.exe is now a GUI program. Commands run from a terminal join it
(AttachConsole) and print there; the app leaves it after startup errors
have had their chance to print. Rune 31dbcad cloaks a window until its
first frame presents. Release checks assert the GUI subsystem.
Rune 90355ba: the native Metal backend offers IMMEDIATES, which the
window's and HUD's compositors ask for (their Painter), so they no
longer fall back to wgpu, and the window keeps the prewarmed device.
process.log names the backend each window and HUD device draws with
(rune::describe_gpu). launch.bench.ts gains first-frame;
interaction.bench.ts measures gpu.process.3d and drives macOS through
accessibility and the wheel.
* windows: drop hidden overlay windows so game capture doesn't take Hex for a game (#1308)
* rune 7897b03: hidden Windows overlays have no window (#1308)
On a Wayland compositor without layer-shell (GNOME), the recording offer and
recording capsule can open on an already running XWayland with Labs ›
Floating meeting capsules on GNOME (gnome-meeting-capsules, off by default),
through Rune's new OverlayOptions::xwayland_input. Off, or when the overlay
still can't open, the offer opens the Meetings pane as before (#1271), whose
note now names the lab. Rune pin bumped for anomalyco/rune#85.
Thanks @lgwacker for the analysis in #1274 and rune#85.
* Accessibility: name Hex's panes and controls for screen readers and strobe
* Rune c35fe19; pane_header beside title_bar; rows report selected only when selected
* Drop the unused title_bar import
* Tests: microphone row at the tall size; say what the tree held when a key is missing
* Tests: read the microphone field with its menu closed
* Rune f6799d3
* perf(windows): tray Hex makes no GPU device until something shows
Rune 4c039671. The capture capsule, picker, and ink keep their windows from
launch but make their GPU surfaces only to show (release_gpu_when_hidden).
gpu-draw.pending is written when Rune starts the launch's first GPU device
(rune::on_gpu) and cleared by its first frame, so a tray launch that never
draws leaves no marker.
* perf(windows): the first HUD after rest shows without waiting for the GPU
Rune c448a35a. A first surface on a new device now takes about 210 ms to its
first present instead of 630 to 850 ms (precompiled DX12 uber shader, one
adapter enumeration). The HUD keeps its window from launch, keeps its GPU
surface for 5 minutes after its last hide (release_gpu_after), then gives the
device back. When the dictation shortcut's modifiers go down, Rune makes the
device and the HUD's pipeline on a thread (warm_gpu_with), so the HUD that
follows shows in about 15 ms.
* docs(capture): the picker is prewarmed again; it holds no GPU surface while hidden
NVIDIA's X11 surfaces are opaque only, so Rune handed every translucent
overlay to lavapipe, whose swapchain makes DRI3 requests NVIDIA's Xorg
refuses; the async X error then panicked whichever window winit touched
next. A software adapter now never takes an overlay from a hardware one.
The overlay draws on NVIDIA with opaque alpha, and an X compositor still
blends its ARGB window. Thanks to the #1216 reporter for the diagnosis.
* Scroll bars on every pane and dropdown; Page keys in menus (#1209)
* Rune 3d7b60d2 nix hash
* Rune 3c6ac905: scroll bars on panes and dropdowns, Page keys in menus; goldens (#1209)
* Feature map: scroll without a wheel (#1209)
A prewarmed layer-shell overlay that has not been shown yet (the Annotate
ink surface) kept its own Wayland queue with a keyboard, and nothing
dispatched it while hidden. Every wl_keyboard.keymap the compositor sent,
a few per paste through wtype's virtual keyboard, sat there with its fd
open. Rune now drains a hidden layer surface's queue each loop turn.
Reproduced in a headless sway: fds grew by 2 per wtype run on the old
build and stayed flat on this one across repeated dictations and pastes.
* Move 2.3.1 Linux and Windows installs into the managed layout when their updater installs this build (t1217)
* Give the Nix check flock for the installer the 2.3.1 adoption test runs (t1217)
After the Dock icon came and went with Settings, macOS could tie the HUD's
panel to one Space while AppKit still reported its all-Spaces mask, and
setting the same mask again did nothing. Rune now clears and resets the
mask before ordering an all-Spaces overlay in, and orders it out first if
it is still shown on another Space.
wgpu compares Devices by id, and each Rune GPU has its own instance whose
first device gets the same id as the last one's, so device != f.device never
saw a new device. The HUD and the Sounds preview now keep their painter by
Frame::device_key, unique per device for the process. Thanks to the #982
reporter for catching it on hardware.
Rune: overlay surface configuration runs in a wgpu error scope, so a refused
surface fails that overlay instead of panicking the whole Rune app. Overlays
on GNOME + NVIDIA stay on the compositor's GPU instead of moving to an iGPU
or lavapipe that claims translucent alpha but can't make the swapchain, keep
their own device across shows, and rebuild their renderer on a new device.
Hex: the HUD painter is rebuilt when its device changes. If the window's Rune
app still dies, hex window show and hex status say so (from the pipeline's
first attempt).
Analysis credit: @adelekeogunsona (#979) and the #982 reporter, whose
swapchain repro and proposed Rune changes this follows.
* Bump Rune: dropdown lists fade their scrolling edge (hex#840)
* nix: Rune f1fe6164 hash
* Golden: the language menu shows it scrolls (#840)
* Bump Rune 9f8bfca7: a select shows half its next row (#840)
* Bump Rune f5def6d4: the next row's label shows fading (#840)
* Cargo.lock and the language menu golden
On Windows and X11 the shown HUD checks the pointer's display every 250 ms
(from its own frames) and, when it changed, moves there with the live text
at once, without animating or taking focus (Rune 0e5ce3c7's
`OverlayHandle::refollow_pointer`). Wayland compositors keep the focused
output; GNOME and KDE keep the primary display.
Fixes#807