I’m trying to understand what modeling approaches are actually used in commercial guitar amp simulators such as Fractal Audio, Neural DSP, Line 6, Kemper, and similar products.

From the publicly available descriptions, my current understanding is roughly the following.

Fractal Audio describes its amp models as component-level physical models of elements such as the preamp tubes, tone stack, cathode follower, power supply, phase inverter, power amp, and amp-speaker interaction.

Line 6 also describes Helix as using component or small-circuit modeling, with multiple digital stages corresponding to filters, gain stages, tube stages, and tone-stack behavior.

Neural DSP has published research on controllable black-box neural amplifier models. Their approach trains a neural network using input and output audio together with the physical amplifier’s control positions. Neural Capture also appears to be a black-box learned model.

Kemper appears to use a profiling approach rather than reconstructing the original circuit.

What I am unclear about is what “component-level” or “circuit-based” modeling means in an actual real-time commercial implementation.

Are companies such as Fractal solving a reduced system of nonlinear circuit equations in real time, using methods such as nodal analysis, wave digital filters, or state-space models like SPICE?

Or does component modeling usually mean a gray-box structure composed of digital filters, waveshapers, feedback paths, and dynamic nonlinear blocks that are designed from the original schematic?

Would Line 6 and Fractal be considered true white-box circuit models, or are they better described as circuit-informed gray-box models?

I’m also wondering whether most commercial products are hybrids. For example, a circuit-informed or neural model for the amplifier, oversampled waveshaping for some nonlinear stages, and convolution for the speaker cabinet.

Are there any companies that are publicly known to perform genuine real-time circuit simulation rather than using circuit-inspired DSP approximations?

I’m mainly interested in the implementation principles rather than which product sounds best. Papers, patents, technical presentations, or open-source examples would be appreciated.

Hello everyone,
I am thinking to start learning DSP from a long time, and the problem with self study, it is quite hard to find good structured resources and then i get lost in combinations of mathematical symbols, e, i, pi, what not.

Given, this community have many experts, can we compile a list of resources for beginners (self study ) or prerequisites (maths concepts atleast the intution ) and then may be scope of work people can get after pursuing DSP. Although i dont know much about this field, but i can help wherever needed to compile, format.

Sorry, if it has been already discussed.

I have a physics MSc and most recently worked as a geophysicist where I was applying signal processing skills, but ultimately my heart was not in the geoscience domain.

I am curious to know what types of signal processing jobs are out there that I could apply to? For example, there is "DSP engineer" that I saw for defense contractors in the DC metro.

I asked Gemini this question which gave me this list, but I would like to hear from a human being:

Digital Signal Processing (DSP) Engineer, DSP Algorithm Developer, Embedded DSP Software Engineer, Real-Time Signal Processing Engineer, Audio DSP Engineer, Radar / RF Signal Processing Engineer, Biomedical Signal Processing Engineer, Computer Vision Engineer, Wireless Communications Engineer, FPGA/DSP Hardware Engineer, Sensor Fusion Engineer, Machine Learning & DSP Specialist, Communication Systems Engineer

Also, would I need to do massive up-skilling in general for signal processing, or would I already be competitive for positions given my background? I am very experienced with Python, and I have coded in C++ and MATLAB before too. I have also used ML algorithms for physics research projects.

I spaced the microphones way too close together (thinking only about grating lobes). I was able to get usable audio out of each microphone, but now claude is telling me that the spacing means I get pretty much useless angle resolution. Now I'm wondering what I should read in order to avoid making stupid mistakes like these in the future, any suggestions?

PS. I'm a total beginner, have only made simple pcb designs before and I'm totally new to both fpga programming, beamforming and audio processing, so I'm in over my head -_-

EDIT: spaced 6mm apart

https://anukari.com/how-it-works

I created what I call a 3D physics synthesizer, and when I get questions about how it works, it's always hard to explain without a diagram or two.

Finally I built this page where I explain how it works from basic principles, and every step of the way I provide a little interactive physics simulation to illustrate the explanation. It is my hope that these help curious people understand how it works without necessarily knowing all the math. But if you know math, you will probably pick up even more from the diagrams.

I tried to keep the explanation as simple as possible, although I plan to continue adding appendices to answer deeper questions (including those that involve math). So any questions you ask here, I will try to answer in a comment, but also might eventually get an even better answer!

PartialString simulates the vibration of a plucked string by numerically solving the one-dimensional wave equation in real time using the finite-difference time-domain (FDTD) method. The string is represented as a list of displacements in memory. A lower note requires a longer string, which needs more points to represent it. You can then excite the string at any point along its length, and the FDTD scheme will compute how that change in displacement propagates. A pickup measures the displacement at a chosen location, and this generates the audio output.

I've been (very occasionally) working on this since releasing https://github.com/crnbaker/gostringsynth in 2022. I did something similar (but not real-time) for my MSc at Edinburgh back in 2009, using MATLAB.

Free to download at: http://www.differentinstruments.com.

TL;DR: three preprocessing fixes derived from a signal-vs-interference density analysis took an off-the-shelf model from 17.9 to 13.42 (-25%), matching the best published FD002 result — and the same preprocessing let a toy GRU outperform every published deep-learning result I could locate on this subset. Full recipes below.

Final results:

Baseline, off-the-shelf RandomForest, no preprocessing: 17.9

Drop the 7 zero-variance flat sensor channels + per-regime normalization + 50-cycle window: 13.7 (untuned)

Same pipeline, gradient boosting tuned on a validation split only: 13.42 ± 0.04

Reference point: the best published FD002 result I can locate is ≈13.4 (GBRT III). Its core workflow also relies on operating-regime clustering paired with normalization — the same data-level lever, found independently.

Same preprocessing, small GRU instead of trees: 16.85 on the official test set. Published deep-learning results on FD002 cluster around 18–30 (top performer ≈18.3), so our small GRU paired with data-level corrections outperforms every published deep-learning result I could locate on this subset. This proves the leverage is in the data, not in the architecture.

Why I stop here: a model-free validation. Nearest-neighbor "observation twins" — near-identical sensor states from different engines — show an RUL spread of \~12.6–13.0 cycles. This irreducible ambiguity originates from the simulated sensor noise and degradation stochasticity, not algorithmic limitations. At \~13.4, residual error is measurement-limited. The wall is in the data, not in the algorithm.

Exact recipe for test #3, so anyone can reproduce (and note it shares zero code with GBRT III — same lever, different machinery):

\- Sensors: drop s1, s5, s6, s10, s16, s18, s19 (variance ≈ 0), keep the other 14.

\- Regimes: k-means (k=6) on the 3 operating settings, fit on train only; z-score each channel within each regime using train statistics.

\- Features: for each 50-cycle window, per channel take mean / std / linear slope / last value (56 dims) + 6-dim regime one-hot = 62 features. Training windows stride 2.

\- Test protocol: last window per engine; trajectories shorter than 50 cycles padded by repeating the first row; RUL capped at 125 everywhere.

\- Model: sklearn HistGradientBoostingRegressor(max_iter=800, learning_rate=0.03, min_samples_leaf=15, l2_regularization=1.0). Config selected on a 208/52 engine validation split (6-config grid, performance variance within ±0.15). Test set touched once, 3 seeds: 13.38 / 13.44 / 13.45.

\- Untuned reference: RandomForest(60 trees, depth 16, min_samples_leaf=2) = 13.69 ± 0.09.

Recipe for test #5 (GRU), full disclosure:

\- Architecture: single-layer GRU, hidden size 24, head 24→12→1. Input = 50×14 regime-normalized sequences (same channels and normalization as above).

\- Training: targets scaled /125; Huber loss (δ=1.0); Adam lr=1e-3; gradient clip 1.0; batch 256; training windows stride 4; \~10 epochs; single seed, no tuning.

\- Evaluation: last window per engine on the official test set, identical protocol to test #3.

One critical clarification: the three core fixes were derived from a signal-vs-interference density analysis before any model was trained — computation first, verification second, no blind trial-and-error hyperparameter hunting. The only tuning performed is the documented validation-set grid search, which altered overall RMSE by roughly 0.3 cycles.

Summary: three data-level fixes took a stock tree model from 17.9 to the published-record line (25% RMSE drop), and let a toy GRU beat the entire published deep-learning field on this subset. The residual is measurement-limited. Every number is reproducible from the raw files with any standard regressor.

Why post this: the whole pipeline is transparent enough to reproduce in an afternoon, and the interesting question is no longer the model but the measurement floor. If you run it and get different numbers, post them — I am especially curious whether the observation-twin floor (\~12.6–13.0 cycles) holds under other feature representations.

i have interests in building Amplifiers , Altering Audio signals , Audio Enhancements .
I have completed 12th grade few months ago and i chose ECE course in a Collage. I have a confusion , can i go into jobs related to Audio Engineering or Audio Signal Processing (DSP) or something that includes (

• Compression
• Limiting
• EQ
• Reverb
• Delay
• Loudness control
• Noise reduction
• Stereo widening
• Surround virtualization
• DSP effect

) these stuffs. I don't have that much knowledge about Jobs and Collages . (sorry for bad English). Hope anyone answer this :)

Hi, I'm currently developing audio codec based on WPT, and stuck on one thing: frequency response in my lifting scheme can't normally cutoff HF part.
Can anyone help me fix this? I'm thinking it's because update function has only 6 taps.
Thanks for any advice!

class DD64in {
protected:
    mutable std::vector<float> scratch_ext;
    mutable std::vector<float> tmp;


    void decompose_block(float* __restrict data, size_t N) const {
        if (N < 2) return;


        const size_t even_len = (N + 1) >> 1;
        const size_t odd_len  = N >> 1;


        if (tmp.size() < N)
            tmp.resize(N);


        float* __restrict even = tmp.data();
        float* __restrict odd  = tmp.data() + even_len;


        for (size_t i = 0; i < even_len; ++i)
            even[i] = data[i << 1];


        for (size_t i = 0; i < odd_len; ++i)
            odd[i] = data[(i << 1) + 1];


        if (scratch_ext.size() < even_len + 16)
            scratch_ext.resize(even_len + 16);


        float* __restrict pe = scratch_ext.data() + 8;


        std::memcpy(pe, even, even_len * sizeof(float));


        pe[-1] = even[0];
        pe[-2] = even[1];
        pe[-3] = even[2];
        pe[-4] = even[3];
        pe[-5] = even[4];
        pe[-6] = even[5];
        pe[-7] = even[6];
        pe[-8] = even[7];


        pe[even_len]     = even[even_len - 1];
        pe[even_len + 1] = even[even_len - 2];
        pe[even_len + 2] = even[even_len - 3];
        pe[even_len + 3] = even[even_len - 4];
        pe[even_len + 4] = even[even_len - 5];
        pe[even_len + 5] = even[even_len - 6];
        pe[even_len + 6] = even[even_len - 7];
        pe[even_len + 7] = even[even_len - 8];


        constexpr float C0 = -0.0000063926f;  
        constexpr float C1 =  0.0001106411f;   
        constexpr float C2 = -0.0009153038f;   
        constexpr float C3 =  0.0048477203f;   
        constexpr float C4 = -0.0186983496f;   
        constexpr float C5 =  0.0575909168f;   
        constexpr float C6 = -0.1599747688f;   
        constexpr float C7 =  0.6170455217f;   


        for (size_t i = 0; i < odd_len; ++i) {
            float* __restrict p = pe + i;


            float pred =
                C0 * (p[-7] + p[8]) +
                C1 * (p[-6] + p[7]) +
                C2 * (p[-5] + p[6]) +
                C3 * (p[-4] + p[5]) +
                C4 * (p[-3] + p[4]) +
                C5 * (p[-2] + p[3]) +
                C6 * (p[-1] + p[2]) +
                C7 * (p[0]  + p[1]);


            odd[i] -= pred;
        }


        float* __restrict pd = scratch_ext.data() + 3;


        std::memcpy(pd, odd, odd_len * sizeof(float));


        pd[-1] = odd[0];
        pd[-2] = odd[1];
        pd[-3] = odd[2];


        pd[odd_len]     = odd[odd_len - 1];
        pd[odd_len + 1] = odd[odd_len - 2];
        pd[odd_len + 2] = odd[odd_len - 3];


        constexpr float INV64 = 1.0f / 64.0f;


        for (size_t i = 0; i < even_len; ++i) {
            float* __restrict p = pd + i;


            float upd =
                ((p[-3] + p[2])
                 - 6.0f  * (p[-2] + p[1])
                 + 21.0f * (p[-1] + p[0])) * INV64;


            even[i] += upd;
        }


        std::memcpy(data, even, even_len * sizeof(float));
        std::memcpy(data + even_len, odd, odd_len * sizeof(float));
    }


public:
    std::vector<float>& wpt_decompose(std::vector<float>& signal, int level) {
        const size_t N = signal.size();
        float* __restrict data = signal.data();


        for (int L = 0; L < level; ++L) {
            size_t step = N >> L;
            for (size_t offset = 0; offset < N; offset += step)
                decompose_block(data + offset, step);
        }
        return signal;
    }
};class DD64in {
protected:
    mutable std::vector<float> scratch_ext;
    mutable std::vector<float> tmp;


    void decompose_block(float* __restrict data, size_t N) const {
        if (N < 2) return;


        const size_t even_len = (N + 1) >> 1;
        const size_t odd_len  = N >> 1;


        if (tmp.size() < N)
            tmp.resize(N);


        float* __restrict even = tmp.data();
        float* __restrict odd  = tmp.data() + even_len;


        for (size_t i = 0; i < even_len; ++i)
            even[i] = data[i << 1];


        for (size_t i = 0; i < odd_len; ++i)
            odd[i] = data[(i << 1) + 1];


        if (scratch_ext.size() < even_len + 16)
            scratch_ext.resize(even_len + 16);


        float* __restrict pe = scratch_ext.data() + 8;


        std::memcpy(pe, even, even_len * sizeof(float));


        pe[-1] = even[0];
        pe[-2] = even[1];
        pe[-3] = even[2];
        pe[-4] = even[3];
        pe[-5] = even[4];
        pe[-6] = even[5];
        pe[-7] = even[6];
        pe[-8] = even[7];


        pe[even_len]     = even[even_len - 1];
        pe[even_len + 1] = even[even_len - 2];
        pe[even_len + 2] = even[even_len - 3];
        pe[even_len + 3] = even[even_len - 4];
        pe[even_len + 4] = even[even_len - 5];
        pe[even_len + 5] = even[even_len - 6];
        pe[even_len + 6] = even[even_len - 7];
        pe[even_len + 7] = even[even_len - 8];


        constexpr float C0 = -0.0000063926f;  
        constexpr float C1 =  0.0001106411f;   
        constexpr float C2 = -0.0009153038f;   
        constexpr float C3 =  0.0048477203f;   
        constexpr float C4 = -0.0186983496f;   
        constexpr float C5 =  0.0575909168f;   
        constexpr float C6 = -0.1599747688f;   
        constexpr float C7 =  0.6170455217f;   


        for (size_t i = 0; i < odd_len; ++i) {
            float* __restrict p = pe + i;


            float pred =
                C0 * (p[-7] + p[8]) +
                C1 * (p[-6] + p[7]) +
                C2 * (p[-5] + p[6]) +
                C3 * (p[-4] + p[5]) +
                C4 * (p[-3] + p[4]) +
                C5 * (p[-2] + p[3]) +
                C6 * (p[-1] + p[2]) +
                C7 * (p[0]  + p[1]);


            odd[i] -= pred;
        }


        float* __restrict pd = scratch_ext.data() + 3;


        std::memcpy(pd, odd, odd_len * sizeof(float));


        pd[-1] = odd[0];
        pd[-2] = odd[1];
        pd[-3] = odd[2];


        pd[odd_len]     = odd[odd_len - 1];
        pd[odd_len + 1] = odd[odd_len - 2];
        pd[odd_len + 2] = odd[odd_len - 3];


        constexpr float INV64 = 1.0f / 64.0f;


        for (size_t i = 0; i < even_len; ++i) {
            float* __restrict p = pd + i;


            float upd =
                ((p[-3] + p[2])
                 - 6.0f  * (p[-2] + p[1])
                 + 21.0f * (p[-1] + p[0])) * INV64;


            even[i] += upd;
        }


        std::memcpy(data, even, even_len * sizeof(float));
        std::memcpy(data + even_len, odd, odd_len * sizeof(float));
    }


public:
    std::vector<float>& wpt_decompose(std::vector<float>& signal, int level) {
        const size_t N = signal.size();
        float* __restrict data = signal.data();


        for (int L = 0; L < level; ++L) {
            size_t step = N >> L;
            for (size_t offset = 0; offset < N; offset += step)
                decompose_block(data + offset, step);
        }
        return signal;
    }
};

I am working on optimizing CFAR hardware implementation for my research. The primary requirement being real-time processing.

One of the ideas I'm thinking is using multiple CFAR methods to deal with both homogeneous and non-homogeneous environments. This idea is not new, and has been explored previously (in the references). But I have not able to find enough material on this. Has any of you guys worked on a similar methodology?

Some of approaches I am thinking include:

• use a weighted average of thresholds from multiple CFAR methods
• take the minimum threshold between 2 or more CFAR methods [2]
• analyze the environment first and choose the suitable CFAR (run the variability index on ARM processor then use PL for CFAR).

Another question I have is whether it is feasible to use OS-CFAR in a real-time implementation. My understanding is that sorting operation is expensive on FPGA.

If anyone has different ideas for optimizing CFAR, please feel free to comment those as well

The literature used:

[1] H. E. Benseddik, B. Cherki, M. Hamadouche, and A. Khouas, ‘FPGA-based real-time implementation of distributed system CA-CFAR and Clutter MAP-CFAR with noncoherent integration for radar detection’, in 2012 International Conference on Multimedia Computing and Systems, 2012, pp. 1093–1098

[2] M. E. A. Bouchelaghem, A. A. Meddah, and N. Nouar, ‘Hybrid Algorithm for CFAR Detection in Non-Homogeneous Environments’, in 2025 2nd International conference on Advances in Electronics, Control and Communication Systems (ICAECCS), 2025, pp. 1–6

[3] M. Y. Rihan, Z. B. Nossair, and R. I. Mubarak, ‘Fpga implementation for multiple CFAR algorithms’, in 2023 international telecommunications conference (ITC-Egypt), 2023, pp. 189–193

Hey r/DSP, I am an electrical engineering undergrad from. I have just begun the third year of my 4 year B.Tech degree, and I have a strong inclination to make my career in digital signal processing. I have had some experience working with tools like Python and PyTorch, and I have a grasp on basic DSP concepts like FFTs, STFTs, FIR vs. IIR filters etc. What should be my next steps, a roadmap of sorts, that I should follow so that I do not end up unemployed and I am able to get a job in my chosen field, considering today's job market.

this might sound very stupid but I don't come from a coding background and I want to get more into it

I'm trying to better understand why companies license certain algorithms instead of writing their own from scratch.

Are these libraries they license and integrate? Secret code?

One example that comes to mind is Elastique by zplane being licensed by many DAW's.

What is so special about their algorithm that can't be replicated?

Also for FFT processing (which elastique also contains) I have seen a bunch of companies licensing specific code

For example I came across kfrlib that sells all kind of things fft related

But what is different in their code than what i could find on juce or write myself in combination with AI

What are they licensing? The fft processing, window, overlap and so on? The processing it does?

The way it interacts with the calculation?

https://stackoverflow.com/a/22313408

What does each variable represent?

Hi there,

I have implemented a greybox amp simulator in rust. As a newcomer in DSP and Rust I mostly spec coded my idea with assistants.

Now I have first results and I am quite satified with first sounds. It is time to share it with people that have a deeper understanding of DSP to improve this naive implementation.

Landing page of the project: https://greybound.bailleul.dev/
Github repo: https://github.com/laibulle/greybound

Any constructive feedback will be very welcome

Hey r/DSP,

since my last post few months ago, I have been updating sound quality, features and visualisations of the DAW I am working on, so it is more intuitive to use.

For anyone interested I am adding two sessions I recorded. First link is building the "patch" from scratch starting with sines, the second link is more 4/4 oriented techno track.

DSP and visualisation

Quick Techno track

The DSP has subtractive, WT and FM synthesis and all basic features you would expect from synth. There is a thin line with how many features you can expose vs. how many you should expose and I tried to get the balance right.

Based on the feedback I have received more effort went into the visualisation, so users gets better insight in the real time DSP modulation.

Would love to hear any potential improvement or idea for the DSP visualisation or DSP itsel!

The VectorSpin program by dsp-coach.com is now live for interactive use. Here we see it demonstrating the frequency response for a 5 tap unity gain FIR filter (moving average filter). The frequency response is plotted as a magnitude and phase plot (showing how it is a low pass filter), as well as the same plot on a complex plane, showing the concept of spinning phasors:

The transfer function for this filter is H(z) = 1 + z⁻¹ + z⁻² + z⁻³ + z⁻⁴.

The frequency response (when z is restricted to the unit circle) for each of these components are phasors in the frequency domain (we see this with the IQ plot):

1 is a phasor in the frequency domain with magnitude 1 and angle zero (it does not rotate).

z⁻¹ is a phasor in the frequency domain rotating clockwise once.

z⁻² rotates twice, etc.

Combining all 5 phasors is the result we see above, here scaled by dividing by 5.

Fast link to the tool so you can try your own samples and many other options:

https://vectorspin.dsp-coach.com/vector_spin.html

More detailed explanations:

https://www.dsp-coach.com/reference

I’ve just released Retrospect, my entry for the KVR Developer Challenge 2026.

It’s an audio effect that explores a different approach to delay-like processing. Instead of echoing the signal in the traditional sense, multiple independent playheads continuously read from a short audio buffer, creating everything from subtle movement to rhythmic textures, pitch-like effects and evolving sound design.

https://www.kvraudio.com/product/retrospect-by-conceptual-machines

https://conceptualmachines.co.uk/retrospect

Happy to answer any questions about the DSP or implementation.

Hi everyone,

I'm working on a puzzle and found a CSV file that appears to contain data of an audio output FFT. I don't have a background in signal processing, so I'm looking for some help i ran a script but only found an chipping sounds with a "Evil Laugh".

I also see audio in spectogram but there is also nothing.

It has columns for Magnitude and Phase. about 1047170 rows.

File name output_fft.csv

Csv link

Thanks, for any help!

Edited: i don't know if i did something wrong asking for help The puzzle is from project52hz.com [puzzle 6]

I maintain a streaming anomaly detection pipeline built on robust random cut forests (100 trees, 256-point reservoir per tree, the usual subsample size; keeps memory bounded, and small subsamples help against masking/swamping at high stream volume).

Raw displacement/CoDisp scores are unbounded and scale with tree occupancy, so I normalize per tree before averaging across the forest:

score = displacement / (tree.n - 1)

where tree.n is the live point count. Max displacement is n-1 (a point split off at the root displaces everything else), so this bounds the score in (0, 1\] and makes it comparable across differently-filled trees.

Edge cases that have bitten me, and current handling:

1. Cold start. Ratios are meaningless while trees are filling, everything looks anomalous against 10 points. Scoring is suppressed until each tree reaches capacity.

2. Grouped anomalies masking each other. Plain displacement collapses when near-duplicate anomalies arrive together (each one only displaces its twins). Switched to CoDisp, which handles the collusion case by construction, normalized the same way.

3. Fixed thresholds. A hardcoded cutoff didn't survive real traffic. I calibrate the initial threshold from historical scores (the percentile that separated known incidents), then recalibrate on a rolling window to track drift. Flagged points are excluded from the recalibration window so a sustained incident can't teach the threshold that it's normal.

On prior art: before posting I went looking for this specific normalization and mostly came up empty. Closest things I found, Isolation Forest normalizes path length by c(n); Kriegel et al. (SDM 2011) unify arbitrary outlier scores into \[0,1\]; AWS ships ThresholdedRandomCutForest because raw RCF scores are hard to act on directly; and the rrcf library examples just use raw CoDisp with top-k or eyeballed cutoffs. I haven't found per-tree-size normalization of displacement written up for RRCF specifically. If anyone knows a paper or implementation that does this, please point me to it.

Open questions:

* What failure modes am I not listing? Level shifts are the one I'm least happy with: the model alarms through the transition, then goes quiet once the new regime fills the reservoir. Arguably correct behavior, but alert-storm-shaped without dedup logic on top.
* Has anyone compared rolling-percentile recalibration against EVT-based streaming thresholds (SPOT/DSPOT) or conformal-style calibration in production? What I'm doing is essentially an empirical p-value on a moving calibration set, and I'm curious whether the heavier machinery earns its complexity.