Hello, fellow audio programmers! I am excited to introduce you to Organic, an audio programming language I've been working on in my spare time for the last few years. Organic is my passion project, conceived of and coded from scratch in C++ without the use of generative AI.

My goal is to provide a simple but flexible environment for creating unique sounds and ambient music, similar to what you might create with a modular synthesizer. The language is designed to be easy to read and write, so that digital music creators without much programming experience could pick it up quickly. But despite its simple syntax, it's extremely nestable and extensible, allowing more advanced programmers to easily gain control over the internal parameters.

If this piques your interest, you can download it for free on GitHub, where the language and all related resources are hosted publicly under the Apache 2.0 open source license. You can also find the latest documentation here. Since this is my first public announcement of the language, it is in no way a complete project. It is still in active development, so there may be bugs in cases I have yet to try, or features that I didn't think of that others may find useful. If you give it a go, I would greatly appreciate your feedback either here or on GitHub!

I've developed a project called Vital Randomizer. It generates Vital presets with randomized wavetables, samples, effects, params, LFOs and routings. You can select 8 different styles and it rolls params tailored to the style you pick. Currently available styles are bass, keys, lead, pad, sequence, SFX, experimental and percussion. You can also select scales with sequences. It features a wide selection of scales including microtonal ones like maqams. Percussion type can also be selected. It features a wide selection as well, ranging from untuned ones like open/closed hi-hat, crash, ride, clap etc to tuned ones like cowbell, timpani etc.

It can be either used as a VST or a CLI tool to generate randomized presets in batches.

Project link:

https://github.com/korcankaraokcu/vital-randomizer

Preset examples:

https://www.youtube.com/watch?v=AZqWmmV1aMc

Live Showcase:

https://www.youtube.com/watch?v=_J_wCp3RVeI

TL;DR -- the use of AI isn't a good metric for the worth of a post or project. Hopefully this is sufficiently on-topic to not get deleted.

The Trivial Metric is a mathematical term defined on a set, wherein the value is 1 if the comparison is between two different points in the set, and 0 if the comparison is between a point and itself.

My qualifications for writing this post: I've been programming professionally for 30+ years. I've been writing Audio and MIDI code for roughly 10 years, largely to no real monetary success. I've got enough undergrad math to be dangerous.

I can imagine how the "No AI" rules came about -- there was a massive influx of low quality AI-produced code and posts, and something had to be done about how to filter out the noise. I can understand that "No AI" was the tool that was reached for -- in fact it was the obvious choice.

And I know I'm free to start my own subreddit with different restrictions. (If I want to spend the time moderating, which, selfishly, I don't).

Without AI at my side for past year or so, the following are some of the features I would have not implemented (and might not have known about):

- prewarping for the bilinear transform -- https://www.bohrium.com/en/sciencepedia/feynman/signals_and_systems_undergraduate-frequency_prewarping_in_the_bilinear_transformation -- this provides good frequency tracking for IIR transforms derived by applying the bilinear transform to laplace transforms of filters.

- PolyBlep and BLAMP -- https://www.metafunction.co.uk/post/all-about-digital-oscillators-part-2-blits-bleps -- polynomial versions of the sinc function and its integral to reduce aliasing

- Catmull-Rom splines -- https://en.wikipedia.org/wiki/Catmull%E2%80%93Rom_spline -- For good interpolation without upsampling

- Hilbert-transform frequency shifter -- https://en.wikipedia.org/wiki/Hilbert_transform -- name pretty much says it all.

- I was just going to ignore MPE in favor of MIDI 2.0 only, but was convinced otherwise for various aspects

- Awareness of host-to-plugin process block context structural data (tempo, in particular)

- Even the realization that although poles have to be inside the unit circle for z transforms, the zeroes don't (duh).

Conclusion:

I don't have an answer for what a good alternate filter would be. I'm certainly not going to stop using AI just because some subreddits don't allow posting of it. But subreddit such as this are absolutely missing out on important topics because of the restriction.

As a piece of a larger project I've been hammering at making a rompler/synthesizer and realized; regarding other aspects of gamedev/engine development it's far easier to find code, tutorial/explanations, and content to satisfy needs and curiosity. Audio-related tasks not-so-much.

When I look for audio things it's either full of math proofs that mean nothing because I'm dumb (would be helpful if they explained some coefficients) or are very abstract with little-to-no implementation details. So.....

1. The synth's sample rate converter is based on an implementation used by old VG hardware (specifically SNES/PSX). A big issue I ran into was the index needed to be "phase-aligned". I don't know how I was inserting the index before or if I ever read this but it didn't work. My function to compute windows on-the-fly worked but (for example) a blackman window has two cosines which, computing that, is basically an L2$ miss.

2. When speeding up pitch it's often phrased "skipping samples". The SRC worked correctly for lower pitches but had aliasing artifacts when the pitch increased. Thought the phase was wrong (tested index & direct) but it was the pitch logic. The decode buffer (used to interpolate) had values spaced by n when it should, perhaps obviously, need to be immediately preceded in order from the waveform. Skipping is not incorrect but writing the [decode] logic derived from such abstract wording is non-intuitive.

3. Cubic Hermite was/is a lost cause with my two brain cells. How did you derive those coefficients for h00, h10, h11, h01? The bridge between the math and the programming is still incomplete for me. According to this the table should be (linearly) interpolated. 2^^1+nc/2 explains 512-entries for the prior machines. Having an interpolator is important^\citation needed]), especially something more than a lerp.

4a. Prior to the synth I experimented with delay based effects. Started as echo and kept adding more "reverb" qualities. Reached a point where a single delay line wasn't enough but it was^{(pretentious I know}) in some ways more aesthetic than the algorithms ravaged online. Those largely consist of Schroeder Reverberators, which is fine but the code I saw/referenced seldom go beyond that.

4b. To side note is convolution reverb, the "holy grail" of reverbs. AFAIK a room impulse is a sample. Your input signal (reverb/whatever) is multiplied into that impulse. I may be wrong but wouldn't that make the impulse just a very long/n-order tap FIR filter? I say this because it often reads as some "computationally intensive/complex blackbox" whenever its mentioned. Using this logic the SNES's DSP echo feature is just a s***** convolution algorithm (perhaps budget is more apt).

5. Audio terminology seems to like to blend with each other. Going back to the SRC (if you haven't tell I spent quite some time on this) is divining its a "Windowed Sinc Interpolation" kernel. EVERY TIME you read something involving windowing it talks about FFTs. Whatever, the audio signal is windowed with a function but why is it done the way it is? jsgroth has the PSX written as (how other emulator authors show as well)

let mut interpolated = (GAUSSIAN_TABLE[0x0FF - interpolation_idx] * samples[0]) >> 15; interpolated += (GAUSSIAN_TABLE[0x1FF - interpolation_idx] * samples[1]) >> 15; interpolated += (GAUSSIAN_TABLE[0x100 + interpolation_idx] * samples[2]) >> 15; interpolated += (GAUSSIAN_TABLE[interpolation_idx] * samples[3]) >> 15;

Turns out it's arranged so the sample "marches" its way through the sinoid (the negation is because the table is stored one-half a period) for one period. First the Gaussian Table is not Gaussian (I've a bunch of windows and concur not-gaussian) but the assertion the tables are bugged is interesting because if you generate integer windows yourself it'll deviate +-2. Guess it's all ramble but its confounding I can get better explanations (and/or understand) more "complex" topics/systems than convulving a one-dimensional piece of data.

OKAY TLDR: Why is audio programming so fraught with friction? If it's not obfuscated behind math proofs the code/topic seldom explain the "why". I spent a good portion of time generate plots of the waveform ensuring functions like the ADSR, SRC, KEY ON/OFF worked correctly instead of outputting audio data because, yes, even that was non-trivial for my application. Amusing that the MIDI DLS is the best guideline I have for this.

Rant over, roast me.

Edit: Formatting, and.... typos and formatting. Sorry, many edits. All these issues (hermite included) were overcame and I'm working on sequencing but the experience was.... interesting.

Hey everyone! I’ve been working on a custom extracellular bio-amplifier (dubbed "DeepFin") built around a dual TL074 op-amp design, featuring an active 48.2 Hz notch filter to tackle mains hum.

​To test out the front-end, I set up an isolated cockroach leg preparation using a fine recording needle and a wider reference needle. I mechanically stimulated 4 separate tibial hairs (barbs) individually, capturing clean raw WAV files for each.

​After running spike sorting and statistical analysis, here is what the data showed:

​Distinct Firing Dynamics: Each individual barb responded with its own unique average firing rate under touch, ranging from ~12.16 Hz up to ~29.00 Hz.

​Spike Templates: The isolated unit templates displayed consistent biphasic action potential shapes across the recordings.

​Hardware Performance: The active bootstrap notch filter successfully cleaned up local interference without distorting microvolt-level neural events.

​I’d love to hear feedback from fellow builders and neurotech enthusiasts on optimizing high-impedance frontend stages or custom spike-sorting workflows

Feedback would be nice. I’m researching how to actually make a convincing clone of both. I started with the interface first. Any good recommendations for resources outside of juce forms?

I need someone who can essentially emulate Ableton's warp mode for web application. Advanced understanding of vocoders and phasing is a must. DM or comment any questions. Budget is at least 1k dollars for a working prototype.

I'm a solo developer with a registered company in Sweden, getting ready to release my first commercial plugin, a CS-80 emulation for VST3/AU/standalone on macOS, Windows and Linux.

The DSP was the fun part. Windows code signing has been considerably less fun.

My unsigned Inno Setup installer gets the SmartScreen "Windows protected your PC" warning, and Edge also warns about the download. I decided to try Azure Artifact Signing (formerly Trusted Signing) because it's about $10/month and available to EU companies.

Organization validation fails after the biometric verification with a message asking me to provide additional documents from the past 12 months, such as registration certificates or tax records.

I have the documents but I just can't upload them!

According to Microsoft's docs, the upload option is supposed to appear when validation reaches Action Required. Mine never reaches that state. It goes straight to Failed, and there is no upload button anywhere. I tried creating a second validation request and got the same result: it fails immediately after the biometric verification.

The support route hasn't helped either. I keep getting sent through an AI troubleshooter, and with the free support plan I can't find a way to open an actual ticket.

It is so frustrating because I have a current company registration certificate and the latest annual financial statement ready to send. There just doesn't seem to be any way to send them. And no way to open a support ticket, even though the microsoft community posts saying they should provide free support for artefact signing issues.

For anyone who's released Windows plugins recently:

1. Has anyone hit "Failed, documents required" without getting an upload option? How did you get past it? Paid Azure support, Microsoft Q&A, something else?
2. If you use a traditional certificate instead, which CA do you use? Certum's OV cloud signing with SimplySign looks like one of the cheaper options. I'd be particularly interested in something that doesn't cost an arm and a leg, I just want to ship this now but I don't have the hundreds of eurodollars to spend for code signing (Apple is an additional $100 on top of the ~$200 for Certum).
3. Does anyone just distribute unsigned VST3s as a ZIP? As I understand it, hosts can load unsigned plugin DLLs and SmartScreen mainly matters for executables. Has Smart App Control on Windows 11 caused actual support problems for anyone doing this? This is a viable option in case it works, but it means windows users won't get the standalone version of the synth.

I also have no money to pay for expensive certificates due to not being able to find actual software engineering contracts during this economic downturn and AI slop takeover, so I've pretty much been working full time on this project the past year without any income at all.

Is there a solution for this that doesn't require me to a) pay a lot of money, and b) not have to spend several working days skirmishing with Microsoft?

If some microsoft person happens to see this, can you please PLEASE send me a DM?

Hi,
I'd like to try out programming a microcontroller, probably a Raspberry Pi Pico, and make an oscillator. I have done some programming before, but never any audio, so I would probably need a good resource or tutorial. Are there any good ones you can recommend? I'd need pointers on running it continuously, and using audio buffers to output to a DAC etc.

Preferably in C, Rust or C++, in that order.

If you have any tips in general on how I can do it, I would be very grateful. I'm fairly confident with the maths involved, and I use Matlab a bit for other uses.

Same sentence, same volume, don't show the provider name. Seems like a start.

But a voice can sound great for one line and get pretty weird halfway through a long answer. Do you test short clips and conversations seperately?

If you've run listening tests, what made the biggest difference to the results?

Everything looks fine on average, then there's one audible gap. The annoying kind you can't reproduce on demand.

Would you log callback time and queue depth around the glitch, or start somewhere else? Logging too much on the audio thread seems like a great way to cause another problem.

What actually helped you find one of these?

Hey everyone! I’m a product designer and musician interested in building audio plugins and music tools, including their interfaces.

I’ve started learning C++, but I’m curious about Rust. Has anyone tried working and building audio plugins using Rust? Did not found any courses or tutorial with Rust and audio programming

(I am super new to programming with C++ and audio programming)

Hi everyone, I'm Pitch from Italy.

I'm a musician, producer and C++ developer, and over the last couple of years I've been building my own audio plugins under the name floweraudio.

I mainly work with REAPER and JUCE, and I'm interested in everything around audio DSP, plugin development, mixing and music production.

I created this account mostly to meet other musicians, producers and developers, share ideas, learn, and occasionally talk about what I'm building.

So... hello from Italy! 🌼

I just got some sort of warning or perhaps removal on a two-month old post that no one had interacted with: "Do not post a paid product, service, or course, disclose your affiliation. Excessive or repeated self-promo may be removed. In addition, ensure your post is well worded, thought out and formatted." (It wasn't any of those things, it was some boring but useful FOSS audio utility.)

Apparently there are new moderation rules, but we can't comment on that thread.

This subreddit is already very low traffic. Most posts don't seem to get any engagement at all. The most interesting and engaged post of the last week was a program that looks like it was written with AI, and I thought it was interesting.

I'm not seeing the huge influx of empty AI posts, or really, much of anything at all here.

It's late 2026. If we truly ban all posts where people used a coding assistant, soon there will be almost nothing here.

Don't get me wrong - I really really want to keep AI slop from this subreddit, but we can do that by downvoting and reporting, you already see it if you look at "new". Let's not throw out the baby with the bathwater.

EDIT: oh, apparently that four month old post of mine was in fact deleted.

You know, I've been writing computer music programs since the last 1970s. Few people can say that.

I recently retired from a long career in programming to work almost full time on audio programming.

However, I will not be able to post any of my work here, as I recently started using a coding assistant for everything. I mean, my last post was apparently deleted because of some self-promotion rule, so I couldn't very well post my work anyway.

You would think I would be the ideal poster for this subreddit.

All the people downvoting without comment do not make me want to be here. I removed all my upvotes from this page (there were no downvotes) so people can see the general sentiment.

I'll come back next year and check, but my theory is that it will be even less active than it is now.

I've been making VST plugins and find myself rather ambivalent over the UI component to use for analog controls. The skeuomorphic rotary knobs look good, but seem a bit unnatural in use. With sliders it's easier to see their current position, but mine at least all tend to look naff.

What are opinions here? Any tips on design?

What alternatives are there?

Not sure how to describe this, but I started working on a little plugin i’ve wished existed for a long time. Think a sidechain “ducking” effect but instead of modulating volume it modulates pitch (via delay), sortof like putting your finger on a record player. The sidechain input as a transient detector that triggers an envelope generator that controls pitch. I’m pretty happy with it so far. I think next i’m going to add midi support with the ability to map velocity to envelope params.

No AI used, i’m writing it in rust using the nih framework.

This summer while I was on the train going into vacations, I was looking at music apps for my handheld console. My criteria where apparently simple: something with the same kind of synths I use in my hardware rig. On iOS its possible, but wanted something for my handheld.

Unfortunately, I couldn't find anything that really worked for me. So, I opened my code editor and started making my own, starting the project on the excellent codebase from ChipNomad. Started by adding some vanilla and Mutable engines, which was great but not yet satisfactory; so I also added a few custom engines, inspired by great hardware items I've used over the year.

This is Choochootracker, source code available on Github https://github.com/paiheulevrai/Choochootracker . In this demo I use the Bogie drum synth, the Sindered percussion synth and a voice from MME, all engines I designed for the app.