Chatgpt AI and what not making a daw with AI

The Studio
1

Right being that I have no idea on how to do do this I’m thinking about using AI to code an idm daw…

I will post the source code that AI comes up with in this thread…

I guess c++ is the common code language I guess

1 Like
2

If you want source code for a DAW (Digital Audio Workstation) written in C++, these are the best open-source starting points:

### Best C++ DAW Engines / Source Projects

1. **Tracktion Engine** — full DAW backend framework in C++

Built for sequencing, audio editing, MIDI, plugin hosting, automation, etc.

GitHub: [Tracktion Engine](GitHub - Tracktion/tracktion_engine: Tracktion Engine module · GitHub)

Official site: [Tracktion](Creative audio software DAW plugins | Tracktion)

2. **JUCE Framework** — industry-standard C++ audio framework

Used by many commercial DAWs and plugins.

GitHub: [JUCE GitHub](GitHub - juce-framework/JUCE: JUCE is an open-source cross-platform C++ application framework for desktop and mobile applications, including VST, VST3, AU, AUv3, LV2 and AAX audio plug-ins. · GitHub)

Official site: [JUCE Official Website](Home - JUCE)

3. **MAGDA** — open-source modern DAW using JUCE + Tracktion Engine

Includes mixer, session view, AI integration, modulation system, etc. ([Hacker News][1])

GitHub: [MAGDA Source Code](GitHub - Conceptual-Machines/magda-core: A DAW built for automation, transformation, and fast musical iteration · GitHub)

4. **OpenDaw** — GPL DAW written with Qt + Tracktion Engine

Has piano roll, notation view, VST3 support, routing system. ([Reddit][2])

GitHub: [OpenDaw GitHub](GitHub - glenwrhodes/OpenDaw: OpenDaw — a free, open-source Digital Audio Workstation for Windows. Qt 6 UI, Tracktion Engine audio, MIDI piano roll, VST3 instruments, built-in effects, Claude AI assistant. · GitHub)

-–

## Recommended Stack for Building Your Own IDM DAW

For an IDM/electronic-music focused DAW:

| Component | Recommended |

| --------------- | ----------------------- |

| GUI | JUCE |

| Audio engine | Tracktion Engine |

| DSP | Custom C++ DSP / Faust |

| Plugin support | VST3 + AU |

| Sequencer | MIDI clip engine |

| Synths | JUCE DSP module |

| Time stretching | RubberBand / SoundTouch |

| Audio graph | Tracktion graph |

-–

## Minimal Architecture

Typical DAW structure:

```text

App

├── Audio Engine

│ ├── Mixer

│ ├── Tracks

│ ├── Clips

│ ├── DSP Effects

│ └── Plugin Host

│

├── Sequencer

│ ├── MIDI timeline

│ ├── Automation

│ └── Tempo map

│

├── UI

│ ├── Arrangement view

│ ├── Piano roll

│ ├── Mixer

│ └── Device rack

│

└── File System

  ├── Project save/load

  └── Audio cache

```

-–

## Example: Simple JUCE Audio App

```cpp

class MainComponent : public juce::AudioAppComponent

{

public:

MainComponent()

{

    setAudioChannels(0, 2);

}

void prepareToPlay(int samplesPerBlockExpected,

                   double sampleRate) override

{

}

void getNextAudioBlock(

    const juce::AudioSourceChannelInfo& bufferToFill) override

{

    bufferToFill.clearActiveBufferRegion();

}

void releaseResources() override {}

private:

};

```

-–

## Features Needed for an IDM-Focused DAW

IDM-style workflows usually need:

* Clip launching

* Probability sequencing

* Polymeters

* Euclidean rhythms

* Granular synthesis

* Modular routing

* Automation curves

* Glitch/stutter engine

* Step sequencers

* MIDI effects

* Live resampling

Tracktion Engine already gives you a large portion of this.

-–

## Learning Resources

* [JUCE Tutorials](Tutorials - JUCE)

* [Tracktion Engine Docs](tracktion_engine/docs at develop · Tracktion/tracktion_engine · GitHub)

* [The Audio Programmer YouTube Channel](https://www.youtube.com/@TheAudioProgrammer?utm_source=chatgpt.com)

-–

## Easiest Path

If your goal is:

* **Fastest development:** JUCE + Tracktion Engine

* **Maximum control:** pure C++ audio engine

* **Modern DAW reference:** MAGDA or OpenDaw

* **Plugin/synth focus:** HISE

Would you like:

* a **minimal DAW starter template in C++**

* a **step-by-step roadmap to build an IDM DAW**

* or a **full source example with mixer + piano roll + VST hosting**?

[1]: https://news.ycombinator.com/item?id=47417821&utm_source=chatgpt.com “Magda – Open-Source DAW with Integrated AI (C++/JUCE/Tracktion Engine) | Hacker News”

[2]: https://www.reddit.com/r/sounddesign/comments/1s3x5mu/i_built_a_free_opensource_daw_gpl

_qt_6_vst3_sheet/?utm_source=chatgpt.com “I built a free, open-source DAW - GPL, Qt 6, VST3, sheet music view, destructive audio editor (OpenDaw)”

3

Damn, I had no idea about traktion engine. I would add you should try and keep the DAW as portable as possible (code-wise) meaning to support the maximum number of OS/devices with increased abstraction. I think forget about 3rd party plugin hosting and develop a few basic tools to start. 'twould be a dream come true if I could actually record something on my phone, put a quick beat/processing on it, save it to the cloud and then open that up on my studio PC to finish at home. Plus that basically makes every phone a DAW in addition to a field recorder all in one app.

1 Like
4

JUCE is quite nice as you get lots of stuff in a single library.

I would however split the application into two parts: The UI and the engine. Because C++ needs quite a lot code for writing nice UIs while its excellent for the audio engine itself.

I used .NET for the UI and C++ for the engine. But if I had done it again I would probably have used RUST for the UI. Fun to learn new languages.

2 Likes
5

Honestly, for non-engineers (aka most of us) it’s fun to just make a sequencer or tracker in some game engine or something if you really want to get your feet wet. Start small before you consider just how much work is required to do half of the shit that already exists somewhere else, and maybe consider whether the world needs another DAW in the first place; you could easily start with something like Cabbage and print off a VCV module with almost no code at all as opposed to starting with C++ and heavy DSP constructs right out of the gate. Hell, even a small sequencer in Python could be really inspiring, and it’s not nearly as hard to learn. AI could probably even steal one from someone else for you and you can pretend like it’s yours, if that’s your thing.

I think the one issue with AI fantasy roadmaps is that it generally doesn’t lead anywhere, but there are smaller ‘helper’ environments all around you if you really want to get into some basic DAW-like tasks or extending one. Pure Data is even another option if you don’t mind the visual clusterfuck that it becomes later on, because you can sort of create all of those constructs from scratch in a visual context, and it can be a great way to actually lay down a solid prototype.

I saw some guy doing the same AI roadmap thing on the Renoise forums recently; planning out a theoretical DAW with AI, running through ASM and AVX malarkey (nobody would ever do this on modern machines, by the way) and likely not getting far with anything aside from playing with theoreticals. Maybe just reading the DAW manual and checking out VFX script (or similar) to extend the way things work, a little bit at a time, could even be more practical. Then if that’s not enough, take it up a notch.

1 Like