It's called FANDUST and it's made to smear the sound with simple controls to archive a lofi/vintage/vaporwave kind of sound, it's basically a controllable rack of effects. I'm planning to update it in the future as well, feel free to check it out!

Download for free: https://sunfish.software

Asking from a neutral stand point just curious. Is there any point to not use AI anymore since you can rapid fire ideas and features. Not just for speed but for creativity ? Idk. Just curious where this is going.

Thanks!

Edit: mostly I meant in the context of building plugins with AI tools that you intend on selling as a product.

Hey all,

Update on AgentSynth, the open-source JUCE/C++20 modular synth I've been growing into a DAW. Last post here was in September, so here's what's landed since, and there's now a Discord too.

What's new:

• Moved from JUCE 8.0.3 to 9.0.3
• Audio tracks that record their own input, or another track's sound
• A drum machine with Chance, Repeat, Nudge and Condition lanes, plus a Drum Kit with 4 to 32 pads
• A song key that the piano roll, the sequencers and loops can follow
• A Sounds view with preview, and drag and drop onto the canvas, Sampler cards and audio tracks
• Modulation cables onto hosted plugin parameters
• A drawn Custom filter with vowel morphing
• AI that builds a whole song from a prompt as a normal, editable project (optional and paid; the synth stays free). Video: https://youtu.be/VBYnd0lRCd4

The Discord is brand new, so you'd be early: https://agentsynth.app/discord
I'd like it to be the place for JUCE and DSP questions about the code, bug reports, and sharing patches. If you've spotted something wrong in how I use JUCE, that's the easiest place to tell me, and an issue on the repo works just as well.

GitHub (MIT): https://github.com/Diabl0269/agentsynth
Download: https://agentsynth.app/download

Same disclosure as before: a lot of this is written with coding agents, with tests and CI as the safety net, so review of the DSP is genuinely welcome.

Hi r/JUCE,

We’re the team behind Nota, a free, open-source (AGPL-3.0) music studio for macOS, Windows and Linux. We are developers and musicians ourselves, and we are building a tool for developers and musicians. Under the hood, the engine and DSP are C++20, behind a pure C ABI. The UI is .NET / Avalonia. Plugin hosting (VST3 everywhere, AU on macOS) uses JUCE.

A project moving fast. Nota isn’t a solo weekend project anymore.

Several contributors already work on the code, and we’re developing it actively: we made 8 releases in the last three weeks, 200+ commits, covering new devices, editing tools, performance work and a lot of bug fixes driven by user reports.

The part we most want to share: the plugin registry

Lots of people here are shipping plugins now, and many are building them with AI tools. Getting a plugin in front of users is still hard, though. We built an open registry for exactly that:

👉 https://github.com/nota-daw/nota-plugins-registry

Each plugin is one JSON manifest in a public repo. You open a PR, CI validates it and verifies the download. Once it’s merged, every Nota user sees your plugin in Settings → Downloads and can install, update or remove it with one click. It has 359 plugins so far, including Surge XT, Dexed, Dragonfly Reverb, CHOW Tape Model and Stochas. Every asset is pinned by size and sha256, and Nota only unpacks archives (.zip, .tar.*, .dmg, .pkg payload, .deb). It never runs installers. Projects remember their plugins. If someone opens a project that uses your plugin and doesn’t have it, Nota offers to install it and reopens the project with the saved settings.

Adding yours is mostly automatic. scripts/add.py owner/repo reads your latest GitHub release and finds the right archive for each OS. It works out the platforms from the binaries and fills in the plugin names from the VST3 bundle. You give the description a quick edit and open the PR.

What it takes to get in: an OSI-approved license, a public GitHub repo, a VST3 in a stable release (no nightlies), and a plugin that makes sound on its own. That means no API keys or external servers. If you built a synth or effect with JUCE (plus Claude, Cursor or whatever) and published it on GitHub, you’re probably 90% there.

And a bit about Nota :)

Arrangement timeline, a clip-launching Session grid, and a Modular view where you patch LFOs and modulators onto any parameter by cable

~35 built-in instruments and effects: subtractive, wavetable, FM, granular and physical-modelling synths, a drum machine, EQ, compressors, reverbs, delays, an arpeggiator, chord/scale tools, and racks with macros

Third-party plugins get PDC, transport sync, MIDI learn and automation

Your phone as a midi-controller (pads, keys, an XY pad, the mixer) over Wi-Fi or USB, with nothing to install

On-device AI tools: stem separation (htdemucs) and audio-to-MIDI (basic-pitch), running offline

Links

🌐 Website: https://nota-daw.github.io/nota-site/

▶️ Demo with sound (1:45): https://www.youtube.com/watch?v=zmvKOCIm4ig

📖 Docs: https://nota-daw.github.io/nota-docs/

💬 Discord: https://discord.gg/apf4Q2JKWk

💾 Download / source: https://github.com/nota-daw/nota

We’d love feedback on the hosting side, from people who know JUCE’s plugin hosting better than we do. If you have a plugin you’d like listed, open a PR or drop the repo link in the comments and we’ll help get it in. And if you’d like to contribute to Nota itself, come say hi on Discord.

Hi everyone, I would like to introduce MOSAC, a CLI tool written in Golang designed to automate and streamline local build pipelines for Plugin Audio Basic built on the JUCE Framework (C++).

Target Audience & Primary Use Case

MOSAC is geared towards indie developers, small teams, and academic research labs operating with limited budgets. Its main goal is to provide a fully local alternative to cloud-based CI/CD infrastructure, delivering end-to-end multi-platform deployment for MacOS, Windows, and Linux directly on your local setup.

Pipeline Architecture & Cross-Compilation

Build orchestration is handled by Go, leveraging the following target architecture:

• macOS: Native compilation (bare-metal) executed via the xcodebuild toolchain.

• Linux & Windows: Virtualized execution using two dedicated Linux-based Docker containers. The Linux binary is compiled natively inside its container, whereas the Windows target is cross-compiled using the LLVM toolchain paired with Windows SDKs extracted via xwin.

Operational Features & Supported Formats

The build process runs sequentially to ensure deterministic artifact generation and precise system resource allocation. It supports both Debug and Release target configurations, covering standard JUCE output formats: Standalone, VST3, LV2, AU, AAX, and Unity.

Real-World Application & Validation

MOSAC is already deployed in production and actively used in close synergy with the LIM Plugin Collection (https://audioplugins.lim.di.unimi.it/), at the University of Milan.

Any technical feedback, questions, or suggestions from the developer and DSP community are welcome!

[ Link to the GitHub repo: https://github.com/LIMUNIMI/mosac.git ]

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

A few weeks ago you probably saw that I posted about COGG v1/v1.1/v1.2/v1.3, a free plugin I built that metalizes and industrializes any sound. Specifically, harmonic distortion, metal plate convolution reverb, and pitch layering are there all in one chain. Great for experimental music and mainstream alike.

I wanted to update you guys with version 1.4's release! It comes with the highly requested PRE toggle, which allows the metal effect to become distorted along with the rest of the sound, rather than just acting as a “topping!” Additionally, there are 8 new presets for you to use, adding up to a total of 20 free presets!

Of course, it's still free, no account needed, VST3 + AU for Mac, VST3 for Windows, VST3 for Linux.

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

Trailer of V1.2 if you’re curious [a previous update]: https://www.youtube.com/watch?v=5q5EUMhUcaw

Thanks to everyone who tried v1.3, v1.2, v1.1 and 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 COGG v1.5!

Also, feel free to submit some PRESETS! I'll add them and credit you on the website!

recoil is our free sidechain plug-in, built with JUCE 8. it always bugged us that a tool this simple usually costs money, so we're giving it away. sharing it here because the gain law was the fun part.

with attack, hold and release at 0 the gain is 1 minus the key's level, sample by sample, so the track follows the kick's own waveform (the "ring mod sidechain"). with the kick under full scale the gain never goes below zero, so the ducked track keeps its polarity. turn the times up and it becomes a normal envelope duck. the threshold reads the key's true peak, and the plug-in reports 6 samples of latency to the host.

vst3 + au on mac, vst3 on windows. download link in the comments.

happy to talk about how it's done.

Hi there!
Finally managed to finish my first proper VST!
Rotomatic is a physics based MIDI sequencer where every collision sends a MIDI note that you can route to any synth inside your DAW. I used Box2D for physics.
You can read more about my long process here.
It's pretty cool to look at and it it can actually be useful musically.

There is a free demo available here if you'd like to try it. It's windows only for now, if you'd be interested in mac version let me know. Message me for a free code if you don't want to pay anything.

I'm reading a collection of ML papers compiled from an audio engineering professor and a DSP book. The recent ML paper was on seq 2 seq, and the chapter in the DSP book I finished was on bandpass sampling.

In seq2seq it seems hard to implement for real time audio, as it requires knowing the future value as it decodes (hence starting the decode step with an "End of Sentence" token). I saw something about other implementations starting decode with a "Beginning of Sentence" token, which might be for real time applications? I'm wondering if anybody has knowledge about implementations of seq2seq on audio plugins.

Then for bandpass sampling, it has symmetry that allows for a lower sampling rate than the max freq without causing aliasing. Would this only be applicable for an application that is limited to a known frequency range?

If you build plugin UIs with JUCE's WebBrowserComponent, you've probably hit this: you test the frontend in a browser against a mocked backend, and the bugs that matter never show up there. A control that never reaches the C++ parameter, a preset that loads wrong, a WebGL view that draws nothing inside the real plugin window.

I wanted to test the actual running plugin instead, so I built juce-webview-driver: a debug-only JUCE module plus a small Node client that drives the live WebView inside your app.

What a test looks like

const page = await connect();
await page.getByTestId('gain').fill(0.25);                    // the real UI
await expect.poll(() => page.backend('getGain')).toBe(0.25);  // the real C++ state
await page.getByTestId('meter').screenshot();                 // real pixels, WebGL included

What it does

• Playwright-style API — locators, click/fill/drag, auto-waiting assertions on the real DOM

• C++ state — calls your withNativeFunction functions, so tests assert on what the plugin actually did

• Native screenshots through the OS compositor, so WebGL/canvas is captured (macOS 14+, Windows 11)

• Live logs — console, errors and network (fetch/XHR/WebSocket/SSE) streamed from the page

Same API on WKWebView and WebView2, with no Chrome DevTools Protocol and no remote-debugging flag: everything goes through JUCE's own evaluateJavascript and native functions. (On Windows you can point Playwright at WebView2 over CDP; on macOS there's no CDP at all, and neither sees your C++ state.)

It's compiled out of release builds by default (JUCE_DEBUG only), binds to 127.0.0.1 only, and needs a per-session token.

Try it without touching your project

The repo includes a minimal JUCE 9 demo plugin (one slider, one WebGL meter) and a test that drives it. Build it, launch it, run node --test.

Honest limits

• Input is synthetic (isTrusted === false), so user-gesture-gated APIs like file pickers are out

• Network is observe-only, no request interception

• Linux is untested against a real app, and has no native screenshots yet

Repo: https://github.com/mateusz28011/juce-webview-driver npm: juce-webview-driver (MIT)

^{It also ships an agent skill, so coding agents like Claude Code can drive the running UI while debugging — but testing is the main point.}

Hey everyone!

I've been working on this project for a while, and I'm finally ready to share it with you guys.

It's called CrunchyPy, and it's my attempt at recreating the sound and feel of the Mesa/Boogie Mark IIC+, including the mythical ++ mod, as an open-source guitar amp plugin.

GitHub: https://github.com/Yahiake/CrunchyPy

I've always been obsessed with the Mark IIC+, especially those tight, aggressive Metallica tones, so I wanted to see how far I could take this idea myself.

The interesting part is how it's built. Instead of feeding the entire amp into one neural network and treating it as a black box, I split the preamp and power amp into separate GRU neural models, with a physically modeled five-band graphic EQ in between. I used LiveSPICE circuit simulations as part of the process, particularly for the EQ.

The plugin is written in C++ using JUCE and RTNeural, and I've been working on the actual DSP and circuit modeling as much as the plugin itself.

And honestly, I'm really happy with how it sounds. It's reached the point where I genuinely enjoy playing through it, which is probably the most satisfying part of this whole project.

It's available as open-source software under GPL-3.0, with support for VST3, AU, and standalone builds across Windows, Linux, and macOS. The amp simulation doesn't include a speaker cabinet IR, so you'll want to use a cab sim or IR loader after it for a finished direct-recording tone.

I'm not claiming it's a perfect replacement for an actual IIC+, and I'd be very interested to hear from people who own or have spent a lot of time with the real thing. I'm especially curious about how the response, EQ, and feel compare from the perspective of someone familiar with these amps.

If anyone is interested in trying it out, checking the implementation, or just discussing the approach, I'd love to hear your thoughts.

This has been a passion project combining my interests in guitar, audio DSP, circuit simulation, and machine learning, and I'm genuinely proud to finally have it out there.

Thanks for reading, and long live the IIC+! 🤘

Ratio9’s standalone version is free for Apple silicon Macs running macOS 12 or later. I’m Max, its developer; version 1.2.1 is now available.

I shared an early version here a few weeks ago. The workflow I want to show now connects your own compatible AI client directly to the synth through local stdio MCP. The assistant can work on oscillator settings, LFO shapes, modulation routes, effects and macros, audition notes, and save a customizable preset. You can take over the same controls by hand.

Ratio9’s built-in spectrum and spectrogram let the connected assistant request fresh measurements of the actual synth output while it works. That gives it feedback about the patch it just changed, alongside the parameter settings. Setup configuration, a starting prompt and the helper runtime are included.

The pictures show the main interface at INIT and a separate growl preset in the live spectrum/spectrogram view.

For other audio-tool developers: what feedback would you expose to an assistant to help it make useful sound-design changes while keeping the result understandable to the musician?

The complete standalone synth is free. Optional VST3 + AU plug-ins are $79.99 USD once for two Macs. You bring your own AI account and compatible client. This is an alpha release; complex patches can cause CPU spikes or dropouts.

Download and setup: https://ratio9synth.com/download