Wishlist from the first day of real use (2026-09-20), in the order I'd build it. Nothing here is started.
One feature, three symptoms:
- No virtual-device picker. freeseries only works with its own virtual endpoint, so find the FxSound device by name and hide that choice. Keep the picker as a fallback when no such device exists (VB-Cable users).
- Per-device correction. Each output remembers its own headphone correction. (Until 2026-09-20 it also held the sound preset; see "Where the sound lives" below.)
- Auto-switch. A priority list of outputs. Headset turns off -> audio moves to the monitor and its EQ; headset comes back -> audio moves back. The engine already notices a dead output (
Status::Reconnecting); today it retries the same device forever instead of falling to the next one.
This is also the robustness story: a missing headset must never mean silent audio.
app/src-tauri/resources/setup.ps1 installs the vendored, Microsoft-signed fxvad package (one UAC prompt) and names the endpoint "freeseries". The app opens the wizard by itself when no virtual device exists, watches for the device becoming the Windows default, then hands over to Devices. Verified: the script on Windows PowerShell 5.1 (dry run and rename), the elevation command line (unit test), the whole flow against the preview's simulated fresh PC. Not verified: the elevated install from inside the app, because the only test machine already has the driver.
Found on the way: renaming an endpoint (PKEY_Device_DeviceDesc) needs no admin rights, so it never prompts. The "(FxSound Audio Enhancer)" suffix is the driver's interface name and stays.
Still open: a one-click "make it default" (needs the undocumented IPolicyConfig COM interface that EarTrumpet and SoundSwitch use; today the wizard deep-links to Sound settings and detects the result), and uninstall.
Done since: a live spectrum analyser behind the curve (src/spectrum.rs: a tap on the processed audio, an own radix-2 FFT run off the audio thread, 96 log bands; drawn on a canvas outside React). Its display range (-84 to -12 dBFS after a 4.5 dB/octave tilt) was tuned against synthetic data only and wants a look with real music.
The EQ editor needs love and the app reads as an open-source project. Do it as a proper design pass with the impeccable skill, not piecemeal.
-
Where the sound lives (changed 2026-09-20). A sound preset belongs to a channel, a headphone correction to an output, and nothing else carries an EQ. Before, the output held a sound preset too and the Mixer let a channel name a second one: both ran in series, so a user with "PSense Game" on the channel and "PSense Media" on the output got two curves and two preamps, 10.6 dB down (found when the user reported low volume; every Windows endpoint volume measured 100% with
examples/volumes.rs). Now the Equalizer and the Presets page work on one channel, picked with a Game / Chat / Media switch in the toolbar; the Mixer strip's picker sets the same curve and its thumbnail opens the editor on that channel. The engine is unchanged: channel presets travel in the plan (a plan with the same devices retunes the running session), the output preset is the correction alone. Saved settings migrate (store.ts, checked bynpm run check): a channel's own pick wins, otherwise the main channel inherits what the first output played. The editor still draws the active output's correction as a dashed reference line, and headroom is worked out over correction plus sound. The analyser shows the whole mix, not the channel being edited. Checked in the browser preview only. -
Starter sound presets written for freeseries: Footsteps, Bass boost, Voice clarity, Late night, each with a preamp that cancels its loudest point.
-
Import / export in Equalizer APO
ParametricEQ.txttext: import from a file, copy the current sound to the clipboard. -
Soft limiter after the EQ (
eq::limit): identity below -1 dBFS, bends towards full scale above it, no look-ahead so no latency. -
Tray menu (2026-10-17). Right-click the tray icon: Play on (every output, the one in use ticked), Sound (every preset), EQ on, Mic on (when a cable and a mic are set), Audio processing, Quit. The UI owns the menu:
tray.tsbuilds the list from the same state the pages show,set_tray_menurebuilds the native menu whenever it changes, and a click comes back as a "tray" event with the item id, acted on through the same setters as a click in the window. Checked bynpm run check(the list) andcargo check; not yet clicked in the real app. -
Global hotkeys: Ctrl+Shift+F9 / F10 previous / next sound preset, Ctrl+Shift+F11 bypass. Not Ctrl+Alt (that is AltGr on European layouts). A shortcut another app already owns is reported in Settings instead of failing the launch. Untested in the real app: the Rust side compiles, nothing has pressed the keys yet.
-
Agent access (built 2026-09-20). An AI agent can tune the EQ with the user: an MCP endpoint (Streamable HTTP with plain JSON responses, spec 2025-11-25, no event stream) on 127.0.0.1:47630 (47631 in a dev build), off until switched on in Settings, which also hands out the
claude mcp addcommand.app/src-tauri/src/agent.rsis only the HTTP edge, on std alone: loopback bind, a bearer token, foreignOriginorHostrefused (a web page can reach 127.0.0.1; the MCP spec asks for exactly this), POST only. Every JSON-RPC message goes to the webview as an "agent-request" event and the answer comes back throughagent_reply, because the state lives in the UI: the tools (app/src/agent.ts: get_state, listen, set_eq, use_preset, save_preset, search_headphones, use_headphone_correction) change it through the same setters as a click. set_eq validates and clamps like the editor, and without a preamp picks the one that puts the loudest point at 0 dB. A hand-tuned, unsaved curve is filed as " (before agent)" before an agent replaces it. Setup, routing and anything elevated are out of an agent's reach. Checked: the HTTP edge by a Rust test, the protocol and set_eq bynpm run check, all tools against the whole app in the browser preview. Run end to end 2026-09-21 with curl against the dev build: handshake, tool list and get_state come back with the user's real channels, 401 without the token, 403 with a web origin. Still unproven:listenwhile the window sits in the tray, where WebView2 slows timers to about one a second. -
Upgrading without uninstalling (2026-09-21). The installer never needed the old version removed: over an existing install it shows a page whose second option is "Do not uninstall", and it has the update mode Tauri's own updater uses.
npm run upgrade(app/scripts/upgrade.ps1) builds and runs it with/P /UPDATE /NS /R: no pages, settings and shortcuts stay, the app restarts. Flags read out of the generatedinstaller.nsi; the script has not been run. It closes everyfreeseries-app.exe, a dev build included. Version 0.3.0 from here on, so an upgrade is an upgrade and not a same-version reinstall. An in-app updater (tauri-plugin-updater) is the next step and waits on two things that are the owner's: a public place for releases (there is no git remote yet) and a signing key only they hold. -
Headset modules (2026-09-21). Per-headset hardware support is a table, one file per headset, community-maintained except the Arctis Nova Pro Wireless (the only one we own). Replaces
arctis.rs. The ChatMix dial drives the Game / Media balance; battery and mic mute show on the output strip. Details, the protocol and how to add a headset:docs/headsets.md. Microphone processing research and the route to try first (VB-CABLE as the virtual mic, our own capture APO as the fallback):docs/mic.md. Later, on the same kind of seam: clip capture with one track per channel (the engine already has every channel separately). -
The cushion follows the load (2026-11-02). A week of log checks showed 5-10 audible dropouts a day while gaming, each one capture packet 10-30 ms late, more than the 12 ms cushion, and one 120 ms HDMI stall nothing reasonable covers.
Cushion(wasapi.rs): a second in which playback ran dry deepens the cushion by 10 ms, up to 32 ms; every quiet minute takes 10 ms back off.Feed::mix_intonow returns the dry count, and the feed builds the deeper cushion the way it rebuilds a used-up one. The cost is 10-20 ms of latency only while the PC is loaded. Tested with the rig; not yet run on the PC. -
Devices page: monitors that change id, a headset that is off (2026-10-26). The user's HDMI monitor came back from every restart as a new endpoint (five different ids for it in the log), so its saved entry went red and a second "Odyssey" sat under Add.
adoptRenamed(devices.ts, checked bynpm run check) moves a saved entry whose id is gone onto the listed device of the same name, correction kept, as long as that device isn't saved already. And the dot was green for the Arctis while the headset was off, because its base station keeps the endpoint listed; the engine already knew (it had moved to the monitor). The Devices page now gets the headset's model while it reports itself off and shows that output red, the same rule as the engine'sPresence. -
Devices page slimmed (2026-10-17). The user: too much text, no way to see which outputs are there, the correction confusing. Each output row now carries a dot, green when Windows lists the device and red when it doesn't (the one playing glows and says so), and only the controls that act on it: Play here / Unpin, reorder, remove. The two long hints are one sentence each. The correction left the rows for its own section under the list, for the output in use (the one playing, else the one that would play): name, the correction or None, Remove, Find yours / Change opening the AutoEq search in place. The Mixer's output strip still opens that section. Checked in the browser preview with a playing, an online and an offline output.
-
Where the correction lives in the UI (2026-09-28). The user picked an AutoEq correction on the Presets page and could not find it in the Mixer: two kinds of preset on one page, and the Mixer showed the correction as one small line on the output strip while every channel strip had a picker for its sound. Now a correction is chosen on the Devices page, on the output it belongs to (a "No correction" / name link on each output row opens the AutoEq search under the list, titled with the output); the Presets page holds sounds only and says where corrections live; the Mixer's output strip draws the correction curve the way channel strips draw their sound, with the name under it, and clicking it opens Devices on that output. Checked in the browser preview.
Still to do from the same list: switch the sound preset when a game launches (needs foreground-process watching and a rules UI), the IAudioClient3 backend, README / updater / code signing for a public release.
Let Sonar users bring their configs. Format is unresearched: find where GG stores Sonar configs on disk and what a shared community-config link contains, then map its filters onto our bands.
Measured 2026-09-20 with examples/process_probe.rs (child process plays tones, parent captures its process-tree loopback and the endpoint loopback at once):
- Windows' per-process loopback returns the app's raw stream: a stereo tone comes back bit-for-level (-20.0 dBFS, L only); of a 7.1 stream it returns the front pair only (back-left: silence). It is pre-mix and pre-spatial, so it can never carry the Atmos/DTS render.
- It is taken after the session volume: muting the app in the mixer silences the endpoint loopback and the per-process capture. So "mute it on the endpoint, capture it per process" doesn't work, and neither does subtracting captures from the mix (the spatial renderer doesn't pass stereo bit-exactly).
What that leaves, best first:
-
A second instance of the same signed driver. VERIFIED 2026-09-20.
setup.ps1 -AddInstance(elevated) createdROOT\MEDIA\0002from the package already installed: status OK, its own endpoint, andexamples/probe.rsshows the two loopbacks are fully independent (a tone played into one reads -20.0 dBFS on its own loopback and digital silence on the other, both ways). Endpoints are named per instance without admin rights: "freeseries", "freeseries Media", then "freeseries Chat" (Media came second from 2026-09-21: music next to a game matters to more people than voice chat does; the balance slider sits between the main channel and whichever is second). From the same day the name people read is spelled "FreeSeries": the endpoints ("FreeSeries", "FreeSeries Media", "FreeSeries Chat"), the product name and the UI copy; crate, exe, paths, the logon task and the MCP server key stay lowercase.setup.ps1renames an endpoint that carries one of our names in the old spelling, so an upgrade fixes itself (run on the user's PC: both endpoints renamed, a second run changes nothing, the live engine never noticed). The main endpoint stays plain "FreeSeries" rather than "FreeSeries Game": most people never add a channel, and it is the one to make the default. The extra endpoints can't be hidden from Windows: a disabled endpoint can't be played into, and that is how an app gets onto a channel. The Devices page says so instead, and shows whether FreeSeries is the Windows default. This is Sonar's own model with no new driver to sign.Built 2026-09-20. The engine captures every channel's device in one session, applies that channel's EQ and volume, sums them and runs the output's EQ and the limiter over the mix (
src/wasapi.rs). Hardware check through the CLI (freeseries run 0,1 2): a tone into either device arrives at the output at -19.9 dBFS, a 24 s soak shows 0 dropouts and 0 phase jumps, latency 13-31 ms per run. The app has a Mixer page (Game/Chat balance, per-channel volume, mute and EQ) and an "Add the chat device" action that runssetup.ps1 -AddInstancebehind one UAC prompt. Untested in the real app, and that action has only ever been run by hand.Apps into channels, built 2026-09-20.
src/routing.rsdrives the per-app output device of the Windows volume mixer through the undocumentedWindows.Media.Internal.AudioPolicyConfig(layout and IIDs from EarTrumpet; same vtable on Windows 11 and on Windows 10 before 21H2, different IID). Measured with a test process: pinned to "freeseries Chat" its tone reads -20.0 dBFS there and silence on the main device, the pin survives a relaunch (Windows stores it per app), un-pinning sends it back to the default. Two limits found: an app can only be pinned once it has an audio session (E_INVALIDARGbefore that), and an app moves when it next opens a stream (real apps reopen at once; a stream that ignores the invalidation stays put). The Mixer page has a board: a lane per channel, drag an app across, all processes of the same executable move together, with a per-app select as the keyboard route.Quitting hands apps back (2026-09-21). Windows keeps an app pinned to a channel's device whether FreeSeries runs or not, so after Quit those apps stayed silent even once the user pointed Windows back at their headphones; the way out was to reopen, drag everything off Media and quit again. Now the tray's Quit un-pins every app that sits on one of our virtual devices (
routing::release, tested with a fake; a user's own pin to a real device is left alone), and the UI remembers which channel an app belongs on (assignmentsin the saved settings, by app name) and pins it again whenever audio is running: at the next start, and for apps that open later (checked every 5 s; pins found from before this existed are taken over once). Checked in the browser preview and by the Rust test; the real quit has not been run. The Windows default follows the engine (2026-09-21): see "Handing the default back" below. Limits: only apps that are running at Quit can be released (Windows offers no way to list pins of apps that aren't), a crash or a kill releases nothing.Console, built 2026-09-20. The Mixer page is a mixing console: one strip per channel (EQ thumbnail and picker, its apps, fader, mute, name plate), an output strip, and a Game/Chat crossfader. The whole strip is the drop target. Live peak meters come from the engine (
Dsp::levels(), per channel after EQ and volume, plus "out" for the mix after the limiter), polled 20 times a second and painted outside React. Apps show their real icon (routing::icon_of,SHGetFileInfoWto RGBA; checked by eye against Spotify, Discord and Chrome withexamples/icon_dump.rs). Checked in the browser preview only: a real mouse drag, the meters and the icons have not been seen inside the Tauri window. -
Mixer-only channels as the fallback: group apps into Game/Chat/Media and drive their Windows session volumes (
ISimpleAudioVolume, what the Volume Mixer does). Works with Atmos/DTS and adds no latency, but no per-channel EQ.
Mic processing (noise suppression, mic EQ) needs a virtual capture device; fxvad's capture pin is disabled in its signed INF. Parked.
The one failure every voice of the council named: the engine goes away and the PC is silent, because Windows still plays into our virtual device. Now the Windows default follows the engine. While it plays, the default is ours; when it stops, quits, crashes or is killed, every role (Console, Multimedia, Communications) that pointed at one of our devices moves to the output the engine was playing on, and the roles we moved come back when the engine runs again, unless the user has pointed them elsewhere in the meantime.
src/default_output.rs: reading the default is documented API; setting it isIPolicyConfig::SetDefaultEndpoint(undocumented, what the Sound control panel uses; GUIDs and vtable slot 13 from EarTrumpet's source).hand_back/take_backdecide first and move second, because Windows 11 drags Multimedia along when Console moves (seen on hardware, pinned in the test).app/src-tauri/src/handback.rs: the policy with its state inhandback.json(app data) behind aStoretrait. A watcher thread followsEngine::status(); Quit hands back on its way out; and for a death without a say, the app starts a second copy of its own exe as--watchdog <pid> <state file>, which waits for the app's process to end and then hands back. It shares nothing with the app but the file.- A development build does none of this: the default belongs to the installed app running next to it.
- Checked on this PC: the setter (FreeSeries -> headphones -> FreeSeries, all three roles,
cargo run -- default [device#]), and the real watchdog process against a stand-in that was killed: the default moved to the headphones within the 5 s I waited, the watchdog exited, the state file recorded it. Not yet run: the installed app doing it by itself (Stop, Quit, End task, and the take-back at the next start); that needs the next install. - The installer closes every
freeseries-app.exeby name, which includes the watchdog (good: it would otherwise hold the exe open), so an upgrade does not hand back; the app restarts right after.
The tool plays quiet noise into the virtual device, records the loopback of that device and of the output, and cross-correlates them on WASAPI's own capture timestamps. Self-against-self reads 0.0 ms.
- 0.1.1 as installed, FxSound -> Arctis: 64 ms. Most of that was backlog: audio that queued up while the streams started (capture runs first) and was never given back. It varied from start to start.
- With the queue trimming in
src/wasapi.rs(drop whatever is always left over, keep an 8 ms cushion), FxSound -> monitor: 25-27 ms, the same on every start. Not yet measured on the Arctis route. - Asking cpal for one-period buffers changed nothing. ~25 ms is the floor of shared-mode WASAPI at its 10 ms period: one period to capture, one to render, plus the cushion.
Measured again 2026-09-21 on the real route, installed app, three runs each within 0.2 ms: main channel -> Arctis Nova Pro Wireless 30 ms, Media channel -> Arctis 51 ms. A dev engine of the current code to the monitor reads 20 ms (main) and 21 ms (Media), so the 20 ms the Media channel loses on the installed build is unexplained: re-measure after the next install before chasing it.
What the "glitch" lines in the log really were (2026-09-21, second and final reading).
Two readings of the same log lines were wrong before this one, and both are kept here as a warning. First "a glitch every three minutes from clock drift" (the intervals run from 12 s to 35 min). Then "the tray app's capture thread is starved by builds, 5 runs of 5": every one of those five "witness" results was the test tone of tools/glitch-under-load.ps1 itself starting and stopping on the installed app's Media channel. The user's run against the new build showed it: one "media capture glitch" in the second the tone began.
The group "2x capture glitch, dropped 4 ms" then, a while later, "playback ran dry N times" is a sound starting and a sound stopping on a channel, nothing else. Loopback delivers nothing while an endpoint is silent; when a sound starts, WASAPI flags the first packets as discontinuities (logged as glitches), they arrive as a burst (extra delay), and when the sound ends the queue empties while the channel still counts as talking (logged as running dry). Two of those three were only noise in the log. One was real: about a second after every sound that starts from silence, the old code cut the burst's 4 ms out of the middle of it.
Fixed in src/wasapi.rs (Feed::mix_into, pulled out of the playback closure so it can be tested with a ramp signal and a fake clock):
- A channel waking from silence holds its first samples until the cushion is queued (twice it until 2026-10-02), so the sound starts without holes and nothing of it is lost.
- Built-up delay is never cut out any more. It is eased out: the channel plays 0.5 % fast (2 % for more than 10 ms of backlog), interpolating between samples, until the measured excess is gone, and lands exactly on a sample again so that normal playback stays a bit-exact copy. Test:
a_sound_that_starts_from_silence_is_never_cut(red before: samples missing a second in). A real capture stall costs one gap: the audio that arrives late is dropped where the silence already is.Reverted 2026-09-22. On the Arctis route this ran in a loop: a late packet ran playback dry, the "late" audio was cut, the queue was back below what the jitter needed, the next packet ran dry again. Measured on the installed app with a 30 s tone: 502 cuts, 31 dry seconds, 1343 phase jumps; the user heard it as crackling all evening. The queue now deepens to whatever the jitter needs (that is what the once-a-second easing measures against) and nothing is ever cut; a stall is one gap. Tests:jitter_is_absorbed_by_a_deeper_queue_never_by_cutting,a_capture_stall_is_one_gap_and_the_delay_eases_out.- Discontinuities while a channel wakes are not reported; running dry is only reported for a channel that is still talking when the second is over.
- Audio threads join the Windows "Pro Audio" class (
AvSetMmThreadCharacteristicsW, no dependency). Measured in the installed app: its two audio threads at priority 24, everything else at 8 to 10. Standard practice; no glitch on this PC has been shown to need it.
Measured on hardware (dev engine, Media -> monitor, tone started and stopped three times): the log shows only "easing out N ms", and examples/soak.rs reads 0 level dropouts and 0 phase jumps. That tool was blind before: it played 1 kHz, and a cut of whole milliseconds is whole cycles of 1 kHz. It now plays 1130 Hz and flags a change in how fast the phase moves, so a steady slide (drift, easing) passes and a cut does not. It still skips the first second of a run, which is where the old build's 4 ms cut fell, so the old cut was shown by the log and the unit test, not by this tool.
Verified in the installed app (build of 19:46, 2026-09-21): three audio threads at priority 24; the user's run of tools/glitch-under-load.ps1 (60 s of tone under a from-scratch build) left nothing in the log but "easing out 17 ms" and "7 ms" where the tone began: no glitch, no dry, no cut.
Open: about 19 ms that belong to one channel and are not in our queue. Installed build, settled 6 s before measuring, repeatable to 0.3 ms: Game -> Arctis 48 ms, Media -> Arctis 29 ms. In the morning's build it was the other way round (30 and 51). The engine reports no excess for either channel, so the time is spent outside Feed: not in cpal's capture loop (it drains every packet on each wake), and cpal's capture timestamps are no help (callback and capture time read identical). A dev engine on both channels -> monitor read 37 and 32 ms today against 20 and 21 in the morning, so there is session-to-session variation of the same size too. Likely in how much audio sits in the WASAPI endpoint buffers, which cpal gives no control over (it fills whatever render space is available). This is an argument for the backend below rather than something to chase through cpal.
Low-latency spike, 2026-09-22 (examples/lowlat.rs). Two findings.
IAudioClient3buys nothing here: every endpoint on this PC (fxvad, NVIDIA HDMI, Realtek, the Arctis over USB) reports min = default = max = 10 ms. The drivers don't offer smaller engine periods, andInitializeSharedAudioStreamrefuses the loopback flag anyway (AUDCLNT_E_INVALID_STREAM_FLAG), so loopback capture stays on the plain initialise.- The 10 ms period is not where the latency is. A bare passthrough on raw WASAPI (loopback capture, event-driven render, one thread, a queue capped at two periods, no EQ) measured 7.2 to 8.0 ms added latency Media -> monitor, where the cpal engine reads 20 to 37 ms on the same route (and 29 / 48 ms to the Arctis). 25 s of tone through it: 0 dropouts, 0 phase jumps, 0 dropped frames, 0 dry frames once audio was flowing. The 12 to 40 ms the current engine spends are in how cpal fills the render buffer (whatever is free, and the 22 ms WASAPI buffer is mostly free) and in queues between its two threads.
So the backend is worth building and is simpler than planned: own WASAPI, no IAudioClient3, one render-event-paced thread per session that drains every channel's loopback and mixes straight into the render buffer, with Feed's priming and easing kept (the spike had none and got away with it only because its cap of two periods just drops the excess). Target on the evidence: ~8 ms plus the cushion, the same on every channel, since one thread reads all channels at the same moment. Both endpoints must share the mix format (the spike requires it; the engine's ponytail note about resampling stands).
Native backend, built 2026-09-22 (src/native.rs). WASAPI direct, one thread per session woken by the render event: drains every channel's loopback, channel EQ and volume, mix, output EQ, limiter, render buffer. Same Feed (priming, easing) as the cpal backend, which stays in the tree (FREESERIES_CPAL=1 in the CLI runs it); the app uses the native one. 19 engine tests unchanged. Measured, both channels -> monitor, settled: main 9.4 ms (cpal read 20-37 on this route), 25 s tone 0 dropouts 0 phase jumps, 0 dry. Wake jitter up to 3.4 ms against a 12 ms margin.
Two things found on the way, both outside the backend:
- The Media channel reads ~16-20 ms more than the main one on every backend, including the raw spike with no queue at all (device 0 -> monitor 1-11 ms, device 1 -> monitor 24 ms), while both channels hold the same 7-8 ms leftover in their queues. So it is the second fxvad instance's loopback (or its position stamps that
latency.rsrelies on), not the engine. Unverified beyond that; a microphone measurement would settle whether it is real delay or a stamp offset. - Running
latency.rsright beforesoak.rsleaves the virtual device's loopback slipping for a while: the tone tool alone, with no engine in the path, then shows phase jumps (4, 6, 17 in three runs; 0 in five runs without the preamble). Two afternoons of "the engine glitches" readings had that preamble. Proven by dumping the engine's input and output: the jumps were already in the input. Noted at the top of both tools.
Measured in the installed app on the Arctis, 2026-09-23, and the numbers above are wrong. The loopback-referenced tool flatters the HDMI route by about 25 ms (the output loopback's stamps sit at different points of the device path per device), which is where "9 ms" came from. latency.rs now has a render mode whose reference is the noise itself, stamped with the time cpal's playback clock says each buffer plays (OutputCallbackInfo::timestamp().playback); with a consistent reference the difference between routes is trustworthy even if the absolute stamps aren't. By that reference: noise straight into the monitor 26 ms, straight into the Arctis 41, straight into the FreeSeries virtual device 36 (fxvad's own path is 10 ms slower than a real device). Through FreeSeries: monitor 62-72 (native) and 62-64 (cpal), Arctis 67-81. The bare passthrough with no queue reads 59 to the monitor. So FreeSeries adds about 35 ms on every route with either backend, and about 25 of that is structural: a second pass through the audio engine at 10 ms periods plus the virtual device's own tap; the rest is the 8 ms cushion and the queue. The native backend gained nothing measurable. It stays because it is one thread with no cpal on the audio path, it logs the output buffer state per session, and its tone runs are clean on both routes; the render fill is capped at two periods (a no-op on the devices seen: they hold one period at wake). The 10 ms target in docs/latency-target.md is not reachable with shared-mode WASAPI at 10 ms periods; the honest claim is "about 35 ms, the same as the cost of a second shared-mode pass, and below the headset's own radio link".
Exclusive-mode output, tried 2026-09-23: it removes about 31 ms. examples/lowlat.rs run <from> <to> x opens the output in exclusive mode at the driver's minimum period (the HDMI monitor: 3.33 ms, 16-bit PCM; float is refused in exclusive mode) and self-times every write: the capture stamp of the frame against the render clock's play position for it, the same sum in both modes. Shared: 13.9 ms. Exclusive: -17.2 ms (the fxvad loopback stamp marks its own render position, later than the mix, so absolute values are off; the 31 ms difference is what counts). Nothing dropped, nothing dry, tone into it clean. An external check is impossible: an exclusive stream makes the endpoint refuse every other client, loopback recorders included, so only a microphone or a cable loop can confirm it. What exclusive costs: nothing else can play to that endpoint while FreeSeries runs (by design everything plays into FreeSeries; on Stop and Quit the handback frees it), Windows' own volume, meter and loopback for that endpoint stop working (volume keys keep working: they act on the FreeSeries device, which is the default, before our loopback), and a device whose driver refuses exclusive mode needs the shared path as fallback. Whether to ship it is the owner's call.
What would move it otherwise: IAudioClient3 small periods (none of the drivers here offer them), or an APO instead of a loopback pass (docs/mic.md lists why an APO is the wrong shape for us). A microphone measurement is still the number for the site.
Earlier plan, superseded by the above: our own WASAPI backend on IAudioClient3, which lets shared-mode streams run at the driver's minimum period (often ~3 ms) instead of 10 ms. AudioBackend is already the seam for it. Target: ~10 ms. Whether fxvad and the user's outputs support small periods is unverified.
- Glitches under heavy CPU load. The installed app logged three capture glitches at 12:59 on 2026-09-20 while a Rust build was saturating the CPU, and none in the quiet 75 minutes before. The capture and playback callbacks share a mutex'd queue and run at whatever priority cpal gives them. If this shows up while gaming, the fix is the lock-free ring buffer already flagged in
src/wasapi.rs, plus checking the audio threads register with MMCSS ("Pro Audio").
Read from ten days of the installed app's log (build of 2026-09-22 18:10, native backend) and from the PC.
A click every few minutes: the cushion was smaller than one packet. The log is a steady trickle of playback ran dry 1 times, alone or next to capture glitch, in clusters seconds apart and then quiet for minutes. A per-wake trace of a dev engine shows why. Loopback hands audio over in whole 10 ms packets, and the virtual device's clock slides against the output's, so the moment a packet lands drifts across the moment we wake. At that crossing a wake finds no new packet (and one nearby finds two). With 8 ms in hand and 10 ms needed, that wake is a 2 ms hole. Worse, nothing ever put the cushion back: after one dry moment the trace shows the queue running with 2 ms left over, for good, so the next crossing is an 8 ms hole. examples/wakes.rs ran next to the installed app for 15 minutes: 90 001 wakes on the Arctis and on the monitor, none later than 15 ms, while the app logged dry moments. So it is not late wakes, not USB, not thread starvation.
Fixed in Feed:
CUSHION_MS8 -> 12: one whole period plus 2 ms. Costs 4 ms of delay.- A cushion that got used up is eased back in by playing 0.5 % slower (the same reader that eases delay out, with the sign turned). Logged as
N ms of cushion left: easing it back in: in the next build's log that line should stand whereran dry 1 timesstood. - A channel waking from silence starts at the cushion, no longer at twice it: the same three packets as before, so sounds start no later.
- Test:
a_wake_without_a_packet_is_not_a_gap_and_the_cushion_is_rebuilt.
Capture glitches: the default loopback buffer holds two packets. 1056 frames, 22 ms, on every endpoint (examples/spatial.rs prints it). Three packets are waiting whenever a wake comes a little late at a crossing, and the third is lost. The native backend now asks for 200 ms (honoured: the log line says room for 200 ms of capture); room is not delay. tools/stall.ps1 freezes a dev engine for 60 and 30 ms: before, capture glitch; after, no glitch and no dry moment, only the new the output woke the engine late 1 times ... worst 62 ms line. The glitch line now says how many frames were lost and how late the wake was, so the next log can tell our lateness from Windows' own engine hiccuping.
The big bursts were the PC. 2026-10-01 11:40 (64 + 70 glitches in five seconds) is the minute the machine hung and was reset: Kernel-Power 41, the xHCI incident already in the pc-optimizer notes. Two more unclean shutdowns: 09-24 19:46 and 09-25 17:19.
audio session died: main capture: 0x88890004 four times (three within two minutes on 10-01 21:38): the FreeSeries endpoint was reconfigured under us (format or spatial setting changed). The engine reopens within the same second. Nothing in the Windows logs says who did it. Not chased.
"Sound feels weird": spatial sound is on twice whenever audio plays on the monitor. ISpatialAudioClient::GetMaxDynamicObjectCount is 0 with spatial sound off and 128 with any format on; the format itself is in the endpoint's {8a845654-d6c3-4cd7-b4eb-243d4bd99032},2 property. On this PC: FreeSeries = Dolby Atmos for Headphones (not DTS), FreeSeries Media = off, Arctis = off, Odyssey monitor = DTS Headphone:X, Realtek speakers = Dolby Atmos for Speakers. The engine falls back to the monitor whenever the headset is off (it was on the monitor all evening from 22:20), and there Atmos-for-headphones output goes through DTS Headphone:X again. DeviceInfo.spatial now carries this and the Devices page warns when the FreeSeries device and a chosen output both have it on. Type-checked, not looked at in a browser (the Chrome tools would not attach).
The tone tool lies while the PC is in use. soak measures everything on the output it listens to. Tonight the installed app was itself on the monitor, so every Media -> monitor run measured two engines' copies of the tone beating against each other (levels from -25 to -29 dBFS, hundreds of "dropouts"). And with music on the Media channel the tone dips in the music's rhythm with no engine in the path at all (soak 1 1). Before a run: read the installed app's last engine Running line and render the dev engine somewhere else; trust the engine's own log over the tone when the channel carries live audio. Clean runs tonight, Media -> Arctis endpoint: 30 s, 0 dropouts, 0 phase jumps.
Not done: the installed app still runs the old build. npm run upgrade puts this in.
Route A built: real mic -> RNNoise -> VB-CABLE's input; apps pick CABLE Output. CLI (mics, mic),
examples/miclatency.rs, Tauri commands and a Mic page. Numbers, the cable's registry surprise and
what is left to trim: docs/mic.md, "Step 2 results".