# ChucK gives you a strongly-timed audio language you can rewrite while it runs

> ChucK is a real-time music programming language built as a C++ virtual machine with a time-based concurrent model, where code can be added and modified on the fly. It installs with a single Homebrew command or builds from source, and its core can also be embedded in a C++ host.

**ccrma/chuck** — ChucK Music Programming Language

- Repository: https://github.com/ccrma/chuck
- Website: http://chuck.stanford.edu/
- Stars: 1,051 · Forks: 146
- Language: C++
- License: GPL-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/ccrma-chuck

## Time is a first class value in the language

ChucK is described as a programming language for real-time sound synthesis and music creation, and the phrase the project uses for its model is strongly-timed. What that means in practice is that the language has a time-based, concurrent programming model where the relationship between code and the audio clock is explicit, with dynamic control rates. Alongside that, the language allows you to add and modify code on the fly, which is the feature that separates it from an offline synthesis tool. The language also reaches beyond sound generation into control: MIDI, OpenSoundControl, HID devices and multi-channel audio are all listed as supported. The intended audience is stated as composers, researchers and performers who want a programming tool for complex audio synthesis and analysis programs and for real-time interactive music. It is worth being clear that this is a language with an audio clock built into its semantics, though the core can also be embedded as a library in a C++ host.

## Installing on macOS takes one Homebrew command

The installation story starts with a binary release page, and the Homebrew formula is the short path on macOS:

```bash
brew install chuck
```

The README points to the official release page for downloads and installs, and to the ChucK homepage, with a Princeton mirror, for documentation, examples, research publications and community resources. Since ChucK is open source and freely available on macOS, Windows and Linux, the release page is the answer for the platforms where Homebrew does not apply. The repository itself is the source for the language core, the virtual machine and the synthesis engine, and the project also maintains separate repositories for graphics, plugins, the package manager and the various hosts.

## Building on macOS is a make target in chuck/src

To build from source you clone the repository and work in the `chuck/src` directory:

```bash
git clone https://github.com/ccrma/chuck.git
cd chuck/src
make mac
```

The output is a `chuck` executable in `chuck/src`. For a binary that runs on both Intel and Apple Silicon, the README gives a separate target:

```bash
make mac-ub
```

The build badges at the top of the README cover macOS, Linux and Windows unit tests as separate GitHub Actions workflows, so the three platforms are treated as first class rather than one being an afterthought. On Windows the route is Visual Studio, 2019 or later recommended, by opening `chuck.sln` in `chuck/src/visual-studio` and building it. The presence of a `universal binary` target is a small detail that tells you the project cares about the current hardware transition rather than only the older one.

## Linux builds are a driver choice, not a single binary

The Linux build is where the audio layer shows its shape. The dependencies are gcc, g++, make, bison, flex, libsndfile, and then ALSA for the linux-alsa builds, PulseAudio for linux-pulse and JACK for linux-jack. On Debian or Ubuntu the README gives the package list:

```bash
sudo apt install build-essential bison flex libsndfile1-dev \
  libasound2-dev libpulse-dev libjack-jackd2-dev
```

The build itself is a make target per driver, and the full set is one target:

```bash
cd chuck/src
make linux-all
```

The README notes that `make linux-all` is equivalent in outcome to combining `make linux-alsa linux-pulse linux-jack`, and that a subset is a subset of the same form, for example `make linux-alsa linux-pulse` or `make linux-alsa`. A note in the dependency paragraph says that setups which do not need JACK or PulseAudio can omit either or both, and that ALSA is needed for MIDI support on Linux. That is the kind of detail worth reading before you set up a build machine, because the audio stack you compile in determines what the resulting binary can talk to on a given machine.

## The WebAssembly build produces webchuck.wasm and webchuck.js

ChucK also compiles to WebAssembly, which is how the browser hosts exist. The README requires the Emscripten SDK, activated from the `emsdk` directory with the environment script:

```bash
source ./emsdk_env.sh
cd chuck/src
make web
```

The result is `webchuck.wasm` and `webchuck.js` in the `chuck/src/host-web/webchuck/js` directory, and the README points to a separate WebChucK repository for the browser runtime. The separate repositories matter for anyone planning to ship a browser instrument: the language core, the web host, the browser IDE and the Unity and Unreal Engine integrations all live in their own repositories, each maintained by the same team but versioned and built separately.

## ChucK core embeds into a C++ host in about twenty lines

The core, meaning the compiler, virtual machine and synthesis engine, can be incorporated into other C++ software as a component or library. The README points at a series of C++ examples in the `src/host-examples/` folder, of which `example-1-minimal.cpp` creates a minimal ChucK host in roughly twenty lines. Later examples add real-time audio, then C++ to ChucK communication using ChucK globals, then ChucK shred control from C++. The build for them is one more make invocation:

```bash
cd src/host-examples
make
```

The claim that the whole family of tools uses this core and host model is worth noting, because it means the same engine powers the command line tool, the desktop IDE, the Unity and Unreal Engine integrations and the WebAssembly build. There is also a documented mode for building only the core, without a host and without any of the audio drivers, which is the variant to look at if you are embedding the language in something that supplies its own I/O.

## The plugin ecosystem lives in its own repository

Extending ChucK is done with plugins called chugins, and they are developed in a separate repository that the README describes as a good place to start contributing. A package manager named chump exists for the language, and other repositories cover graphics, symbolic music support in smuck, the desktop IDE miniAudicle and the browser IDE. This split is the main cost of adopting the project as a platform rather than a tool. ChucK itself is licensed under the GPL, and the repository carries both a GPL licence file and an MIT one, so which terms apply to the parts you build on top is a question for the licences themselves rather than for this summary. A copyleft licence in the core is a material fact for anyone planning to ship a commercial product built on the virtual machine, so read `LICENSE.GPL` and `LICENSE.MIT` before committing to a design.

## Conclusion

Adopt ChucK when you want to write sound synthesis and analysis code with timing semantics you can reason about, and you are willing to learn a language whose scheduling model is unlike anything in general purpose programming. Do not adopt it expecting a general purpose audio toolchain: MIDI, OpenSoundControl and HID support exist, but the distribution channels for plugins and the packaging tooling live in separate repositories, so an embedding project is a multi-repository commitment. Verify first which audio drivers you actually need on Linux, because `make linux-all` builds ALSA, PulseAudio and JACK together while `make linux-alsa` builds one, and read the host examples under `src/host-examples/` before planning an integration.

## FAQ

### How do I install ChucK?

On macOS, `brew install chuck` is the short path. The README also points to the official ChucK release page for downloads and installs on macOS, Windows and Linux, and to the ChucK homepage for documentation and examples.

### How do I build ChucK from source on Linux?

Install the listed dependencies, including bison, flex, libsndfile and the audio driver development packages, then run `make linux-all` in the `chuck/src` directory. That target is equivalent to `make linux-alsa linux-pulse linux-jack`, and you can build a subset such as `make linux-alsa`.

### What does strongly-timed mean in ChucK?

The README describes ChucK as presenting a time-based, concurrent programming model that it calls strongly-timed, with dynamic control rates and the ability to add and modify code on the fly. The language is built for real-time sound synthesis and music creation.

### Can ChucK be used as a library inside a C++ program?

Yes. The core, the compiler, virtual machine and synthesis engine, can be incorporated into a C++ host. The repository includes examples in `src/host-examples/`, the simplest of which builds a minimal host in about twenty lines, and they are built with `make` from that directory.

### What licence does ChucK use?

The project is listed under the GPL-2.0 licence, and the repository root holds both LICENSE.GPL and LICENSE.MIT files, so the terms for the parts you build on should be read from those files directly.

## Sources

- [ccrma/chuck on GitHub](https://github.com/ccrma/chuck)
- [Issues](https://github.com/ccrma/chuck/issues)
- [License: GPL-2.0](https://github.com/ccrma/chuck/blob/main/LICENSE)
- [Project website](http://chuck.stanford.edu/)
- [README](https://github.com/ccrma/chuck/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ccrma-chuck