Changelog
From v1.0 to native v1.13
Every public release of Reverie, with the technical detail behind each step. The first release went live on March 24, 2026. Today, two and a half months later, we are shipping the first fully native version of the Reverie Engine.
v1.13.0
The Native ReleaseLatestTwo and a half months after our first public release, the Reverie Engine is no longer running through a JavaScript shell. The DSP has been rebuilt as native code on macOS and Windows, and the architecture that drives it has been retuned for long-form ambient work. Under a strict pipeline-parity benchmark, depending on the style, the same 5-minute render runs anywhere from 1.05 to 5.2 times faster, with two to four times less peak memory across the board. The toolbox is also much deeper: the new Custom Chain Builder exposes the full set of 37 DSP modules and lets you arrange them yourself, where 1.0 only offered curated styles.
From Paulstretch to Dreamtime
Our extreme time-stretch module gets a name of its own. Dreamtime is our evolution of Paul Nasca's 2006 Paulstretch algorithm with six engineering signatures: spectral drift, stochastic multi-segment extraction, phase continuity blending, adaptive segmentation, engine-level duration correction, and seeded phase RNG. The result: live evolving soundscapes, not frozen drones.
Reverie Engine, now native
The DSP pipeline was rewritten end to end in native code on macOS and Windows. Up to 5x faster wall-clock on a 5-min render, 2 to 4x less peak memory across all styles, and no IPC bridge between the UI and the engine.
Custom Chain Builder
Assemble your own effect chain from the full set of 37 DSP modules. Reorder, tweak parameters, save chains as personal presets. v1.0 only offered curated styles, with no way to compose your own pipeline. Full undo and redo history.
Five new Pro presets
Deteriorating Memories, Harmonic Healing, Forest Breathing, DNA Splice and Ancient Chant join the factory roster. Two new styles, Chimera (spectral DNA fusion) and Sacred (ritual drones), back the last two.
Inside the engine
What makes the Reverie Engine ours
Architecture choices that survive the rewrite, baked into both native builds.
USeed (Universal Seed)
A portable Base62 code that captures the full chain: 64-bit engine seed, module indices, every parameter value, stereo spread, with CRC-8 integrity. One code is enough to reproduce a render bit for bit on any machine, in any mode. The displayed USeed is truncated to 16 characters for readability; the full string is preserved internally.
Per-module RNG isolation
Each module receives its own deterministic sub-seed derived from hash(main_seed, module_name, chain_position). Tweaking one effect never silently shifts the random parameters of another.
Inter-module soft limiting
A tanh curve sits between every module to prevent resonance buildup on long chains. Transparent below threshold, audible only when the chain would otherwise clip.
Long-form LUFS normalization
Loudness is measured on a 60-second window in the middle of the file (-16 LUFS, +3 dBFS headroom). Adapted to homogeneous drones, lighter on memory than full-file measurement.
Three-layer preset system
Module defaults, then style overrides, then factory preset overrides. Recipes never have to mutate a module to fix a single preset, which keeps every other style intact.
DSP highlights
What changed under the hood, module by module
The Python build of 1.0 and the native build of 1.13 share the same algorithms. These are the nine modules where the rewrite brought a measurable change in either sound quality, numerical stability, or speed.
dreamtimeSix engineering signatures beyond PaulstretchReverie's extreme time-stretch module, now shipped as Dreamtime, is a custom evolution of Paul Nasca's 2006 Paulstretch. Six differences from the baseline: (1) Spectral Drift – read head wanders through the source following three sinusoids at golden-ratio frequencies, drift plus-minus 30%, where the original reads linearly, keeping hour-long renders alive. (2) Stochastic Multi-Segment – for sources over 3 seconds, 2 to 4 non-contiguous micro-segments are extracted and crossfaded, with silent-zone detection and retry, instead of a single contiguous segment. (3) Phase Continuity Blending – 70% new random phase plus 30% previous with shortest-arc wrapping, reducing the grainy digital artefacts of per-frame random while keeping the drone character. (4) Adaptive Segmentation – segment duration auto-scales from 40-70% of the source for short inputs down to 20-40% for longer ones, always guaranteeing at least 40 FFT frames. (5) Duration Correction Loop – engine-level post-chain orchestration with pre-loop, re-stretch and 3.5s sigmoid fades to hit the target duration exactly, where the original is single-pass. (6) Seeded Phase RNG – MT19937 isolated from segment selection RNG, letting you lock the drone texture while varying upstream modules. Net effect: same spectral magic, with the motion, robustness and reproducibility needed for production work.
spectral_freezePer-bin Perlin drift, decoupled phase seedCaptures multiple phase snapshots and interpolates them slowly. v1.0 jittered each FFT bin with plain random noise; 1.13 replaces it with deterministic 1D Perlin noise (3-octave fbm), so long-form freezes evolve smoothly instead of shimmering. The phase seed is also decoupled from the texture seed so you can vary one without disturbing the other.
temporal_evolutionNative IIR filtering, no more handcrafted FIRSlow macro envelopes (30 to 300 seconds) sweep brightness, cutoff and amplitude to fight drone fatigue. v1.0 reimplemented the filtering with handcrafted scipy windows; 1.13 uses native Butterworth IIR filters, more stable numerically and significantly cheaper per sample.
Benchmark
Measured, not estimated
30-minute ambient render, strict pipeline parity on both versions: identical source file, identical preset and parameters, identical mastering chain end to end. Two scenarios because the two main time-stretch families (paulstretch and spectral_freeze) stress different parts of the engine and gain differently from the native rewrite.
Dreamtime chain (Dark style)
Chain: Dreamtime, lowpass, spectral_blur, reverb, breathing. Stresses time-stretch FFT batching and the IIR filter path.
| Metric | v1.0 (Python) | v1.13 (native) | Delta |
|---|---|---|---|
| Wall-clock time | 39.08 s | 21.87 s | 1.79x faster |
| Peak resident memory | 5.10 GB | 1.75 GB | 2.91x less |
| User CPU time | 35.01 s | 38.40 s | native runs work across cores in parallel* |
| Cycles retired | 146.8 G | 143.4 G | similar work, much shorter wall time |
| Output WAV duration | 1800.3 s | 1800.0 s | identical |
Spectral freeze chain (Spectral style)
Chain: lowpass, spectral_freeze, spectral_blur, shimmer_reverb, stereo_width. Spectral-domain heavy, dominated by STFT/FFT across the chain.
| Metric | v1.0 (Python) | v1.13 (native) | Delta |
|---|---|---|---|
| Wall-clock time | 29.56 s | 24.56 s | 1.20x faster |
| Peak resident memory | 5.17 GB | 2.79 GB | 1.85x less |
| User CPU time | 29.67 s | 45.98 s | native runs work across cores in parallel* |
| Cycles retired | 117.8 G | 170.6 G | native does more work in parallel, finishes sooner |
| Output WAV duration | 1781.1 s | 1800.0 s | within v1.0 internal 5% target tolerance |
* User CPU time is the cumulative work across all cores. The native build is higher because it runs effects in parallel across multiple cores; what you actually wait for as a user is wall-clock time.
Sweep across 8 styles, 5-minute renders
Same source, same parameters, same mastering chain. Only the style changes. Ordered by wall-clock speedup. Spectral-dominated styles gain less because the FFT path is already efficient in scipy; chains heavy in time-stretch and modulation gain the most from the native rewrite.
| Style | v1.0 wall | v1.13 wall | Speedup | v1.0 RAM | v1.13 RAM | RAM saved |
|---|---|---|---|---|---|---|
| Crystalline | 35.86 s | 6.90 s | 5.20x | 4.41 GB | 1.36 GB | 3.24x |
| Bright | 26.55 s | 5.49 s | 4.84x | 4.24 GB | 1.14 GB | 3.72x |
| Cloud | 14.14 s | 6.26 s | 2.26x | 4.08 GB | 1.14 GB | 3.58x |
| Dark | 11.63 s | 6.36 s | 1.83x | 4.61 GB | 1.13 GB | 4.08x |
| Warm | 10.31 s | 6.79 s | 1.52x | 3.22 GB | 1.45 GB | 2.22x |
| Deep Drone | 10.42 s | 7.25 s | 1.44x | 3.19 GB | 1.45 GB | 2.20x |
| Vintage | 13.72 s | 10.13 s | 1.35x | 3.62 GB | 1.42 GB | 2.55x |
| Spectral | 5.91 s | 5.62 s | 1.05x | 2.63 GB | 0.91 GB | 2.89x |
Test conditions
- ·Hardware: MacBook Air, Apple M3, 8 cores (4 performance + 4 efficiency), 16 GB unified memory, macOS 26.3.1
- ·Source: 238 s stereo 48 kHz PCM 16 input (electronica)
- ·Parameters: chaos 70, brightness -50, stretch 35, target 30 min, seed 42
- ·Mastering chain identical on both versions: DC removal at 5 Hz, multiband resonance taming, brightness-aware high-shelf, soft tanh limiter at 0.95, LUFS normalization to -14 LUFS with -1 dBFS true-peak ceiling, LR2 stereo bass mono crossover at 200 Hz
- ·Output: stereo 48 kHz WAV PCM 24-bit, around 494 MB per render
- ·Measured with /usr/bin/time -l, file load included in the timing
Single-run numbers. v1.13 was measured against the macOS-native Reverie engine, the exact code that ships inside the macOS app. v1.0 was measured against the legacy Python build, with the LR2 stereo bass mono crossover backported into its mastering pipeline so that both versions run the same mastering chain end to end. The bench harness on the native side is a dev-only tool, disabled by default and never bundled with the shipped app.
Performance
- •Engine compiled with AVX2 and FMA on Windows for 256-bit SIMD float operations
- •Native Apple Silicon and Intel binaries on macOS
- •SIMD-vectorized FFT replaces the Python scipy path on the heaviest spectral modules
- •O(n log n) FFT convolution on reverb and shimmer paths
- •Native Butterworth IIR filters in place of handcrafted scipy filters on temporal_evolution and similar modules
- •Single-pass in-place processing on modulation modules (breathing, micro_drift), better cache behavior on long renders
- •Double-precision phase accumulators on every LFO, fixing float drift that the Python build accumulated past 6 minutes at 48 kHz
Added
- •Custom Chain Builder (Pro mode): full set of 37 DSP modules now user-selectable, replacing the curated-styles-only workflow of 1.0
- •Five new factory presets: Deteriorating Memories, Harmonic Healing, Forest Breathing, DNA Splice, Ancient Chant
- •Multi-format export: WAV, FLAC, OGG, AIFF in 16 or 24-bit
- •USeed (Universal Seed): Base62 code that captures the full chain, modules, parameters and stereo spread for byte-identical reproduction on any machine
- •Phase seed parameter on Dreamtime for stable base texture across upstream changes
- •Undo and redo on the entire session
- •Multi-select drag and drop
- •Native file drag and drop
- •Icon picker for custom presets
Improved
- •Pixel-perfect native UI on both macOS and Windows
- •Faster startup, no JavaScript runtime to warm up
- •Tighter audio scheduling, no IPC latency between UI and engine
Fixed
- •A class of bridge-related bugs from the 1.0 stack disappeared with the native rewrite
Compatibility
macOS and Windows. Same licenses as 1.0, no re-purchase needed. Output duration unchanged: 30 minutes on Pro, 3 minutes on Free.
v1.0.0
The First ReleaseThe first public release of Reverie. The Reverie Engine ran in Python (NumPy and SciPy DSP) inside a hybrid desktop shell, with a curated style-based workflow. Everything you hear in 1.13 starts here.
Added
- •Reverie Engine in Python, hybrid desktop application on macOS
- •Style-based generation: pick a curated style or roll the random one, then hit generate
- •15 factory presets for the Pro tier, 5 Lite presets in the free tier
- •Up to 100x stretch ratio
- •Pro tier export up to 30 minutes, Free tier capped at 3 minutes
- •WAV export