r/AudioProgramming

Since march I've been mixing two passions: guitar (and home studio) and tech. I asked: why not make something to solve a pain I've personally had with Audio on Linux? And also to train my rust skills?

So here, Its: Finally I'm feeling confident to show it out (even though in early beta stage).

Hope It may be useful for you all.

* NeuralAmpModeler-rs https://github.com/fabiohl/NeuralAmpModeler-rs is a crate that implements a high-performance Neural Amp Modeler (see https://www.neuralampmodeler.com/ ) library written in pure Rust. It provides the core engine for loading, building, and executing NAM models. You all can "cargo add" it right now, if you think it may be useful. I really strived to foster high end performance, full compliance with LTSM and Wavenet (A1 and A2) and a clean architecture. All of those statements backed by benchmarks and tests.

* NAM-Plug https://github.com/fabiohl/NAM-Plug is a CLAP (an open source and better alternative for VST3 standar) plugin implementing NeuralAmpModeler-rs you can use in your favorite DAW.

* NAM-Audio-Pipe https://github.com/fabiohl/NAM-Audio-Pipe is a standalone PipeWire host application for Neural Amp Modeler (NAM) simulation on Linux

When you hear an instrument, you can tell it's a piano, a violin, a drum — even if they're all playing the exact same pitch. We call that difference "timbre." But it made me wonder: can you actually explain what timbre is, physically?

In school you probably learned that pitch comes from frequency — how many times the air vibrates per second. But since the same pitch can have different timbres, frequency clearly isn't the answer.

If you've messed with synthesizers, you might guess it's waveform shape — sawtooth vs. square vs. pulse. That's closer, but still not quite right either: waveforms that look completely different can sound identical.

I dug into this and wrote it up (free, no signup) with interactive audio demos so you can test it on your own ears.
Link: https://sciencemusic.pages.dev/timbre/

This post was created using AI assistance (mainly translation).

I’m a live sound engineer, mandalas and cymatics always fascinated me.

I was happy to put this project together,

you can put an audio file in or use mic, it will start to generate the patterns, you can use the menu for editing a bunch of parameters, similar to a visual synth.

Free to use ! Lmk what you think , here’s the link:

Cymaticwizard.com

I plan to keep working on it, expect regular updates!

A long time ago I had posted a multi effects plugin I was working on to gather feedback and it is finally ready to go, either download it from Kofi or go to wavfinaudio.com and find the plugin there (which will bring you to Kofi anyways.

https://ko-fi.com/s/b47e1619e2

For now it is windows only (next update will have a Mac version, just had to get my hands on one)

If you run into any issues or have any feedback please leave it here or go to wavfinaudio.com, scroll down and submit your request there.

Modules it has now (always open to feedback for additional modules or changes to existing modules)

Dattorro Reverb (Hall, Room, Plate)
Tape Delay with wow & flutter
Chorus, Phaser, Flanger & Autopan
Saturation (Soft, Hard, Tape, Tube & more)
Lofi, Bitcrusher & Autofilter
Amp/Cab simulation
Utility master section (gain, width, bass mono, phase)
Features:

Fully reorderable 12-slot effect rack
Built-in presets & custom preset saving
Clean, modern UI with theme support

All updates will go through Kofi so make sure to check your purchases, I will be updating over the next few days based on Feedback.

With love,
WAVFin Audio.

The goal was to create something minimal, stylized and fun.  I have more than 15 years experience as a dev, but this project allowed me to deep dive into a number of audio coding challenges that I had only touched on in other projects.

Here a few things I had to wrestle with.  Hopefully this pass along is useful to others.

^((Oh and the app is free to download, btw.  Link at bottom).) 

Sample-accurate playback under load takes work.

A sequencer has to fire hits at exact sample positions.  Seems simple enough, but everything about the platform conspires against you.  Audio playback renders in chunks (buffers) and timestamps live in two clock domains (sample time for the sequencer, host time for the player nodes).  Where this starts to get thorny is when the user is adding or editing the grid in real-time.  I found myself battling flams, jitter, and clipped transients.

The solution was setting the app's clock as an AVAudioSourceNode that outputs nothing but silence; its render callback just increments a monotonic frame counter every IO cycle, and that counter is the single "now" for the entire app.  A producer thread plans a 12 ms rolling window of events from a snapshot of the grid, so live edits never race the audio thread. 

On the render side, sample time is converted to host time for the player nodes and, most importantly, *both clock reads happen inside a single render cycle*, so they can't straddle an IO boundary and smear the timing.  Employing the above meant the sequencer stays sample-accurate even while the grid is being rapidly reshaped by the user mid-playback.

Touch screens lie about when you touch them! This totally kills 'feel' when playing live.

Tap the screen and hear a sound?  Piece of cake, just wire up a button action and you're good to go. If it were only this easy. 

The issue is that UITouch events do not arrive at constant, predictable times. Delivery is influenced by main thread congestion, processor speed, thermals, etc. One touch might reach the audio engine in 10ms while the next takes 100ms. This creates a real issue where live play feels wrong, because hits land randomly early or late against the timing of your actual taps.  

The fix: every hit is scheduled at a small fixed delay from the touch's hardware timestamp (which is rock steady) rather than played whenever the event finally arrives. Your hands adapt to a steady delay very quickly, the same way a pianist adapts to a piano.  This subjectively feels much better than trying to adapt to random jitter. 

The method: calibrate the delay to the user's actual device empirically. The app measures your specific iPad over your first couple hundred taps, picks the smallest delay that makes things steady, and locks it in as a constant. 

Every user's device ends up with the lowest real-time latency that also effectively removes the jitter.  You can play a rapid fire snare roll and hear every hit land in sequence rather than random flaming.

Your export path must match your live playback path. 

This might sound obvious, but during development it's easy to let these two paths quietly diverge until you realize pan controls or some FX knob didn't actually migrate to the export path, and now your WAV file sounds slightly different than what's happening in the app. From the user's perspective this is a massive fail and they'll never fully trust your product going forward. 

Solution: parity between live and export becomes a test target. Live playback and offline export build from the same FX list and execute the same render code (a new parameter physically can't be wired to one path and not the other), and most importantly, *a WAV-hash regression suite pins it.* Any structural refactor must produce byte-identical renders. This keeps you honest while building.

Download Vaporwave Beats for free:   https://apps.apple.com/us/app/vaporwave-beats-drum-machine/id6786917390

The website:  www.rarefyaudio.com

I've been building a small web instrument called Puntone, and it's designed with touchscreens — iPad and similar tablets especially — in mind.

The core idea: most instruments make you choose between precise pitches (keyboard, frets) or continuous glide (theremin, fretless strings, pitch bend). Puntone tries to keep both — and the part I'm most excited about is that this works for full chords, not just single notes.

Instead of just bending one note theremin-style, you can glide an entire chord voicing into another with your finger — the whole chord slides as one continuous motion, like theremin-ing a chord shape instead of a single pitch. There's a dedicated chord-glide / dual-pad mode built around touch: one pad handles the root note's glide, the other morphs the voicing on top of it. It feels much more natural on a touchscreen than with a mouse.

Other things it does:

• Runs entirely in the browser (Web Audio API) — no install, no account
• Single-note mode also has full-time portamento (the "one-note theremin" experience), playable with a PC keyboard too if you don't have a tablet
• Adjustable glide time / decay in a settings panel
• Built-in recording, so you can layer takes
• No ads, no signup wall

It's a solo project and still evolving. I'd love feedback from people who actually write chord progressions — does gliding a whole chord feel musically useful, or does it read as gimmicky? That's the thing I most want to know.

Try it here: https://puntone-synth.pages.dev/

(Best on a tablet like iPad — touch is the primary input. Also works with Chrome/Edge on desktop via keyboard.)

I have been working on AI Track Inspector 2.3, an experimental offline application that estimates whether a finished track contains acoustic patterns commonly associated with AI-generated music.

This is not intended to prove authorship or identify a generator with certainty. The output is a calibrated classifier estimate accompanied by temporal coverage, model agreement and reliability information.

How it works

The audio is converted to a normalized 16 kHz mono analysis signal and divided into overlapping four-second windows with a one-second hop.

Each window is evaluated by several branches:

• A spectral “fakeprint” branch looking at frequency-domain texture, high-frequency structure, spectral flatness, roll-off, transient behaviour and related statistics.
• A log-mel convolutional neural network trained on time-frequency representations.
• A rhythm branch measuring beat-grid consistency and local timing behaviour.
• A fusion stage combining the branches while accounting for disagreement and out-of-distribution input.

The application then produces:

• An AI-likeness classifier estimate.
• A separate timeline showing where AI-like acoustic patterns were detected.
• Temporal coverage across the track.
• Reliability and branch-agreement information.
• An ambiguous verdict when the analytical branches strongly disagree.
• PDF and JSON reports.

The training and evaluation material included Suno and Udio tracks, mastered and pitch-shifted AI examples, commercially produced real music, demos, semi-live recordings and difficult human-made negative examples.

One important change was removing absolute or unusual BPM as independent AI evidence. Speed-ups, half-time/double-time interpretations and unreliable tempo tracking produced too many misleading results. BPM is now hidden when the beat grid is uncertain and rhythm can only contribute when supported by the other branches.

Implementation

The macOS version is built with SwiftUI, AVFoundation, Accelerate/vDSP and Core ML. The Windows version uses a local Edge/Chromium audio runtime with the same model weights and fusion logic. All processing happens on the user’s computer; audio is not uploaded to a server.

The detector is designed for complete tracks and final mixes, not isolated stems. Stem-level results can be misleading because their spectral and temporal distributions differ substantially from full arrangements.

I am particularly interested in feedback about:

• Codec and resampling robustness.
• Cross-platform decoder differences.
• Better out-of-distribution detection.
• Hard-negative dataset design.
• How uncertainty should be presented without turning a model score into a false claim of certainty.

The current builds are available here: https://www.dropbox.com/scl/fo/bo5dd9t04f818jc8uos44/AOp5_gUP0L6uc63o0nNXcRs?rlkey=9i817ml9fh7mkk0y6ebxaoq8v&dl=0

It is a free experimental project, and I would appreciate technical criticism, difficult test cases and ideas for improving the validation methodology.

Hey guys,

I’ve spent a pretty ridiculous amount of time building an Android music production app called Skunk Audio, and I’m finally getting it ready for Google Play.

It’s basically an offline mobile DAW/beatmaker with a step sequencer, pads and sample chopping, synths, classic instruments, piano rolls, arrangement, automation, mixer buses, effects, recording, beatbox/humming conversion, WAV and MIDI export and other stuff.

I now need at least 12 Android users for Google’s mandatory closed-testing period. I don’t just want people to install it and forget it, though. I would genuinely like producers and musicians to mess with it, make a pattern or small project and tell me what feels broken, confusing or slow.

Testing on different phones is especially useful. Xiaomi/Redmi devices, older or lower-powered phones and Bluetooth or USB MIDI setups would help me a lot because audio apps can behave very differently across Android devices.

The app works offline and doesn’t require an account. Your projects and recordings stay on your phone unless you choose to export or share them.

To join:

Join the testing group:

https://groups.google.com/u/2/g/skunk-audio-testers

Opt into the closed test:

https://play.google.com/apps/testing/org.skunkaudio.app

Install it through Google Play and remain opted in for at least 14 days.

If you test it, please let me know your phone model, Android version and what happened—especially if you notice crackling, stuttering, crashes, silent tracks, touch problems or anything inconsistent between playback and export.

I know asking people to test an unfinished music app is a lot, so honestly, thank you to anyone willing to give it a proper go. I want to release something genuinely good, not throw another half-working beatmaker onto the Play Store.

Thank you for your time!

Hi! I'm working on Audion, an interpreted programming language with bpm synced threads for creative coding in music that can control supercollider, hardware instruments, midi, lighting rigs or anything else you can think of. It is general purpose so you don't have to wrestle with it to do database queries, parse a file or do network requests. Most recent addition is three-d with common widgets so tweaking things is much easier and you can now draw with low level access. It is already possible to make audiovisual art with Audion and breaking changes are not expected. I will probably be making a YouTube channel for it soon.

Audion is interpreted so iterations are fast, the syntax is nothing new (C-like), the object model is very simple. I personally find it very enjoyable to hack with. It is a WIP and collaboration and suggestions are very welcome, hope someone may find it interesting and/or useful.

Github: https://github.com/audion-lang/audion

Soundcloud: https://soundcloud.com/audion-75565851

I am fresh in the area of of microcontrollers.

Although I have started it previous year but never did it continuously,

Recently I have built a project an offline bluetooth based audio transferer( if this name makes any sense). I have explained it here : https://www.youtube.com/watch?v=TobbYyqOm7s

Guys can you feedback me regarding it (like what should i do better) and what should I try to do next....

Appreciate it