FluidEQ 2.0

Your sound, finally worth watching.

fluideq.com · Download · What's new · Report a bug

FluidEQ is a free, open-source system-wide parametric equalizer for Windows 10 and 11, processed by its own audio engine or by Equalizer APO — your choice. Tune once per output, and the right sound follows the right device without you touching anything again.

New in 2.0

The biggest release FluidEQ has had. The whole list is in the release notes; these are the headlines.

• A new window, in new colours. One slider, Brightness, takes the whole window from near-black to a light ocean blue. With a Plus visualizer on the graph the window can take its colours, glow with it, or let it play behind everything on the Backdrop.
• Every look on your graphics card. The graph's forty looks draw at your screen's own refresh rate, eighteen of them new, and a Plus visualizer can be a real 3D world that steps on the kick and leaps at the drop. Move the mouse across one and it throws sparks, petals or snow.
• Sound exactly as you drew it. On the FluidEQ Engine the treble plays as drawn to 20 kHz, every change and every preset switch crossfades instead of clicking, and Auto normalize lands on a new curve's level in one step.
• Presets that sound like the music. 107 whole chains, 83 of them music styles, measured again and levelled so a switch changes the character and not the volume, each explaining itself beside the list.
• Bass, Mid and Treble, like an amplifier, as a curve of their own, with a low and a high cut either side, and every band left as you set it.
• A graph that reads sound like a studio. Twelve measuring views, the live sound 80 dB deep and down to 10 Hz.
• The Room. Twenty-four rooms that turn headphones into a listening room, every channel a speaker around you — all of them free.
• Every game, its own sound, switched when the game comes to the front and put back when it closes.
• FluidEQ folded into a player: the classic amp, or on the Backdrop a player of glass over the visualizer.
• Make your own visualizer. The Studio turns an idea into a scene that moves with your music, with your own AI assistant; a new account can try it free for fifteen days.
• Ask the guide in your own words, in any of ten languages, and it takes you to the control.

What it does

Follows your output. Every setting below belongs to the device you tuned it on. Plug in your headphones and their tuning comes back; switch to speakers and theirs does. FluidEQ maps the stable Windows endpoint ID, not the display name, so it survives renames and re-plugs. Games can have a sound of their own too: give one a preset under Game presets, and FluidEQ switches to it when the game comes to the front, keeps it until the game is closed, however often you alt-tab, and then puts back what you had.

Seven layers, one chain. Each is written as its own file in the Equalizer APO config, included in this order:

Layer	What it is
Convolution	A measured impulse response applied before anything else — from the AutoEq catalogue or a WAV of your own.
Driver type	Twelve compensation profiles for the kind of transducer you are listening on: dynamic and planar headphones, dynamic, balanced-armature and hybrid IEMs, three diaphragm materials, four sizes.
Headphone correction	A published measurement for your exact model, applied as a layer beside your tuning rather than into it.
Parametric EQ	Your own bands, up to 128 of them. Peak, low/high shelf, low/high pass, band pass and notch, each with frequency, gain and Q.
Tone	Bass, Mid and Treble, turned with no band selected: two shelves and a bell, as a curve of their own that never rewrites your bands.
Preset	The tone of the preset you pick — one of 107 whole DSP chains, 83 of them music styles — as a curve of its own, on either engine.
Smart EQ	What a measurement of your own output asked for, one-shot or continuously maintained.

A low cut and a high cut, either side of the Tone knobs, follow the preamp: they only take away, so no headroom is reserved for them. The treble of every layer plays exactly as drawn up to 20 kHz on the FluidEQ Engine, or built the way Equalizer APO builds it, as you choose in the EQ mode menu.

Any layer can be switched off without being lost. Every one of them has a switch on its chip, and the four curves — driver, headphone, preset and Smart EQ — have a strength from 0 to 100% beside it. Switching one off leaves its file out of the chain and touches nothing it holds, so pressing the switch again puts exactly the same settings back: which is how you find out whether a correction is actually an improvement, the same passage both ways, a second apart. It survives a restart, because a config with an include missing is a truthful config.

Everything active is named on the EQ page, so a bump in the graph is never a mystery — you can see what put it there and remove it in one click.

Start from a measurement. 6,229 headphones and 12,594 published curves ship offline from OPRA, the community directory of headphone EQ profiles, grouped by brand and credited to whoever measured them. For anything not in it, the EQ Presets tab links to Squiglink so you can export its EQ text and import it locally. Published corrections remain their own layer; an external export becomes editable EQ bands with a visible source and curve preview.

Smart EQ. Measures what is actually coming out of your output and flattens what it hears, rather than assuming a target. It subtracts the rest of the chain as it measures, so it corrects the recording and the hardware rather than undoing your own tuning. Continuous EQ is the same measurement as a mode rather than a press: it moves a fraction of the way and measures again, for as long as there is music, so only what every record agrees about survives — which is your headphones and your room. Three of them: Detail corrects peaks and dips, Balance also evens out a bright or warm recording, and Target brings every record to the same tonal balance.

One preamp, computed. Every layer contributes to a single Preamp: line derived from the real combined response, so adding a preset or a convolution cannot clip you — and removing one gives the headroom back.

Computing it from the response alone is a worst case, though: it assumes the music has full-scale energy at the exact frequency where your chain peaks, and real music never does. So auto-normalize — still the one switch it always was — also measures what is actually coming out, and reserves what the programme asks for rather than what the chain could theoretically need. A 6 dB boost at 10 kHz stops costing 6 dB of volume when the music up there is 30 dB down.

The two halves answer questions neither can answer alone. The arithmetic is a proof about what happens inside Equalizer APO, so it holds whatever plays and wherever the volume sits, and it stays underneath as the floor: a cold start, a silent room or a measurement that is wholly wrong behaves exactly like the worst case, never like distortion. The measurement covers what happens after, where Windows applies its own volume and ends the path with a limiter — whether that fires depends on a number the main process cannot compute. A sample-peak supervisor holds the output under −0.3 dBFS, which is the limiter's own documented figure with two tenths of margin. Nothing measured is stored; every launch starts at the worst case and works up. A clip indicator watches where the output really clips, not where the chain theoretically could.

Import what you already have. An Equalizer APO ParametricEQ or GraphicEQ file, a FluidEQ profile, or any WAV impulse response. The Convolution tab also carries the AutoEq catalogue itself, searchable by model or by whoever measured it, so a verified impulse can be fetched and applied without leaving the app.

Send a chain to somebody. A Config tab shows the config the engine has actually got on disk, per output, as the include tree it really is — what each file holds, which layers are on, and any include pointing at nothing. Every output also gets one file FluidEQ never rewrites, for the APO commands that have no interface here. From that tab a whole chain exports to a .fluideq file and imports back onto the output you are listening to.

One transport, at the foot of every tab. It follows whichever of FluidEQ's own players is going — the Library, Karaoke, Online Media — and when none of them is, it shows what the rest of the computer is playing and names it, with play, pause, skip and seek reaching that player instead. Where a loaded page exposes its own Previous, Next, Play and Pause, Online Media uses those rather than guessing. Only one thing plays at a time: starting a song in the Library stops the Karaoke stage, and starting either stops Online Media. It will stop players outside FluidEQ too, if you ask it to. Its volume slider is Windows' own volume, so it sets the level of everything the computer plays.

Shrinks to a player. One switch in the title bar, beside Help, turns the window into the Compact player. It is the classic amp, with its LED clock, its lamps and the whole equaliser — presets, band layouts, EQ mode, Smart EQ, Bass, Mid and Treble — a visualizer, and Up Next, where dropped music files join the Library and the queue. On the Backdrop, over a Plus visualizer, it turns to glass instead: the visualizer edge to edge, the song in large type and the controls in a glass dock. It folds to one line, stays on top of other windows if you ask it to, keeps a Brightness of its own, and the full app, the amp and the glass player each remember their own size and place. Its volume, like the transport's, is the computer's own. The same switch brings the full app back on the page you left.

Watch the sound, however you like to. The graph measures what is playing the way studio analysers do: twelve views, from the Analyzer, a spectrogram and a waterfall to stereo, loudness and phase, the live sound drawn 80 dB deep and down to 10 Hz, a twelfth of an octave per point, on scales that hold still while the music moves. Or it draws the music: forty looks in all, every one on your graphics card at your screen's own refresh rate — terraces, a skyline, LED and neon bars, glass towers, a synthwave road — each one yours to recolour and reshape in a designer that opens on the look you are using. The stereo output meter has ten looks of its own: bar, segments, LEDs, fluid, mercury, needle, pulse, stack, flow and centre.

Plays in two places at once. A second output mirrors what you are hearing to any number of other devices, with a level for each, and nothing to install. Game/Video starts with about 30 ms in reserve and catches up after a hiccup; Music starts with about 100 ms for smoother playback. Actual delay also depends on the devices. On Windows the mirror captures audio before endpoint EQ, so each output applies only its own APO profile. The profile picker below each enabled second output shows that device's saved profiles and applies a selection there without switching the main output. Mirroring runs only while FluidEQ is open. Switching the main output stops the old mirrors before the change.

Plays one headset from every computer on the desk. The Share Audio tab lets your gaming PC, your work laptop and the media box all play into the one headset you are wearing: over your own network, losslessly, encrypted, and through the EQ you already tuned on the computer the headset is plugged into. One computer creates a connection code, the others paste it, and nothing is installed and nothing leaves your network.

Ten languages. English, 简体中文, हिन्दी, Español, Français, Português, Русский, 日本語, Deutsch, Italiano — the most-spoken left-to-right scripts. The installer offers a language too, preselecting your Windows one, and the app does the same on first run. Change it any time from the actions menu. Every label, hint, error and tooltip is translated, and a test fails the build if a locale falls behind English. Right-to-left languages are deliberately absent: the layout has never been mirrored, and a broken Arabic is worse than none.

A guide inside the app. F1 opens a user guide from anywhere, searched the way you would ask a friend — "no sound", "limiter", "wallpaper" — in any of the ten languages, forgiving typos and plurals. The best chapter comes first, and every control on its pictures is numbered like a printed manual, with the one you asked about ringed. The same guide is in docs/USER-GUIDE.md.

Updates itself, from wherever it came from. The build published here checks GitHub for a new version, downloads it in the background and offers to restart. A signed build checks its own address instead and never this repository, since signed installers are not published here. Whichever it is was decided when the build was made and is compiled into it, and each verifies what it downloaded — so an installer that ended up on the wrong side is refused rather than run. A build you made yourself does not update. Being offline is not an error and says nothing. After updating, a What's new tour shows what changed; it is in the Help menu any time.

Reopens where you left it. Size, position and maximized state are remembered. The position is only reused if a display still covers it, so unplugging a second monitor cannot strand the window somewhere you cannot reach it.

Closing the window does not stop it. FluidEQ carries on in the notification area, because a window you tidied away is not a reason to stop equalising the machine. Its tray icon reopens the window, carries a badge when an update is waiting, and its menu installs that update, checks for one, or quits for real. A Windows shutdown, a session logout and the installer all still end it properly. Only one copy runs at a time — two would both write the same Equalizer APO config and spend the session undoing each other.

Plays something to tune against. An Online Media tab opens a small set of music and video sites — YouTube, YouTube Music, Bandcamp, Twitch and Suno — in a window inside the app, so a track can be playing while the spectrum moves underneath it and a band is dragged. It is not a browser: it goes to those sites and nowhere else, and it saves a file only when a site offers one and you choose where it goes.

You can sign in, and it remembers you next time. Its cookies live in a store of its own that no other part of FluidEQ reads, encrypted at rest by Windows the same way any browser profile on the machine is, and one button in its toolbar throws the whole lot away — every cookie, sign-in and cached page — in a single press. Sign-in through a Google account may be refused; Google decides for itself whether it will complete one inside an embedded view, and often will not.

FluidEQ is not affiliated with, endorsed by, or connected to any of those sites. They are opened as they are, in an ordinary Chromium window; the app neither hosts, stores, copies nor redistributes anything from them. Whoever uses it is responsible for keeping to each site's own terms of service.

Play what is already on the machine. A Library tab reads the folders you add — MP3, WAV, OGG, FLAC, M4A, Opus, AAC and more, plus video — and browses them by album, artist, genre, song, folder or video, as a dense sortable list, a grid of covers, or a Cover Flow you sweep through. Folders read either as the tree they actually sit in, which is how you see that thirty of your forty albums live in one place, or as every folder at once, which is the one to use when you would rather find than browse. Everything in a folder appears the moment you add it, titled from the filename and grouped by the folder it sits in; the scan then fills in the real tags, cover art and durations behind it, so a large library is usable while it is still being read rather than blank until it finishes.

Cover art comes from the file's own tags, or a cover.jpg beside it, or a tile drawn from the album's name — nothing is fetched from the internet, and no album name leaves the machine. A track in a format Chromium cannot decode says so rather than failing silently; a folder on a drive that is not plugged in keeps its songs and dims them rather than losing them; and an album that does not account for every file in its folder lists the rest underneath it instead of hiding them.

Playback carries on while you look at any other tab, with a transport at the foot of the window. Songs that come with their own lyrics are left out of the library on purpose — they belong to the Karaoke tab below.

Sing over what you already own. A Karaoke tab turns your own files into a stage. Open a song or add a folder — MP3, WAV, OGG, FLAC or M4A, with lyrics from an .lrc, an enhanced .lrc for word timing, or an UltraStar .txt for syllables and real target notes — and files sharing a name pair themselves into a playlist. The words follow the audio's own clock rather than a timer, so a long song cannot drift away from them. A microphone you pick and switch on yourself draws your pitch live, named as a note and marked high, in tune or low, against the song's target notes where the file genuinely carries them and against nothing invented where it does not. It names the chord under the playhead and the one coming next, collects the places you sang high, low or missed so you can jump back to one and be counted in, and goes full screen with the controls fading out of the way. Nothing is recorded, nothing is sent anywhere, and no music ships with it — the songs are your own, and the instrumental is either one you already have or one the Karaoke Maker splits out of the song itself.

And make the file when the song does not have one. The Karaoke Maker builds one out of a song and nothing else. It can split that song into two tracks first, here on your machine with no service involved: the backing track is the instrumental to sing over, and the isolated voice is what the transcriber and the melody detector read instead of a full mix — reading the words off the audio requires it. Both stems follow the same transport with a level each, save as WAV or MP3, and are kept with the project. It is a model listening to a finished mix rather than the studio's own multitrack, so it gives you a good separation and not a clean one; it takes well under a minute on a machine with a usable GPU, and about six without. The words can be transcribed from the audio or pasted in and kept. The timing is recorded by ear — play the track, mark each line as it begins and ends, then mark individual words where a line needs that detail, nudging any mark earlier or later instead of doing it again. The melody is read off the recording into notes you can hear, split, delete, retune or add to by hand. There is a counted-in preview, undo and redo throughout, and what comes out either goes straight to the player or saves as a project to return to.

Shape the sound with a studio rack. A DSP tab adds a rack of ten stages — Normalizer, Denoise, Exciter, Bass Forge, Equaliser, Bass Punch, Dimension, Room, Maximizer and Master — with a crossfade between Library tracks beside them. The order the sound takes through them is fixed, because it is the order the arithmetic makes sense in; the Room, listed after Dimension, runs just ahead of it. Every stage starts off except the Normalizer, whose True Peak mode only ever turns a hot record down, and every one of them draws what it is actually doing while it works rather than what it was asked to do.

Where it runs depends on the engine. Under the FluidEQ Engine it runs on everything the computer plays, every app through the same chain. Under Equalizer APO it stops at the app's own edge: it applies to tracks played in the Library and changes nothing about Spotify, YouTube or anything else on the machine — that is what the equaliser and its per-output profiles are for, and they are untouched by it. The DSP tab says so at the top of its own page.

Stage	What it does
Normalizer	Measures a Library track whole, then applies one stereo-linked gain before anything colours it, so nothing pumps. Live sound it levels song by song, and remembers the songs it has heard.
Denoise	Finds the noise floor and the mains hum that are really there rather than assuming them, draws the floor it is subtracting while it subtracts it, and repairs clicks without eating percussion.
Exciter	Harmonics that were never in the signal — even orders for body, odd for air — over three bands you place, plus Organic for density and Timing, which sharpens attacks and adds no harmonics at all.
Bass Forge, Bass Punch	Forge synthesises the missing fundamental for speakers that cannot reach it. Punch works on time instead of frequency: the fifteen milliseconds of attack no filter can get at.
Equaliser	Six to thirty-one bands, drawn as the filters actually respond. Serial or parallel, minimum or linear phase, stereo, mid or sides, up to 4× oversampling, dynamic bands, and over a hundred presets.
Room	Surround on headphones: every channel becomes a speaker around your head, heard through a measured head and the walls of a room. Twenty-four rooms to start from, and none of it is part of Plus.
Dimension, Maximizer	A widener that works per band and can never change what a mono listener hears, and a maximizer that raises the level without letting peaks past the ceiling, showing how much it holds down.
Master	A destination rather than a number — Streaming, Podcast, Audiobook, Broadcast, Cinema, CD, Vinyl, Club, Reference — each setting the loudness target and ceiling delivery really uses.

Anything that adds level can hand it back: gain match takes the makeup off again so switching a stage on and off compares the sound rather than the volume, and Isolate on the stages that have it plays only what is being removed or added, which is the only honest way to judge one. A whole rack saves, names and exports as a chain file of its own, distinct from an EQ curve, with per-stage profiles and a crossfade curve you draw beside it.

The chain is C++, the same code wherever it runs: inside Windows' audio service under the FluidEQ Engine, and for the Library in a process of its own, named FluidEQ-DSP so a task list says something, which ends when the app does however the app ended. If that process cannot start, Library playback carries on: under the FluidEQ Engine the engine's rack takes it, and under Equalizer APO it plays unchanged, with every stage visibly disabled and the app saying why — there is no second implementation waiting to drift away from it.

Sit in the Room. The Room turns headphones into a listening room, every channel a speaker standing around you, heard through a measured head and the walls of a room: stereo becomes two speakers in front of you, or fills the room if you ask; a 5.1 film is five speakers and the sub; a 7.1 game the whole ring. Twenty-four rooms to start from — eleven classics and thirteen new ones, each told apart by measurement — under Featured, Classic rooms and your own, and everything a room is made of is on its page: where each speaker stands, how far, its level, the walls, the space and the bass management. A listening test picks the head that puts sounds in front of you, by ear, in five pairs. None of it is part of Plus.

Local, and account-free by default. No cloud, no telemetry, no analytics, no proprietary driver, no virtual audio device. Your audio never leaves the machine, except to another computer of yours when you share it with Share Audio, over your own network and encrypted. Signing in is optional and changes none of that — the equaliser, the rack, the library and the players neither know nor care whether you have. Four downloads are worth naming, because being caught out by one of them later is worse than the download itself: asking the Karaoke Maker to transcribe lyrics fetches a speech-recognition model (about 570 MB where your graphics card can run it, about 1.1 GB where it cannot), asking it to read a melody fetches a 361 MB pitch model, asking it to split a song into voice and backing fetches a 700 MB separation model, and switching on the Denoise stage's voice cleaner fetches an 11 MB model. Each comes down once, on your press rather than at launch, and the Maker lists what is on disk and what is in memory with a button to give the memory back. Your audio is not part of any of those requests — the separation, the transcription, the timing, the melody analysis and the voice cleaning all run on your machine. Pasting the words in skips the first, bringing your own instrumental skips the third, and a song you time by ear fetches nothing at all.

FluidEQ Plus

An optional membership that keeps FluidEQ growing, with a tab of its own. The equaliser, the DSP rack, the Room, the Library, Karaoke and the players stay free, as they always have been; Plus is the visualizers and what is built on them.

• Plus visualizers. Living scenes — mountains under the stars, curtains of aurora, a neon city, real 3D worlds — drawn on your graphics card under your EQ curves, where the bass, the beat and the treble each move something different. A gallery holds FluidEQ's own and the ones members publish, and anyone signed in can try FluidEQ's samples for ten seconds.
• The Studio. Describe a scene, open its folder in your own AI assistant, and every file it saves plays on the Studio's stage at once, beside meters of what the scene hears of your song. A scene you publish is reviewed before it reaches the gallery, and one that is approved earns your next month of Plus. A new account can try the Studio free for fifteen days, with no card and nothing charged when the trial ends.
• Your desktop and your desk. A Plus visualizer can play behind your desktop icons, a different one on every monitor, pausing while windows cover it, while the computer is locked and on battery; and your RGB keyboard, mouse, headset and stand can take its colours and rhythm through Windows Dynamic Lighting and Razer Chroma (in beta).
• A leaderboard of the members who listen most, if you want to be on it.

Paying happens in your browser and the app never sees a card. The terms, under Account in the app, say in plain words what your account and Plus send to FluidEQ's server and what is kept — never your audio, what you play, your EQ or your devices.

The config is the source of truth

FluidEQ used to keep its own copy of the state and write the Equalizer APO config from it. That is backwards whenever anything else touches that config — a hand edit, another tool, an APO reinstall, a restore from backup — because the file is what you are hearing and the app's copy is only what it last believed. On startup the file wins.

This used to be hedged, and the hedge is most of why the config is split into one file per layer. A preset, a driver correction and a Smart EQ curve all reached APO as ordinary Filter N: lines with nothing marking them as layers, so reading a config back would have turned every one of them into hand-placed bands — the pickers reading "none" while the sound was unchanged, and the next edit writing the layers in again on top of their own flattened copies. The only safe answer was to refuse to read anything at all whenever a layer was live.

An Include: naming a file answers the question the text never could. Startup adopts the bands and leaves the layers alone, and it learns which layers you had switched off from which includes are missing. The old refusal is kept exactly where it still applies: a flat config — an older FluidEQ's, a hand-written one, another tool's — attributes nothing, and there nothing is adopted.

Owned by the APO config	Owned by the profile
Bands, preamp, GraphicEQ points, which impulse response is loaded, which layers are switched off	Which preset, which driver profile, which headphone reference, the profile name

Nothing in the second column is audible on its own. Everything in the first column is.

How device switching works

FluidEQ writes one Device: block per assigned output into its own config file, which the chosen engine includes. Because it accumulates every block whose device matches, the block for the output you are listening on is the one that applies. Each block names a file of its own:

# Neutral fallback for every output without an attached profile.
Device: all
Channel: all

# Headphones -> Sony XM5 · Music
Device: {HEADPHONE-ENDPOINT-GUID}
Channel: all
Include: fluideq-device-8f2a1c9b4d70.txt

The device's own file states the impulse response, includes one file per layer in the order APO applies them, and ends with the single computed preamp — and then your own file, which FluidEQ creates once and never writes again:

# Headphones -> Sony XM5 · Music
Convolution: fluideq-convolution-8f2a1c9b4d70.wav
Include: fluideq-8f2a1c9b4d70-driver.txt
Include: fluideq-8f2a1c9b4d70-headphone.txt
Include: fluideq-8f2a1c9b4d70-eq.txt
Include: fluideq-8f2a1c9b4d70-preset.txt
Include: fluideq-8f2a1c9b4d70-smart.txt
Preamp: -6.4 dB
Include: fluideq-8f2a1c9b4d70-custom.txt

A layer that is switched off is an Include: that is not written. The name in the middle is a digest of the Windows endpoint id, so an output's files are findable again rather than accumulating a fresh set every launch.

No virtual output device and no kernel driver.

Audio engine

FluidEQ runs on either of two engines, chosen once during install and changeable any time from the engine card at the top of the actions menu. The FluidEQ Engine is FluidEQ's own audio processing engine: it sits after your sound card's own effects, so the manufacturer's panel and its own effects keep working, and switching to it needs no reboot — one Windows permission prompt while audio catches up. Equalizer APO is the classic third-party engine this project has carried since the start: it runs custom APO commands, Peace and VST plugins, but it takes over your sound card's effects slot and needs a restart after install.

The FluidEQ Engine installs to %ProgramFiles%\FluidEQ Engine and keeps its configuration in %ProgramData%\FluidEQ\engine\config, the file FluidEQ writes and the engine reads back. Windows will not load an unsigned audio effect at all until something clears DisableProtectedAudioDG in the registry — the same switch Equalizer APO has always flipped — so the FluidEQ Engine sets it too, and leaves it set on removal in case another effect on the machine still needs it. It needs Windows 10 version 1803 or later.

Under the FluidEQ Engine, the DSP rack runs for the whole PC rather than only what the Library plays — every app's sound goes through the same chain. Two limits still apply: Denoise's neural voice cleaner still only works on Library tracks, and switching the parametric Equaliser to linear phase adds about 171 ms of delay. The EQ and DSP pages show the delay FluidEQ adds, broken down by the effects that add it, and Game mode, which the Gaming presets turn on, cuts it for aim and for voice chat by giving up whatever is only there for comfort.

EQ mode → Phase offers independent Minimum and Linear processing for Your EQ and Curves with FluidEQ Engine 1.6 or later. Minimum is the default and keeps the original parametric filters. Linear preserves their tuning within a checked tolerance, but adds about 350 ms at 48/96 kHz — once, however many groups are set to it, because they share one filter and one delay — and can ring before sharp transients. If a correction is too narrow for the bounded linear filter, the original filters stay active and the app reports it rather than silently reshaping the correction. Smoothing remains independent. These phase choices apply across the FluidEQ Engine's outputs; they do not change the DSP rack, imported convolution impulses or Equalizer APO. Changing parametric phase while audio plays changes its delay: entering Linear can briefly repeat part of the sound; returning to Minimum can skip ahead. The engine crossfades the handover, but does not time-stretch the music or add permanent delay to Minimum just to hide that change. Switch during a pause when an uninterrupted passage matters.

Your EQ applies only while FluidEQ is running. Closing the window keeps FluidEQ running in the tray, and the EQ with it; Quit from the tray icon turns every output back to flat — the DSP rack included — and the next launch puts your settings back. Shutting down or signing out of Windows does the same. Under the FluidEQ Engine that holds even when FluidEQ is ended from Task Manager or crashes: the engine notices FluidEQ has gone and passes the sound through untouched until it is back. Uninstalling FluidEQ turns its EQ off in both engines, including an Equalizer APO you choose to keep.

To remove the FluidEQ Engine, uninstall FluidEQ — its uninstaller takes the engine out with it. To remove just the engine without uninstalling FluidEQ, run FluidEQ-Engine-Setup.exe uninstall from the resources\native folder inside FluidEQ's install directory.

Getting started

FluidEQ is Windows-only, because both audio engines are.

1. Download the installer from Releases and run it.
2. Choose an engine when asked — the FluidEQ Engine or Equalizer APO, see Audio engine above. Nothing is downloaded and there is no second website to visit; both installers are carried inside FluidEQ's own. Picking Equalizer APO opens its own setup so you can tick every output you want FluidEQ to manage; reboot when it asks. Already have Equalizer APO installed? It is left completely alone.
3. Pick your output at the top right, then tune.

That is the whole setup. Nothing needs saving — every edit attaches itself to the current output automatically. Every output keeps at least one profile, and you only need more if you want several tunings for the same device. Rename one with the pencil on its row.

Windows SmartScreen may hold the installer on first run, and again on an update. Choose More info → Run anyway, or build it yourself from source below.

Known limitations

• SmartScreen warns. On install, and on updates.
• Windows only. Both audio engines are Windows-specific and there is no equivalent to target elsewhere. On other platforms FluidEQ starts with two demonstration endpoints so the UI can be developed, and touches nothing. The native DSP host builds on every platform but only has a real audio backend on Windows, so pnpm build needs Visual Studio 2022 there and the media player, Karaoke and Share Audio are Windows features.
• Traditional Chinese readers get Simplified. Locale matching uses the primary subtag, so zh-TW resolves to zh.
• No right-to-left languages. See above — the layout has not been mirrored.

Where things live

Path	What is in it
src/common/	Pure logic, no Electron: filter maths, the APO text reader and writer, preset and driver profiles, translations, validation.
src/main/	Electron main. flush.ts renders the chain, deviceProfiles.ts lays it out as files and writes them, apoConfigReader.ts reads it back, ipc/ and main.ts own the IPC surface and the live state.
src/renderer/	React. FluidEqContext holds the live EQ, I18nContext holds the language.
native/	The C++ audio engine: dsp-core is the chain itself, dsp-host the executable that runs it in a process of its own, remote-audio-capture the Share Audio capture binary. Built with CMake.
.erb/scripts/	Every build, check, smoke-test and packaging script.
docs/	ARCHITECTURE.md, the generated user guide, design briefs and specs, and dated QA snapshots under docs/qa/.
CHANGELOG.md	The release notes, which the app opens from its What's new tour.
CLAUDE.md	Instructions for coding agents; AGENTS.md points at it.

Supporting the work

Nothing here is tracked. No telemetry, no analytics, and no account is required — signing in is optional, and nothing that shapes the sound is gated behind it.

This is one person's work — mine, Ivan Carmenates Garcia — built with a lot of love and an unreasonable amount of attention to detail. Every panel was drawn by hand and argued over: how the response curve reads at a glance, the way a menu unfolds, what a knob does when you drag it slowly, which words go on a button, whether a chip should truncate its label or its value. Nothing here is a stock component with a theme painted on top. The parts you are not supposed to notice are the parts that took the longest.

If it earned a place in your setup, a contribution funds the time that keeps it maintained and the next ideas out of the same workshop.

buymeacoffee.com/startswest

A one-off tip, no account needed. Click the link, or scan the code with your phone.

Prefer to contribute time? Issues and pull requests are just as welcome — see CONTRIBUTING.md.

There is also a game hidden in that panel. Tap the pet or press space on the beat of whatever you are playing — it reads the real percussion out of your own audio, so it is your music you are playing along to — and share your score as a card when you are proud of it. Rainbow mode, which it used to unlock, is simply a switch in 2.0, on from the start.

Development

Requirements

• Windows 10 or 11
• Node.js 22+ and pnpm
• Visual Studio 2022 with Desktop development with C++
• Equalizer APO, for real system-audio integration

Run it

git clone https://github.com/StartSWest/FluidEQ.git
cd FluidEQ
pnpm install
pnpm dev

pnpm dev compiles the native code first, the FluidEQ Engine included. When the engine is installed on the machine and the build changed it, pnpm dev installs the new build over it — Windows asks for permission, and audio restarts for a few seconds — because Windows only ever runs the installed copy.

Only one FluidEQ runs at a time, development or installed: a second launch hands over to the window already open.

On non-Windows systems FluidEQ exposes two demonstration endpoints, so the UI and the device-assignment flow can be worked on without touching system audio.

Commands

pnpm typecheck
pnpm typecheck:styles
pnpm typecheck:encoding
pnpm lint
pnpm build            # native host first, then main and renderer bundles
pnpm test             # unit tests, then the native smoke tests
pnpm test:cucumber    # not part of pnpm test
pnpm package

Jest refuses to start without a build, so pnpm build always comes before pnpm test.

pnpm package builds an installer into release/build, which is what you want for checking a change end to end on a real machine.

pnpm package:signed builds the signed installer instead. It refuses to run unless its whole configuration is present, so it cannot quietly produce an unsigned one.

pnpm package:release is pnpm package for a release: it also signs release/build/latest.yml with the update feed key, and every installed copy refuses an update whose feed is not signed with a key it trusts (src/main/updateFeedSignature.ts). pnpm package:signed signs the feed too. The key pair is made once with pnpm update-feed-keys, which writes the public half into the source and keeps the private half encrypted for your Windows account, outside the project (%APPDATA%/FluidEQ Release) — never in .env, whose values are public, and signing refuses to run while .env holds one. pnpm update-feed-key copy puts the key on the clipboard, kept out of clipboard history, to store in a password manager; pnpm update-feed-key import brings it onto another machine from the clipboard; pnpm update-feed-key check says whether this machine can sign. Without the key, no installed copy can be updated.

The version lives in both package.json and release/app/package.json and the two must agree, or the artifact is named after the wrong one.

Build-time configuration

Copy .env.example to .env to set the contribution links. Every value in it is inlined into the renderer bundle and is therefore public by construction — the file says so at the top, at length, because that is exactly the kind of thing people get wrong once.

Where this came from

FluidEQ is designed, written and maintained by Ivan Carmenates Garcia. It began as a fork of AQUA, which gave it a foundation: an Electron and React shell, Equalizer APO integration, filter controls, presets and a response graph. That foundation is credited here with thanks.

Roughly a tenth of the source is still theirs, and the rest is new work. What remains is mostly plumbing — a number input, a spinner, part of the IPC scaffold. Everything below was written for FluidEQ, and it is essentially all of what you interact with.

Sound

• Automatic per-output profiles. Tune once and the tuning attaches itself to the Windows endpoint you were listening on, by stable GUID rather than by display name. Switch outputs and the right sound follows, with no save step. This is the idea the whole app is built around.
• Driver-type compensation. Twelve profiles for the kind of transducer you are actually listening on — dynamic and planar headphones, dynamic, balanced-armature and hybrid IEMs, three diaphragm materials and four driver sizes — each its own APO layer with a strength control and its own curve on the graph.
• A headphone correction that is a layer, not your bands. A published measurement for your model is applied beside your own tuning rather than over the top of it, so clearing the EQ does not take it with it and it can be weakened or switched off on its own.
• Presets. 105 whole DSP chains, 81 of them music styles, each measured and levelled so switching changes the character and not the volume. A preset's tone is a layer of its own in the main equaliser, on either engine, written after your bands so your own tuning is never overwritten and taking the preset away restores it exactly.
• Game presets. A sound for each game, switched in the moment the game comes to the front and kept until it is closed, however often you alt-tab, with a Game mode that cuts the delay FluidEQ adds.
• Convolution. Verified minimum-phase impulse responses from the AutoEq catalogue, or any WAV of your own, applied ahead of the parametric stage.
• Smart EQ. Measures what is actually coming out of your output and flattens what it hears, rather than assuming a target curve. It subtracts the rest of the chain as it measures, and Continuous EQ keeps it measured while music plays.
• A file per layer. The chain is a root file, a file per output and a file per layer, so a layer can be switched off by leaving its include out, its origin can be told apart from your own bands when the config is read back, and every output has one file FluidEQ never rewrites.
• A second output. What you are hearing, mirrored to other devices with a level for each, without a routing driver.
• One computed preamp. Every layer contributes to a single Preamp: line derived from the real combined response, so stacking a preset on a convolution cannot clip you and removing one gives the headroom back.
• The APO config as source of truth. FluidEQ reads what is on disk on startup instead of trusting its own copy, so a hand edit or another tool wins rather than being silently overwritten.
• Every APO filter type, not just peak and shelf: low/high pass, band pass and notch, with the pass forms written without the Gain token APO rejects. Up to 128 bands.
• Bass, Mid and Treble across the whole band rack, the way an amplifier has them: each dial moves its own third of the spectrum across every band at once, on top of the shape you set by hand.
• Import of Equalizer APO ParametricEQ and GraphicEQ files, FluidEQ profiles, and WAV impulse responses.
• A guided external import, with a link to Squiglink and a preview of the EQ text you paste or open locally.
• A ten-stage DSP rack, on everything the computer plays under the FluidEQ Engine and on the Library under Equalizer APO, running on a C++ engine of its own: normalisation, denoise, exciter, two bass stages, an equaliser of six to thirty-one bands, width, headphone surround in twenty-four rooms, maximiser and a mastering stage with a delivery target, saved and exchanged as complete racks.

Interface

• A rebuilt UI: a shared design-token layer, a scrolling workspace that stops panels fighting over the window, a response graph with draggable points and a live output curve, and a motion vocabulary that respects prefers-reduced-motion.
• A switch and a strength on every layer, so any of them can be compared against, weakened, or taken out without being taken apart.
• A Config tab showing what the engine has actually got on disk, and export and import of a whole chain as a .fluideq file.
• An Online Media tab with a player for a fixed list of sites, so something can be playing while a band is dragged.
• A Karaoke tab built out of your own files: a playlist paired from audio and lyrics, words that follow the audio's own clock, a live pitch lane drawn against the song's target notes where it has them, a chord guide read out of the backing track, and a full-screen stage.
• A Library tab for the music and video on your own drives, browsed by album, artist, song, folder or video, with one transport at the foot of every tab and only one thing playing at a time.
• A Compact player, the whole app folded into one narrow column — the song and its clock, the equaliser, a visualizer and Up Next — that shrinks to a single line and can stay on top of other windows.
• A live spectrum, a response graph and a real level meter, in three sizes that each remember how you left them, the spectrum drawn as a measuring view or a drawn form and the meter in any of ten looks.
• Ten languages, with a test that fails the build when one falls behind.
• In-app updates and a What's new dialog rendered from the changelog, with a tray icon that keeps the equaliser running when the window is closed.
• Window position and size remembered, and no white flash on launch.
• A small animated companion in the titlebar, because the app should be pleasant to leave open.

The Git history is kept whole, every file that came from the fork still carries its notice, and the licence is unchanged. FluidEQ is neither an official continuation of that project nor endorsed by its maintainers.

Attribution

Parts of FluidEQ derive from AQUA, © 2023 AQUA Dev Team, used under the GPL. Full notices, and what was changed, are in NOTICE.md.

The headphone correction library is OPRA (Open Profiles for Revealing Audio), a project of Roon Labs, used under CC BY-SA 4.0. What ships here is that dataset reshaped for the application to read, under the same licence and with no curve altered; individual curves are credited to their authors — oratory1990, the AutoEq project and Rtings — both in the application and in OPRA-ATTRIBUTION.txt. Maintainers can refresh it with pnpm opra:update and validate the result with pnpm test:opra.

Convolution impulse responses are AutoEq's, credited to Jaakko Pasanen and used under the MIT licence. AutoEq is also the origin of much of the data OPRA redistributes.

The Room's heads derive from the MIT KEMAR measurements — HRTF Measurements of a KEMAR Dummy-Head Microphone, Bill Gardner and Keith Martin, MIT Media Laboratory, 1994. That data is copyright 1994 the MIT Media Laboratory and provided free with no restrictions on use, "provided the authors are cited when the data is used in any research or commercial application" — which this application is, so FluidEQ cites them here, in its About panel and in its third-party notices. What ships is the horizontal ring of the compact set, diffuse-field equalised and resampled by build-room-heads.ts; the terms and what was changed sit beside the data in assets/room/heads/LICENSES.md.

Squiglink is linked as an external calculator, not bundled as a database. Users can export the EQ text there and paste it into FluidEQ; the import keeps the source link and a visible curve preview with the applied EQ.

Equalizer APO is a separate project by Jonas Thedering, licensed GPL-2.0-or-later and therefore compatible with FluidEQ's GPL-3.0. FluidEQ does not link any of its code — it writes the configuration file that APO reads — but the FluidEQ installer bundles APO's own installer and offers to run it, so that getting started never means going off to find a download.

Because that means redistributing APO's binary, every FluidEQ release also publishes the matching EqualizerAPO-src-<version>.zip as a release asset, which is how the GPL's source requirement is met. It is deliberately hosted alongside the installer rather than linked elsewhere. APO's licence text ships in resources/assets/licenses/EqualizerAPO-LICENSE.txt, its installer is bundled unmodified, and the version is pinned and checksum-verified in .erb/scripts/fetch-equalizer-apo.ts. If you bump that version, publish the matching source archive with it.

FluidEQ is not affiliated with or endorsed by Equalizer APO or Jonas Thedering. It is an independent front end that happens to write the configuration file APO reads. If something goes wrong in FluidEQ, please open an issue here rather than on the Equalizer APO tracker — a bug in this app is not his to answer for, and his time is better spent on the engine all of us depend on.

FluidEQ is not affiliated with or endorsed by Dolby Laboratories.

See NOTICE.md for the full derivative-work notice.

User guide

Open Help → User guide in FluidEQ, or press F1, for the searchable offline handbook: 31 practical chapters in six parts, from your first five minutes to FluidEQ Plus, illustrated with 43 real interface captures. Each capture numbers its controls the way a printed manual does, and the list underneath names each one under the same number, with its shortcut where it has one; point at a line and the control is ringed on the capture. Click any capture to enlarge it. Ask the search in your own words: it ranks what it finds, forgives typos and plurals, knows the words people use for things in all ten languages and searches the English guide alongside yours, then takes you to the passage and rings the control it is about. The guide follows the app's selected language and theme.

The same instructions are available as an illustrated, print-ready document and a Markdown user guide. Keep the HTML beside the PNG captures when copying it for offline use. Use its Print / Save as PDF button for a paper or PDF copy. Regenerate both documents with pnpm docs:guide after editing the guide text.

License

FluidEQ is free software under the GNU General Public License v3.0 or later.

Copyright © 2026 Ivan Carmenates Garcia
Portions copyright © 2023 AQUA Dev Team

You may use, study, modify and redistribute this software under the GPL. A distributed modified version must also make its corresponding source available under the same license. This summary is not a substitute for the license text.

Additional term under GPL-3.0 section 7(e)

As section 7(e) of the GNU General Public License version 3 expressly permits, this program is distributed with one additional term:

Rights under trademark law to use the name FluidEQ or the FluidEQ logo are not granted. This term declines to grant those rights. It does not restrict any right the GPL grants, and it does not apply to the source code.

You may redistribute FluidEQ unchanged under its own name, and you may always say truthfully that your work is based on it. Give a modified version you distribute a name and an icon of your own — the branding is centralised in src/common/branding.ts so that this is a one-file change. Section 7 also lets you remove this term from material you convey. The full policy, and what it deliberately does not cover, is in TRADEMARK.md.

Additional permission under GPL-3.0 section 7 — scenes

FluidEQ runs small visualizer programs, called scenes, that its users write for it in the Studio. So that a person's own scene stays theirs to license as they choose, this program is distributed with one additional permission:

Additional permission under GNU GPL version 3 section 7 — scenes. A scene is a program in the OpenGL ES Shading Language written to be run by FluidEQ through its scene contract: the declarations, entry point and wrapper FluidEQ supplies around a function named sceneColour, together with any artwork and metadata distributed with it. As a special exception, the combination of a scene with that contract, when run by FluidEQ, does not require the scene to be licensed under this License; you may license your scene under terms of your choice. This permission does not apply to FluidEQ itself or to any other part of it, and does not permit you to distribute FluidEQ, or a modified version of it, under any licence other than this one.

The scene contract is src/common/sceneUniformContract.ts. A modified version of FluidEQ may keep or remove this permission, as section 7 allows.