Giada saves projects as JSON you are meant to edit by hand

Six roles in one binary, and they overlap on purpose

The feature list is written as six separate claims, and reading them together explains what the tool is for. As a loop machine you build a performance in real time by layering audio tracks or MIDI events through the main sequencer. As a sample player you load samples from your own collection and trigger them from a computer keyboard or a MIDI controller. As a song editor you write from scratch or edit an existing live recording using the Action Editor for fine control. As a live recorder you capture sound from the real world and MIDI from external devices or other applications. As an FX processor you run samples or live audio and MIDI input through VST instruments. As a MIDI controller you drive other software or synchronize physical devices by acting as a MIDI master sequencer. The overlap is deliberate: the same performance can be recorded, edited and re-performed, and each role is a reason to reach for a different control in the same window rather than switching applications.

The engine optimizes for timing, not for features

Several items on the list are really one commitment stated repeatedly: sample accuracy. The event engine is described as tick-based and rock-solid, providing sample-accurate timing of every action. The loop engine is sample-accurate and syncs to BPM and beat. Time stretching and pitch shifting are implemented so tempo and pitch can be manipulated on the fly without the audio smearing. Around that sit the properties a live tool needs: an ultra-lightweight internal design, multi-thread and multi-core support, and a 32-bit floating point audio engine. Channels are unlimited and can be driven from the computer keyboard, which is how the keyboard becomes an instrument rather than just text entry. An automatic quantizer exists for the times you do not want sample accuracy but want the beat. The consequence of this emphasis is a specific shape: the tool is optimized for what happens during a performance, and anything that only matters while editing is deliberately simpler.

The audio backend list is the compatibility statement

Giada names five backends and claims full support for each: ALSA, JACK plus Transport, CoreAudio, ASIO and DirectSound. Reading that list tells you what platform each build targets. Linux is covered by ALSA and by JACK, where Transport is the mechanism that keeps several applications on one clock, which matters if you run Giada next to another sequencer. macOS is covered by CoreAudio. Windows is covered by ASIO, the professional driver interface, and by DirectSound for the general case. MIDI input and output are supported on all of them, with custom MIDI lightning message maps maintained in a separate repository, which is the mechanism behind mapping a controller to Giada's controls. Because the tool is a live instrument, the audio stack is not an abstraction you can ignore: if your interface exposes ASIO and you are on Windows, that is the path the application uses, and the difference between backends is audible in latency rather than in features.

Projects are JSON files, described as hackable

Project storage is described in the feature list as a portable system based on super-hackable JSON files. That single phrase does more work than it looks at first. A project you can open in a text editor is a project you can repair, diff, generate from a script, or check into version control, and none of those are possible with a binary format or an opaque one. For a live performance tool, that also means a failed save or a corrupted project does not necessarily mean losing the set, since the structure that describes it is legible. The cost is the other side of the same choice: nothing stops you from editing the file into a state the application cannot load, and there is no schema validation described in the documentation. The companion editors are built on the same assumption, with a Wave Editor for audio samples and a Piano Roll editor for MIDI messages, both described as built-in and sleeker than a general-purpose DAW would give you.

Building means CMake presets and a vcpkg overlay directory

The README deliberately does not contain the build commands. It says the compilation process is made as simple as possible and points to the compiling from source chapter of the user guide, which is where the actual instructions live. What the repository root does show is the shape of the build. CMakeLists.txt and CMakePresets.json sit at the top, so builds are described as presets rather than as ad hoc flag combinations. Dependency management runs through vcpkg, with vcpkg.json declaring the manifest, vcpkg-configuration.json holding configuration, and vcpkg-overlays/ holding local patches to dependency ports, which is where you adjust a dependency version without forking it. A .gitmodules file means some components are submodules, and src/, tests/, scripts/ and extras/ are the working directories. Style is pinned by .clang-format and .gitattributes, and tests use Catch with GitHub Actions, matching the test-driven development claim on the feature list.

A single author, GPL v3, and two places naming the terms

The project is the work of one person, and the repository says so plainly in its copyright line: Giada is Copyright (C) 2010-2026 by Giovanni A. Zuliani | Monocasual Laboratories. That is useful information for anyone depending on it, because it tells you who to talk to and what happens if that person stops. The terms are named in two places with different precision. The feature list says 100 percent open-source GPL v3, and the license section says Giada is available under the terms of the GNU General Public License with a pointer to the COPYING file for further information, without naming the version there. The version numbering is worth reading too, because the tags carry codenames rather than plain numbers: 1.6.0 is Mavka, 1.5.0 is Leshy and 1.4.2 is Korrigan. Bugfix builds are labelled as such, which is a small habit that makes it obvious when to update. The last push to master was on 2026-10-06, six days before this article was written.

Where Giada is the wrong tool

Four cases send you elsewhere. The first is arrangement and notation. There is a song editor with an Action Editor, a Wave Editor and a Piano Roll, but nothing in the feature list describes score notation, orchestral parts, or the kind of linear composing workflow a notation tool provides. If you write a piece start to finish, this is the wrong shape. The second is plugin format. VST instruments are named as what the FX processing path uses, and VST3 appears in the topic tags, but there is no mention of AU or AAX, so a macOS user whose plugins are Audio Units is not served by the plugin hosting described here. The third is a pre-built Windows or Linux binary you can trust. The README sends you to the website for compilation instructions and does not describe packaged builds for every platform, so on a platform where you are not prepared to build, the friction is real. The fourth is stability expectations. The feature list says the software is under a constant stage of development, and it is maintained by one person, so you are choosing a tool whose changes arrive when one person has time, not when a roadmap says so.

Editorial conclusion

Giada suits a performer who builds a set by layering samples and MIDI in real time and wants a project file they can open in a text editor when something goes wrong. It does not suit someone who wants score notation or a full arranger, and it does not serve a macOS user whose plugins are Audio Units, since the FX path is described in terms of VST instruments. Before adopting, read the compiling from source chapter for the backend your platform uses, and open one saved JSON project to see how much of a set is plain text.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. monocasual/giada on GitHub
3. Project website
4. README
5. Releases