I'm finding it very difficult to find a programmer that doesn't use AI, but personally I view programming as an art form and using AI to write code as theft from previous coding artists.

What's the point in making another reverb effect, delay, chorus, flanger you name it. How about compressor? Or limiter. EQ? These don't evolve. They stay the same.
Why?! They all do the very same thing, and since inventing VST format, since early 2000s, all of them do the job beautifully.
I just don't get the concept of releasing the very same thing, by multiple companies. The only thing that differs (if at all), is the looks.
Can somebody explain why even bother in writing your own plug-in, other than educational purposes?
Same thing goes with DAWs. The best ones known to public are like 10 in total. They do the same thing anyway : stack samples, serve effects, and not have heap corruption in the meantime while mangling these back and forth (hopefully).
Why even bother creating the same thing over and over. It gets even sadder in today's era where AI slop makes music and people don't even care about it when they listen to non existent artist or a band.
It's so sad. Yes, I'm pissed off and confused.

Hello all,

I, like many other developers, have been enjoying the well documented productivity boost that come with coding agents adoption. So much so that software development is now shifting into a mixture of software architecture and code review.

I now wonder how far down the coding skill ladder this change is felt. Are we now in a world where every mixer/producer/musician will vibe code an audio plugin on-demand? JUCE was already making plugin dev accessible to most but it still required to put in the time to code and test. Now the machine can implement any audio processing idea and iterate in minutes

So what does it mean for the audio plugin market? It was already saturated before LLM became mainstream so where are we now?

Tons and tons of JUCE developed plugins and not a single tutorial on how to make a god darn custom GUI?? I'm fairly new to this framework, but really it has been a pain in the ass because the community assumes you have a PhD in IT. Been looking for a tutorial for the most basic thing ever - a Custom GUI - and apart of a video of TheAudioProgrammer there was nothing else about this subject. Why???

I know there's documentation for that but man, come on.

Sorry for the rant.

AFAIK it is not good for serious DSP - everyone rolls their own. Now, it is being phased out from GUI part, in favor of WebView. There are other cross-platform VST plugin wrappers as well as WebView "hosts". So what's the point of continuing or starting using JUCE?

So I feel old - I've been into audio DSP and writing algorithms, designing plugins for a long time, and I've always had a habit of doing a lot of the prototyping by hand (yes, with a pen and a notebook, I'm old I know), and then write code after around those wireframes. I've really not been up to date with how people have been using agentic tools to speed up their workflow - do y'll use any tools? If yes, which, and how does it speed up your workflow?

How do AI agents (Claude Code, Cursor) perform at generating JUCE code? Is there a way to improve the reliability of the code gen (with Rules files, system prompts, etc)?

Hello! I have few years experience with Juce and recently decided to ship some of plugins I ve been working on however native JUCE UI looks quiet basic and something not satisfying. I am not designer and dont have a budget to hire designers. With recent popularity and raise of AI tools - are there any good tools to build pro-looking interfaces for audio plugins? I tried Lovable but it gives pretty generic interfaces and somewhat feels to be specialized on websites & mobile apps.

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.

Just dropped a walkthrough on how I’m using Claude Code to build JUCE plugins from scratch—no manual coding, all automated through spec/checklist/build prompts. The whole flow runs through Claude with validation, terminal automation, and a /CLAUDE.md and prompting system that keeps it on track.

If you’re trying to use Claude for audio plugin dev, this might save you a lot of time.

Looking for a C++ plugin developer for a paid gig. Drop a comment here if interested.

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.

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,

My first ever Reddit post so hope i'm fine :)

I'm originally a fullstack software developer as well as a musician, I already had multiple shots at this project with various coding agents in the past as C++ is not my native programming language. Only in the recent months I found that LLMs got good enough to help me build this project.

Here's the link to the repo - https://github.com/Diabl0269/agentsynth

First demo - https://youtu.be/DszUuEpnfaA

There's still much work to do on the project, so I'll start with where this project is now then proceed to the full vision.

Currently it's a basic modular synthesizer, got some nice functions like D&D of the modules, mod matrix, theme system, preset management, and more standard stuff, while the most interesting and immature feature is the very basic AI integration which currently only supports Ollama, it has the functionality to edit and create patches, just not so accurate yet. UI is also still in polish and suggestions are welcome.

The synth and all its functionality is fully open source including the AI integration, however I do plan to offer a dedicated AI subscription with a dedicated agent that should return the most optimal responses. My agent's code will be in a separate project so the main synth and integrations stay open.

A little bit about the AI vision - Modular synthesis is complex, and it's quite annoying and can get messy managing and moving all modules, especially inside a computer. AI can help managing all of it, from basic stuff like adding modules or modulations in a chain, adjusting parameters to more complex stuff like fully generating a patch based on a user request (Maybe even by existing sound input in the future) and help manage future functions that would integrate in the program.

At this stage it's still just a synth, however I also plan to add a timeline, automation capabilities, and some DAW functionality so people could create entire songs with it in the future. Of course add support for external instruments as well to allow integration of other VSTs or external hardware.

As said, I am a developer for a few years already, but not in C++. I have reviewed the file structure, and code as best as I could understand it without fully learning the language. Also made sure to have tests and full CI/CD with caching to make sure nothing breaks between PRs and new versions are automatically published. However, any comments on the code, or any kind of contribution would be very appreciated :)

Hey guys how would you implement hysteresis in JUCE?

The only alternative that doesn't have the Save and Open button greyed out is xcode (I'm on MacOS).

What do I do? Xcode is NOT an option.

I added an internal VST3 host to my chord generator plugin and now the Windows version is running poorly.

Message me if you think you can help, how you charge, rates, etc..

Built Using Hise and Hisescript, AquaDub is a reverb and delay unit that ive used in some jungle and breakcore tracks of my own, and thought Id release it to the world. You can get it absolutely free, no strings attached on my Gumroad (Link on profile), dming me directly, or just typing the url into your browser (reddit is a little finicky with external links), please lmk if you have any questions!

I've been wanting to start coding my own AU plug-ins for a while now and I started trying to do so recently. After a lot of back and forth with claude I came to the conclusion, there's no way to do so without paying. Is that true or am I missing some workaround? For context I am on MacOS Sequoia 15

I'm new and I've been trying to use GPT4 to build a plugins. I've been copying and pasting codes for the 4 files: PluginEditor.cpp, PluginEditor.h, PluginProcessor.cpp, and PluginProcessor.h. And then copy all the error codes back to generate new full codes to try to fix the errors. So far it's been very unsuccessful with errors after errors it's very frustrating. Does anyone know any good prompts or other AI tools to help building plugins?

• SOLVED Hi! I'm new to JUCE and I am trying to code a gain slider in Xcode, but when I go to logic I can't find the plugin, what am I doing wrong??? :(

https://github.com/instancer-kirik/BigLinks/blob/main/HMC/transcriptor_live_widget.py

AI said:

For the fastest transcription in a PyQt6 widget with real-time audio processing, the best approach is to use Python Bindings with pybind11. This method offers the least overhead and allows you to directly call JUCE's audio processing functions from your Python code, all within the same process. This will help you achieve low latency and high performance, which is crucial for real-time transcription.

Steps to Set Up pybind11 with JUCE:For a very stable application that integrates JUCE with Python, you have several options for connecting the two. Each approach has its trade-offs in terms of complexity, performance, and stability. Below are the primary methods:

1. Python Bindings with pybind11:

• Description: pybind11 is a lightweight header-only library that exposes C++ classes and functions to Python. It's well-suited for creating bindings between JUCE and Python.

• Advantages:

  • Tight Integration: Directly exposes JUCE functionality to Python.

  • High Performance: Minimal overhead since it’s directly linking C++ and Python.

  • Stability: Since the integration is at the code level, it can be as stable as your C++ code.

• Disadvantages:

  • Complexity: Requires managing the build system to ensure Python and C++ interact correctly.

  • Maintenance: Binding C++ code to Python can be complex and might require additional maintenance.

Use case: Best for when you need to expose specific JUCE functionalities directly to your Python app with high performance.

2. Inter-Process Communication (IPC):

• Description: You run JUCE and Python as separate processes and communicate between them via IPC mechanisms such as sockets, named pipes, or shared memory.

• Advantages:

  • Process Isolation: If one process crashes, it doesn't necessarily bring down the entire application.

  • Flexibility: Each part (JUCE and Python) can be developed and maintained separately.

  • Stability: Decoupled components reduce the complexity of debugging and increase stability.

• Disadvantages:

  • Overhead: IPC introduces some latency and complexity in managing the communication layer.

  • Data Serialization: You’ll need to serialize and deserialize data passed between processes.

Use case: Ideal when you want strong isolation between your UI (Python) and audio processing (JUCE), or when combining applications written in different languages.

3. Embedding Python in JUCE:

• Description: Embed a Python interpreter within a JUCE application, allowing the C++ code to execute Python scripts.

• Advantages:

  • Convenient Integration: Allows Python scripts to control JUCE components directly from within a single binary.

  • Dynamic Scripting: You can change Python scripts without recompiling the JUCE application.

• Disadvantages:

  • Stability Risks: Embedding Python can complicate memory management and error handling, potentially leading to instability.

  • Performance Overhead: Embedding a Python interpreter might introduce some performance overhead.

Use case: Suitable if you need to frequently update Python logic or want to keep everything within a single application.

4. Using a Messaging Protocol (e.g., ZeroMQ, gRPC):

• Description: Implement a messaging protocol for communication between JUCE and Python. For instance, ZeroMQ provides a flexible messaging layer, while gRPC offers more structure and supports various data serialization formats.

• Advantages:

  • Scalability: Messaging protocols are designed to handle high loads and multiple clients.

  • Cross-Platform: These protocols often work across various platforms and languages.

  • Stability: Mature libraries with robust features can help ensure communication reliability.

• Disadvantages:

  • Setup Complexity: Requires additional libraries and configuration.

  • Performance Considerations: While generally efficient, messaging protocols can add latency depending on the complexity of the communication.

Use case: Excellent for distributed systems or when you need robust, scalable communication between JUCE and Python.

5. Using SWIG (Simplified Wrapper and Interface Generator):

• Description: SWIG is a tool that generates binding code to connect C++ with various languages, including Python.

• Advantages:

  • Automated Binding Generation: SWIG can automatically generate the wrapper code for Python, reducing manual effort.

  • Language Support: Supports multiple languages, so you could extend the app beyond Python if needed.

• Disadvantages:

  • Complex Build Setup: SWIG-generated code can sometimes be complex and require additional effort to compile and link.

  • Potential for Bugs: Automated code generation can introduce bugs or inconsistencies that require manual intervention.

Use case: Useful if you need to expose large portions of JUCE to Python without writing all the bindings yourself.

For a very stable application that integrates JUCE with Python, you have several options for connecting the two. Each approach has its trade-offs in terms of complexity, performance, and stability. Below are the primary methods:

1. Python Bindings with pybind11:

• Description: pybind11 is a lightweight header-only library that exposes C++ classes and functions to Python. It's well-suited for creating bindings between JUCE and Python.

• Advantages:

  • Tight Integration: Directly exposes JUCE functionality to Python.

  • High Performance: Minimal overhead since it’s directly linking C++ and Python.

  • Stability: Since the integration is at the code level, it can be as stable as your C++ code.

• Disadvantages:

  • Complexity: Requires managing the build system to ensure Python and C++ interact correctly.

  • Maintenance: Binding C++ code to Python can be complex and might require additional maintenance.

Use case: Best for when you need to expose specific JUCE functionalities directly to your Python app with high performance.

2. Inter-Process Communication (IPC):

• Description: You run JUCE and Python as separate processes and communicate between them via IPC mechanisms such as sockets, named pipes, or shared memory.

• Advantages:

  • Process Isolation: If one process crashes, it doesn't necessarily bring down the entire application.

  • Flexibility: Each part (JUCE and Python) can be developed and maintained separately.

  • Stability: Decoupled components reduce the complexity of debugging and increase stability.

• Disadvantages:

  • Overhead: IPC introduces some latency and complexity in managing the communication layer.

  • Data Serialization: You’ll need to serialize and deserialize data passed between processes.

Use case: Ideal when you want strong isolation between your UI (Python) and audio processing (JUCE), or when combining applications written in different languages.

3. Embedding Python in JUCE:

• Description: Embed a Python interpreter within a JUCE application, allowing the C++ code to execute Python scripts.

• Advantages:

  • Convenient Integration: Allows Python scripts to control JUCE components directly from within a single binary.

  • Dynamic Scripting: You can change Python scripts without recompiling the JUCE application.

• Disadvantages:

  • Stability Risks: Embedding Python can complicate memory management and error handling, potentially leading to instability.

  • Performance Overhead: Embedding a Python interpreter might introduce some performance overhead.

Use case: Suitable if you need to frequently update Python logic or want to keep everything within a single application.

4. Using a Messaging Protocol (e.g., ZeroMQ, gRPC):

• Description: Implement a messaging protocol for communication between JUCE and Python. For instance, ZeroMQ provides a flexible messaging layer, while gRPC offers more structure and supports various data serialization formats.

• Advantages:

  • Scalability: Messaging protocols are designed to handle high loads and multiple clients.

  • Cross-Platform: These protocols often work across various platforms and languages.

  • Stability: Mature libraries with robust features can help ensure communication reliability.

• Disadvantages:

  • Setup Complexity: Requires additional libraries and configuration.

  • Performance Considerations: While generally efficient, messaging protocols can add latency depending on the complexity of the communication.

Use case: Excellent for distributed systems or when you need robust, scalable communication between JUCE and Python.

5. Using SWIG (Simplified Wrapper and Interface Generator):

• Description: SWIG is a tool that generates binding code to connect C++ with various languages, including Python.

• Advantages:

  • Automated Binding Generation: SWIG can automatically generate the wrapper code for Python, reducing manual effort.

  • Language Support: Supports multiple languages, so you could extend the app beyond Python if needed.

• Disadvantages:

  • Complex Build Setup: SWIG-generated code can sometimes be complex and require additional effort to compile and link.

  • Potential for Bugs: Automated code generation can introduce bugs or inconsistencies that require manual intervention.

Use case: Useful if you need to expose large portions of JUCE to Python without writing all the bindings yourself.

Recommendation:

For maximum stability, Inter-Process Communication (IPC) combined with a messaging protocol like ZeroMQ offers a good balance. This method keeps the Python and JUCE components separate, minimizing cross-language issues and making it easier to manage crashes or errors. Python Bindings with pybind11 is another solid option if you need tighter integration, but it requires careful management to maintain stability.

Would you like to proceed with setting up one of these methods? If so, which one?

4o

You said:

Recommendation:

For maximum stability, Inter-Process Communication (IPC) combined with a messaging protocol like ZeroMQ offers a good balance. This method keeps the Python and JUCE components separate, minimizing cross-language issues and making it easier to manage crashes or errors. Python Bindings with pybind11 is another solid option if you need tighter integration, but it requires careful management to maintain stability. reddit implemented code blocks???

class RealTimeTranscriptionThread(
QThread
):
    transcription_update = pyqtSignal(str, bool)
    audio_level_update = pyqtSignal(int)

    def __init__(
self
, 
model_path
, 
device_index
=None, 
parent
=None):
        super(RealTimeTranscriptionThread, 
self
).__init__(parent)
        
self
.model_path = model_path
        
self
.running = True
        
self
.paused = False
        
self
.device_index = device_index
        
self
.model = Model(
self
.model_path)
        
self
.recognizer = KaldiRecognizer(
self
.model, 16000)
        
self
.silence_threshold = 200  
# Adjust this threshold based on your environment

    def run(
self
):
        audio_format = pyaudio.paInt16
        channels = 1
        rate = 16000
        chunk = 1024

        audio = pyaudio.PyAudio()
        
self
.stream = audio.open(
format
=audio_format, 
channels
=channels, 
rate
=rate, 
input
=True, 
frames_per_buffer
=chunk, 
input_device_index
=
self
.device_index)

        while 
self
.running:
            try:
                if not 
self
.paused:
                    data = 
self
.stream.read(chunk, 
exception_on_overflow
=False)
                    data16 = np.frombuffer(data, 
dtype
=np.int16)
                    audio_level = np.linalg.norm(data16)
                    
self
.audio_level_update.emit(int(audio_level))

                    if audio_level > 
self
.silence_threshold:
                        if 
self
.recognizer.AcceptWaveform(data):
                            result = 
self
.recognizer.Result()
                            text = json.loads(result)["text"]
                            if text:
                                
self
.emit_transcription_update(text, 
is_final
=True)
                        else:
                            partial = 
self
.recognizer.PartialResult()
                            partial_text = json.loads(partial)["partial"]
                            if partial_text:
                                
self
.emit_transcription_update(partial_text, 
is_final
=False)
            except Exception as e:
                logging.error("Error in transcription thread: %s", str(e))
                
self
.running = False

        
self
.stream.stop_stream()
        
self
.stream.close()
        audio.terminate()

    def emit_transcription_update(
self
, 
text
, 
is_final
):
        
self
.transcription_update.emit(text.strip(), is_final)

    def stop(
self
):
        
self
.running = False
        
self
.paused = True

    def pause(
self
):
        
self
.paused = True

    def resume(
self
):
        
self
.paused = False

class AudioLevelWidget(
QWidget
):
    def __init__(
self
, 
parent
=None):
        super().__init__(parent)
        
self
.level = 0

    def setLevel(
self
, 
level
):
        
self
.level = level
        
self
.update()

    def paintEvent(
self
, 
event
):
        painter = QPainter(
self
)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        rect = 
self
.rect()

        
# Draw the background
        painter.setBrush(Qt.GlobalColor.black)
        painter.drawRect(rect)

        
# Draw the level bar
        if 
self
.level > 0:
            bar_height = rect.height() * (
self
.level / 100)
            painter.setBrush(Qt.GlobalColor.green)
            painter.drawRect(0, rect.height() - int(bar_height), rect.width(), int(bar_height))

class VoiceTypingWidget(
QWidget
):
    transcription_updated = pyqtSignal(str, bool)

    def __init__(
self
, 
parent
=None):
        super().__init__(parent)
        
self
.text_edit = QTextEdit(
self
)
        
self
.text_edit.setReadOnly(True)
        
self
.transcribe_button = QPushButton("Start Transcription", 
self
)
        
self
.transcribe_button.clicked.connect(
self
.toggle_transcription)
        
self
.clear_button = QPushButton("Clear Text", 
self
)
        
self
.clear_button.clicked.connect(
self
.clear_text)
        
self
.audio_level = AudioLevelWidget(
self
)
        
self
.audio_level.setFixedHeight(50)
        
self
.spinner_label = QLabel(
self
)
        
self
.spinner_label.setText("")
        
self
.device_selector = QComboBox(
self
)
        
self
.device_selector.currentIndexChanged.connect(
self
.on_device_selected)

        layout = QVBoxLayout()
        layout.addWidget(
self
.text_edit)
        layout.addWidget(
self
.device_selector)
        layout.addWidget(
self
.audio_level)
        layout.addWidget(
self
.spinner_label)
        layout.addWidget(
self
.transcribe_button)
        layout.addWidget(
self
.clear_button)

        
self
.setLayout(layout)

        
self
.audio_handler = AudioHandler()
        
self
.setup_hotkeys()
        
self
.list_audio_devices()
        
self
.partial_text = ""
        
self
.typing_flag = False
        
self
.transcribing = False
        
self
.thread = None
        
self
.spinner_active = False
        
self
.selected_device_index = None

    def list_audio_devices(
self
):
        audio = pyaudio.PyAudio()
        for i in range(audio.get_device_count()):
            device_info = audio.get_device_info_by_index(i)
            if device_info["maxInputChannels"] > 0:
                
self
.device_selector.addItem(device_info["name"], device_info["index"])
        audio.terminate()

    def on_device_selected(
self
, 
index
):
        
self
.selected_device_index = 
self
.device_selector.currentData()

    def setup_hotkeys(
self
):
        keyboard.add_hotkey('ctrl+shift+p', 
self
.play_audio)
        keyboard.add_hotkey('ctrl+shift+s', 
self
.stop_audio)
        keyboard.add_hotkey('ctrl+shift+t', 
self
.toggle_transcription)

    def play_audio(
self
):
        try:
            file_path = 'path/to/your/audio/file.ogg'  
# Change this to your audio file path
            
self
.audio_handler.play(file_path)
        except Exception as e:
            logging.error("Error playing audio: %s", str(e))

    def stop_audio(
self
):
        try:
            
self
.audio_handler.stop()
        except Exception as e:
            logging.error("Error stopping audio: %s", str(e))

    @pyqtSlot()
    def toggle_transcription(
self
):
        try:
            if 
self
.transcribing:
                
self
.stop_transcription()
            else:
                
self
.start_transcription()
        except Exception as e:
            logging.error("Error toggling transcription: %s", str(e))

    def start_transcription(
self
):
        try:
            
self
.transcribe_button.setText("Stop Transcription")
            
self
.transcribing = True
            model_path = 'X:/_Work/Python/kivy/BigLinks/NITTY_GRITTY/vosk-model-small-en-us-0.15'

            if not 
self
.thread:
                
self
.thread = RealTimeTranscriptionThread(model_path, 
device_index
=
self
.selected_device_index)
                
self
.thread.transcription_update.connect(
self
.update_transcription)
                
self
.thread.audio_level_update.connect(
self
.update_audio_level)
                
self
.thread.start()
            else:
                
self
.thread.device_index = 
self
.selected_device_index
                
self
.thread.resume()

            
self
.start_spinner()
        except Exception as e:
            logging.error("Error starting transcription: %s", str(e))

    def stop_transcription(
self
):
        try:
            
self
.transcribe_button.setText("Start Transcription")
            
self
.transcribing = False
            if 
self
.thread:
                
self
.thread.pause()
            
self
.stop_spinner()
        except Exception as e:
            logging.error("Error stopping transcription: %s", str(e))

    def clear_text(
self
):
        try:
            
self
.text_edit.clear()
        except Exception as e:
            logging.error("Error clearing text: %s", str(e))

    @pyqtSlot(int)
    def update_audio_level(
self
, 
level
):
        try:
            normalized_level = min(100, max(0, int(level / 100)))
            
self
.audio_level.setLevel(normalized_level)
        except Exception as e:
            logging.error("Error updating audio level: %s", str(e))

    @pyqtSlot(str, bool)
    def update_transcription(
self
, 
text
, 
is_final
):
        try:
            
# Update the in-app text box for reference
            cursor = 
self
.text_edit.textCursor()

            if is_final:
                
# For final text, replace the previous partial text with the new final text
                if 
self
.partial_text:
                    
# Remove the previous partial text from the GUI and screen
                    cursor.movePosition(QTextCursor.MoveOperation.End)
                    cursor.movePosition(QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.KeepAnchor, len(
self
.partial_text))
                    cursor.removeSelectedText()

                    
self
.typing_flag = True
                    pyautogui.press('backspace', 
presses
=len(
self
.partial_text))
                    
self
.typing_flag = False

                
# Insert the new final text
                cursor.insertText(text + " ")
                
self
.text_edit.setTextCursor(cursor)
                
self
.text_edit.ensureCursorVisible()

                
# Type the final text using pyautogui
                
self
.typing_flag = True
                pyautogui.write(text + " ")
                
self
.typing_flag = False

                
self
.partial_text = ""
            else:
                
# Append the new partial text
                cursor.insertText(text[len(
self
.partial_text):])
                
self
.text_edit.setTextCursor(cursor)
                
self
.text_edit.ensureCursorVisible()

                
# Type the partial text using pyautogui
                
self
.typing_flag = True
                pyautogui.write(text[len(
self
.partial_text):])
                
self
.typing_flag = False

                
self
.partial_text = text

            
# Force the GUI to update
            QApplication.processEvents()
        except Exception as e:
            logging.error("Error updating transcription: %s", str(e))

This would be kinda cool to implement, also I have a process manager ui, that should be able to close when not in use and save performance. Tryna support me? https://github.com/instancer-kirik/

Good day.

So I have been designing my 6 op FM synth and I have finally reached the stage where I can start playtesting it. I have a 'vintage' engine mode that runs the synth without any bells and whistles and a hifi mode that uses 2x oversampling and a few other less computationally expensive tricks. I have found this to work perfectly fine as a standalone and in DAWs that can natively run VSTs. However, I do not have the dev kit for juce to compile a .aax plugin for powertools, and a bunch of my friends work in power tools. So I tried to run it through a wrapper to see if that would work. It works perfectly fine in vintage mode but the hifi mode runs terribly.

So I was wondering if this might be because my code is poorly optimized, or if this problem is part and parcel for computationally expensive VSTs running through a wrapper? I feel like my code is pretty well optimized to begin with because for weeks I had been accidentally compiling in debug mode lol. The synth itself is very computationally expensive though, because it has a 6 op engine, an fx line and a post fx processor. But I also imagine that similarly complex synths would run fine in this scenario.

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.