r/musicprogramming

Learning project that became my favourite: a chiptune synth written entirely in x86-64 assembly (Linux, NASM). No libc, no audio library — just computing raw 16-bit samples and writing a WAV header by hand.

The premise is that sound is just a list of numbers (44100/second) describing where a speaker sits. So the whole synth is: generate the numbers, write them out.

It does four oscillators (square/saw/triangle + LFSR noise), polyphony by mixing voices into one buffer, ADSR envelopes, and FM synthesis with a hand-built sine table. Working on effects next (vibrato, delay, reverb).

github.com/whispem/asm.fm

Feedback on the low-level details welcome — especially the fixed-point math in the FM operator.

I built Afterdark Studio 0.8.0-rc.1 Limited Beta for emerging rappers working with one computer and one microphone. It runs locally in a browser and includes two DJ decks, beat sequencing/piano roll, microphone recording, vocal-production tools, LUFS/true-peak metering, and synthetic acoustic rooms. No account, cloud AI, or API key is required.

Ready-to-test source and setup: https://github.com/seemorecodez/afterdark-studio

Current automated evidence: 111 tests passing and 646/646 interactive controls covered in the Edge UI audit. Honest limits: this is not yet a professional DAW or autonomous DJ; perceptual vocal features are experimental; the isolated drill pack remains disabled after failing its creative gate.

I would value hands-on reports covering: first-run setup, beat quality, microphone/recording workflow, DJ transitions, crashes, audio glitches, and performance. Please include OS, browser, audio interface, and reproducible steps. I am the project creator and am requesting critique, not stars or sales.

I'm a high school student who is developing a free plugin!

A few weeks ago you probably saw that I posted about COGG, a free plugin I built that metallizes and industrializes any sound. Specifically, harmonic distortion, metal plate convolution reverb, and pitch layering are there all in one chain.

I just shipped v1.1 with 8 factory presets so you can dial in different metallic textures instantly instead of tweaking all the knobs from scratch. Everything is there, from subtle texture (like the preset RUST), to full chaos (like presets SHRAPNEL and MELTDOWN).

Still free, no account needed, VST3 + AU for Mac, VST3 for Windows.

Download now for free: https://plasma-hype.itch.io/cogg

Trailer/demo of the update: https://www.youtube.com/watch?v=HfD2drnrMjQ

Thanks to everyone who tried v1.0 and gave feedback, this update came directly from figuring out what people actually wanted to do with it. I personally have used COGG in almost all of my FL projects ever since I released it. Please give it a shot and let me know what you think of the presets and plugin as a whole for a v1.2!

Hey everyone! I've been working on a fun new music toy that lets you create music with physics. The game is simple. Just draw vines and bounce little "dewdrops" off them. Each vine has a unique sound. You can even add FX or create your own vines that you can share with others. And that's just the Sandbox mode! There is also a puzzle mode, where each level introduces something new to teach you the mechanics of the game while you solve and create beautiful music.

If you're interested, check it out on Steam!
https://store.steampowered.com/app/4163480/Dewdrop/

I posted my chorus plugin here a couple weeks ago and someone told me allpass interpolation was the wrong tool for a modulated delay, since the recursive state goes stale while the delay length is moving under it, and that I should look at Lagrange. I was still on linear at that point. So I wrote a 4-tap cubic Lagrange interpolator by hand instead of pulling in a crate, mostly because I wanted to understand it rather than trust it.

What's actually in the thing now, so nobody has to guess from the post:

- 6 ms base delay with the LFO modulating around it, cubic Lagrange on the fractional read. Taps at -1, 0, 1, 2 off the integer index, each one wrapping the ring buffer separately.
- One-pole highpass at 160 Hz sitting inside the feedback loop so the low end doesn't stack up.
- One-pole lowpass on the wet path, cutoff swept by the LFO between 1k and 7k. Most of the character comes from that, not the delay.
- Separate voice struct per channel, LFOs offset 90 degrees. Collapses to mono without eating itself.
- Dry/wet is a plain linear crossfade. There's roughly a 3 dB dip at 50% and I'm fairly sure that's comb cancellation from summing a correlated wet signal with the dry, not bad crossfade math. If that reasoning is wrong I'd like to know.

One debugging note that saved me: check your coefficients at frac = 0.5. They should land on -0.0625, 0.5625, 0.5625, -0.0625. Mine didn't, and it was a typo in one of the products in the third coefficient.

At my defaults (1.6 Hz, about 4 ms depth) the improvement is small. A little less grit on held notes up top. I assume it opens up more if you push the rate.

Two things I still can't answer:

1. Any reason to go past cubic when the modulation is this slow, or is higher order mainly for pitch shifting and wide sweeps?
2. The HF droop moves with the fractional part, so slow modulation means a slow wobble on the top end. Does anyone correct for that in practice or is it under the floor at this depth?

It's free, GPLv3, VST3 and CLAP, mac/windows/linux. It's built for pitch-corrected vocals specifically, which is the only thing I use it on. If you'd rather hear it than read about it, it's at pyfessional.tech, the download button picks your OS for you and the source is linked from the same page. Would rather have someone install it and tell me it sounds wrong than get upvotes.

GitHub repo: pytosc

$ pip install py2tosc

No dependencies. Python 3.10 or newer. Documentation

Why

TouchOSC layouts are drawn by hand in a GUI editor, which is the right tool right up until the work is repetitive. Laying out a fader per parameter for a plugin with fifty-four of them, numbering an eight-by-eight pad grid, renaming two hundred controls, restyling everything, or keeping a layout in step with a config file -- all of it is an afternoon of clicking, or a few lines of Python:

import py2tosc
from py2tosc import ui

faders = [py2tosc.fader(name=f"ch{n}", messages=[ui.midi_cc(n - 1)])
          for n in range(1, 9)]

doc = py2tosc.Document(root=ui.row(
    *faders,
    gap=4,
    pad=8,
    frame=(0, 0, 1024, 768),
    name="mixer",
))

# `ui.row` records how the faders should be arranged but cannot size them,
# since it runs before the frame above it exists. `resolve` walks the finished
# tree and divides that frame among them -- nothing has coordinates until it does.
doc.resolve()

doc.save("mixer.tosc")

Note that py2tosc is a rewrite of tosclib by Alberto Valdez, whose work established the original mapping between the .tosc format and Python that this library is built on.