AuraEngine

A no-compromise offline audio upsampler for audiophiles.

Precomputed FIR filters, 5k to 30M taps · Hybrid-Phase transient engine · GPU double-single precision convolution · true-peak protection · bit-perfect output verification

The same engine, in your browser — up to 30 million taps, eight tracks at a time, nothing to install.

⬇ Download for Windows

Ready-to-run bundles — the filters are already inside.

AuraEngine takes ordinary 44.1/48 kHz FLAC/WAV/MP3 files and re-renders them offline at up to 768 kHz / 24-bit FLAC, using FIR filters of 5 thousand to 30 million taps whose coefficients are designed in 128-bit precision. Because it is not bound by real-time constraints, it can spend the math your DAC's built-in interpolation filter never could: the DAC then receives an already-reconstructed, oversampled waveform and only has to play it.

Everything the engine does is verifiable by design: the full DSP trace is logged to the console, every output file is re-decoded and compared sample-by-sample against the internal f64 buffer, and files that fail verification are renamed _UNVERIFIED instead of being silently kept.

Highlights

• ⭐ The Hybrid-Phase engine — the signature invention of this project. The track is rendered twice in full (linear phase + minimum phase) and an onset detector switches between the two renders per-attack, stereo-linked, at zero crossings. No pre-ringing ahead of the attacks it fires on, stereo image intact everywhere else — see it animated below.
• Massive FIR upsampling — per-ratio Kaiser filters from 5k to 30M taps (β = 14 from 1M up, fitted to the length at 5k), measured stopband down to −221 dB, designed offline in 128-bit precision and applied in end-to-end f64 with Kahan-compensated summation.
• Adaptive apodizer v3 — source forensics — measures the exact frequency of the ADC/SRC pre-ring baked into a master and places a minimum-phase corrective lowpass just below it; unmasks fake hi-res (upsampled masters, including mirror-image aliasing from bad resamplers) at any container rate; leaves clean and minimum-phase sources untouched.
• GPU acceleration with no precision loss — convolution runs on Vulkan compute in double-single (DS) arithmetic (~48-bit effective mantissa, ~−260 dB residual vs f64), enforced at the SPIR-V level with NoContraction so the driver cannot fold it back to f32.
• True-peak safety — 4× Lanczos-4 intersample peak scan with a −0.5 dBTP ceiling, applied only when needed; quiet material passes bit-exact.
• Honest output — 24-bit TPDF dither (Wannamaker-9 noise shaping at ≤48 kHz), then a bit-perfect re-decode verification of every FLAC.
• No external tools — decoding and FLAC encoding are both pure Rust, and no subprocess is started during a conversion. The encoder streams frames to disk as they fill, so a 90-minute file costs the same peak RAM as a three-minute one.
• It stops rather than substituting — if the filter a setting needs is not on disk, the conversion fails and names the exact file, before it starts. It will not quietly fall back to an ordinary resampler while the interface still says "30M Taps".

The filters are already inside. Unzip, run aura-engine.exe, drop a track on the window. No Python, no Rust, no second download, no folder to create — the app opens on the filter that shipped with it and converts immediately.

These point at the current release. The releases page always has the newest one, whatever this table says.

Every bundle carries both phase types, so Hybrid-Phase works out of the box, and both rate families, so 44.1 and 48 kHz sources convert alike.

What it needs

If nothing happens when you run it, open a command prompt in the folder and run aura-engine.exe --selftest. It prints what the build needs against what your machine has, and writes AuraEngine-crash.txt next to the exe. That file is enough to tell us why — open an issue and attach it. From 1.2.3 the program also says so in a window of its own rather than closing without a word, and where the cure is a download it offers to open it.

Which one? The tap count sets how steep the wall at the cutoff is, and how long the conversion takes. It is a setting with a ceiling, not a quality tier: on the magnitude response there is nothing in thirty million taps that five thousand with a wider window cannot do, and on music a 5k and a 30M render agree below 20 kHz — what differs is the last kilohertz of the CD band (measured). 10M at FS8 is where to start. 5k is the whole app in a few megabytes, 1M carries every multiplier in a download small enough for a phone tether, and 30M is the longest filter the engine designs.

Comparing them is the point. Unzip more than one bundle into the same folder: the filter files merge, one copy of the app serves all of them, and the tap slider then offers every size you have. Convert the same track at 5k and at 30M and listen to what a tap count actually buys.

Every FIR filter forces a trade. Linear phase keeps inter-channel timing perfect — the stereo image stays holographic — but it pre-rings: a faint anticipatory smear arrives before every drum hit. Minimum phase hits perfectly clean, but warps timing across frequencies. The industry's usual answer is a fixed "intermediate-phase" compromise filter — which simply carries a little of both flaws, everywhere, all the time.

Hybrid-Phase refuses the trade. AuraEngine renders the track twice, in full — one complete linear-phase pass and one complete minimum-phase pass — then a native-Rust HPSS transient detector decides, moment by moment, which render you hear: linear phase through sustains and decays (imaging), minimum phase through attacks (zero pre-ringing). The switch itself is engineered to be inaudible:

• fires only at a zero crossing of the mid signal;
• stereo-linked — one switch plan applied to both channels at the same sample, so the image can never skew;
• 1 ms fade on a smooth curve + 20 ms anti-chatter hold;
• both renders aligned sample-exact via band-weighted group delay before blending.

What the detector keys on, precisely. It measures the rise of percussive energy between analysis frames — the start of a sound. It does not measure whether the filter would ring on this material; it knows nothing about the transition band. On music the two coincide, because an attack is both a beginning and a broadband event. On synthetic material they come apart: a steady square wave with arbitrarily steep edges produces no trigger at all, because nothing begins. So the honest name for the stage is minimum phase on attacks, and there is a known blind spot in the first ~24 ms of a file — both are written up, with the numbers, in docs/06-hybrid-phase-proof.md §1.

This technique was invented for AuraEngine. We are not aware of any other converter that does content-aware switching between two complete phase renders — if you know one, open an issue: we would genuinely love to compare notes. The verification methodology is documented in docs/06-hybrid-phase-proof.md.

flowchart TD
    A["Decode<br/><i>Symphonia · f64, no clamp</i>"] --> B["DC block<br/><i>static mean or 2 Hz IIR</i>"]
    B --> D["Apodizer (optional)<br/><i>source forensics: measured ring cutoff ·<br/>fake-hi-res unmasking · min-phase Kaiser</i>"]
    D --> E{Path}
    E -->|Standard| F["Rubato sinc resampler<br/><i>512-tap sinc · ~−180 dB</i>"]
    F --> G["FIR post-filter<br/><i>5k–30M taps · partitioned OLS ·<br/>CPU f64+Kahan or GPU DS</i>"]
    E -->|"Polyphase FIR<br/>(integer ratio)"| H["Polyphase interpolation<br/><i>the filter IS the resampler ·<br/>L sub-filters in parallel</i>"]
    G --> I["Hybrid-Phase (optional)<br/><i>2nd min-phase pass · HPSS onsets ·<br/>stereo-linked zero-crossing switch</i>"]
    H --> I
    I --> J["True-peak limiter<br/><i>4× Lanczos-4 · −0.5 dBTP ceiling</i>"]
    J --> K["Dither<br/><i>24-bit TPDF · Wannamaker-9 ≤48 kHz</i>"]
    K --> L["FLAC encode<br/><i>native · 24-bit · streaming</i>"]
    L --> M["Bit-perfect verification<br/><i>re-decode · compare ±2 LSB</i>"]

Two conversion paths share the same preparation and output stages:

A detailed, beautifully rendered walkthrough of every stage lives at toxadev.github.io/aura-engine (source: docs/index.html), and the same material as plain markdown starts at docs/README.md. The engineering laws the DSP core is audited against are in DSP_MANIFESTO.md.

Only needed if you want to change the engine. To use it, take a bundle — there is nothing to install and nothing to compile.

AuraEngine is developed and tested on Windows 11 (Windows 10 should work but is untested). Linux/macOS are currently not supported — the build uses the MSVC toolchain and a few Win32 APIs for thread priority and timer resolution.

git clone https://github.com/ToxaDev/aura-engine.git
cd aura-engine\desktop-app
start.bat

start.bat compiles the release binary on first run and launches it. Subsequent runs skip cargo entirely when nothing changed (instant start); start.bat --build forces a rebuild, --clean wipes the build cache. No Node.js, no npm, no Tauri CLI — the frontend is static HTML/JS embedded into the binary.

The converter loads pre-computed filter coefficient files (.npy) — it deliberately refuses to synthesize filters at runtime, because runtime generation could not match the 128-bit design precision.

Easiest way: grab a filter pack and extract it into the repo folder. The archives already contain the fir-optimizer/output/ structure, so nothing has to be moved afterwards.

Or generate them yourself:

cd ..\fir-optimizer
pip install -r requirements.txt
python optimize.py --all-ratios

--all-ratios populates fir-optimizer/output/ with the full matrix — 4 tap sizes × 8 output rates × 2 phase types = 64 files, roughly 10 GB, and it can take a while for the 30M presets. It skips files that already exist, so you can interrupt and resume. If you only care about one preset, see fir-optimizer/README.md for generating a subset. Store the blobs anywhere by setting the AURA_FILTER_DIR environment variable to the folder that contains them.

Whatever subset you end up with, the app works out what it has at startup: it opens on the largest tap count it found at FS8, strikes through the slider positions with no blob behind them, and names the download for one you select anyway. tools/make-bundles.ps1 builds the app-plus-filters packages that appear on the release page.

1. Launch the app (start.bat).
2. Set the FS multiplier (FS2–FS16) and filter resolution (5k–30M taps).
3. Optionally switch on Subsonic Filter, Adaptive Apodizer, Polyphase FIR Resampling, Hybrid-Phase Blending (the lit rows under Advanced DSP), or Hardware GPU Acceleration.
4. Drop files onto the window — conversion starts immediately.
5. The output FLAC appears next to the source file, named like:

Track [AE · 44.1k→352.8k · Kaiser 10M · f64 · AA · HP].flac

A ✓ VERIFIED badge means the written FLAC was re-decoded and matched the internal DSP buffer within ±2 LSB. A console window runs alongside the UI on purpose — it is the engine's full audit log (filter resolution, hybrid-phase coverage, true-peak decisions, verification results).

The rack these live in is three zones — Source, Conversion, Output — with the stages in each standing in the order the pipeline runs them. Each stage is described, with measurements, in docs/18 — The Advanced DSP Stages.

Sources at or below 48 kHz get the full treatment. Hi-res containers skip the static apodizing presets, but the Adaptive Apodizer analyzes them too: if a "hi-res" file is really an upsampled 44.1/48 kHz master, the baked-in brickwall is detected and treated against the original Nyquist. Input formats: WAV, FLAC, MP3, OGG, AAC, M4A. Output is always 24-bit FLAC. Files with non-standard rates are rejected (BAD), files already at or above the target are skipped (SKIP).

This project treats sound-quality claims as testable invariants, not marketing. The rules live in DSP_MANIFESTO.md; the mechanics, briefly:

• Unity gain: every filter is DC-normalized (sum(h) == 1.0) at design time; the converter never changes loudness unless true-peak protection has to act.
• f64 everywhere: decode writes f64 directly — integer PCM exactly, and lossy decoders' samples above full scale kept rather than clipped; there is no f32 truncation anywhere in the CPU sample path. The GPU path uses double-single f32 pairs (~48-bit mantissa) specifically because plain f32 would not meet the noise floor.
• Latency-exact alignment: OLS convolver latency (2 blocks CPU, 1 block GPU) and FIR group delay are trimmed analytically — tested by unit tests (cargo test), not tuned by ear.
• Bit-perfect verification: every output file is re-decoded and compared against the DSP buffer. 25 unit tests cover convolver latency, unity gain, polyphase reconstruction, phase alignment, true-peak and dither behaviour.

These are measurements of the actual production filter files — not design-tool renderings. Reproduce them with fir-optimizer/plot_measurements.py; full gallery with methodology in docs/15-measurements.md.

30 million taps ÷ 48 kHz = 10 minutes. Is the filter really that long? No — a tap count here is defined at the output rate, never at the source rate. The 30M blob for 44.1 kHz × 8 runs at 352.8 kHz, so its kernel is 85 s (39 s at 768 kHz), and 99.76 % of its energy lies within ±1 ms of the centre. Full arithmetic, per-rate table and measured tail decay: docs/16-filter-length-and-rate.md.

Why offline instead of real-time? A 30M-tap convolution at 768 kHz cannot run in real time on consumer hardware without cutting corners. Offline rendering removes the deadline, so every stage can use the highest-quality algorithm instead of the fastest one.

Do I really need the GPU? No. The CPU path is the reference implementation (f64, Kahan-compensated). The GPU path exists to make 10M/30M-tap conversions dramatically faster while staying within ~−260 dB of the CPU result — far below audibility.

Why does a console window open with the app? It is the audit log, and it is intentional. AuraEngine's core promise is that you can see what it did to your audio — filter selection, hybrid-phase switch coverage, true-peak action, verification verdicts.

Does it need ffmpeg or any other external tool? No. Since 1.1.0 both decoding and encoding are pure Rust — Symphonia in, flacenc out — and no subprocess is started during a conversion. The one remaining exception is verifying 705.6/768 kHz output: those rates exceed the FLAC specification's own 655350 Hz cap, so no pure-Rust decoder will read them back. Without ffmpeg installed the log says plainly that verification could not run at that rate, instead of marking a good file _UNVERIFIED. See docs/17-flac-encoding.md.

Can it damage loudness or dynamics? No. The engine applies gain in exactly one documented place: the true-peak normaliser, when the reconstructed waveform would exceed the ceiling — −0.5 dBTP, or whatever Headroom names. It never raises a quiet file. Everything else is unity-gain by construction, and the verification step proves the file on disk matches the math.

aura-engine/
├── desktop-app/            # The converter (Tauri app)
│   ├── src/                #   Frontend: static HTML/CSS/JS (no build step)
│   ├── src-tauri/          #   Rust backend
│   │   └── src/audio/      #     DSP core: converter/, gpu/, dsp_core.rs,
│   │                       #     hybrid_phase.rs, hpss_native.rs
│   └── start.bat           #   Build-and-run launcher
├── fir-optimizer/          # Python filter designer (generates .npy blobs)
├── docs/                   # Technical documentation + docs/index.html
├── DSP_MANIFESTO.md        # Engineering laws of the DSP core
└── CHANGELOG.md

PRs are welcome — read CONTRIBUTING.md first, especially the part about the DSP manifesto: changes to the audio path must keep its invariants (unity gain, f64 precision, phase behaviour) and ship with tests. CI runs cargo check + cargo test on Windows.

Built on excellent open-source foundations: Tauri · rustfft · rubato · Symphonia · wgpu · rayon · flacenc · NumPy/SciPy/mpmath.

PolyForm Noncommercial 1.0.0 © 2026 ToxaDev

In plain words: the source is open to read, build, use, modify and share for any noncommercial purpose — personal listening, hobby projects, research, education. Commercial use of any kind requires a separate license from the author — all commercial rights are reserved. If you want to use AuraEngine (or a derivative of it) in a product or service, write to auraengine.dev@gmail.com to discuss commercial licensing.

GitHub has no private messaging, so the address above is the way to reach the author directly.