Save Big on Used Gear + Use Code CUPID10 for 10% Off Select New Items. Shop the Sale Save Big on Used Gear + Use Code CUPID10 for 10% Off Select New Items. Shop the Sale Save Big on Used Gear + Use Code CUPID10 for 10% Off Select New Items. Shop the Sale Save Big on Used Gear + Use Code CUPID10 for 10% Off Select New Items. Shop the Sale

The Programmable Eurorack

Interfacing Eurorack with Max/MSP, Pure Data, SuperCollider, and ChucK

Daniel Miller · 12/10/24

Connecting a laptop to a modular synthesizer or Eurorack has a lot of potential. While many people incorporate a laptop into their workflow for monitoring and recording, the laptop can also be a powerful tool for controlling a hardware synthesizer.

Laptops offer sequencing capabilities that go beyond most rack-mounted sequencers. Software sequencing often facilitates the evaluation of complex, large-scale compositions over time. Software offers the ability to save and recall your work easily. Moreover, integrating programming environments like Max/MSP, Pure Data, SuperCollider, Tidal Cycles, ChucK, and Csound into a hardware synthesis workflow unlocks the potential for creating bespoke algorithmic approaches to creativity with almost unlimited creative potential.

On the other hand, Eurorack systems bring physical controls and robust analog and digital synthesis into the mix, making composition more improvisatory and spontaneous. The physicality of voltage in a hardware synthesizer shapes the way that a user interacts with that material, suggesting new ways to intervene in the signal chain. This tactile engagement with the Eurorack invites a phenomenological experience, where the immediacy of touching and manipulating controls and patch cables becomes a dialogue between the creator and the instrument.

While the Signal blog has previously covered the DC-coupled audio interfaces such as the Expert Sleepers ES-8 and ES-9, this article aims to demystify the hybrid sequencing setup and simplify the process of bridging digital software with 1V/oct CV voltage sequencing in Eurorack using common music programming environments. We’ll look at some specific examples in Max/MSP, Pure Data, SuperCollider, and ChucK. Over the course of these examples, we’ll explore the basic sequencing and modulation setup and detail how to effectively mediate CV conversion between these digital tools and your Eurorack setup.

The choice of which audio programming environment to use to interface with your Eurorack (or the choice to use one not covered here, such as Csound or Tidal Cycles) ultimately comes down to personal preference. Max/MSP and Pure Data offer a visual programming paradigm that requires zero knowledge of text-based programming. They both come with built-in components that abstract common functions into LEGO-brick-like objects connected together with modular-synth-like virtual patch cords. And while Pure Data is free and open source, the proprietary Max environment comes with impressive graphical user interface (GUI) features out of the box, making it great for building controllers. SuperCollider is a common text-based programming environment for real-time audio synthesis and algorithmic composition that offers a powerful server-based architecture and a huge user community. And ChucK is a newer language that offers static type safety, a strong built-in definition of musical time and synchronization, and a concise syntax that allows complex audio processes to be instantiated in just a few lines of code.

All example files used in this article, including Max/MSP, Pure Data, SuperCollider, ChucK examples, can be downloaded from the author’s GitHub page.

Basic Concepts

Control Voltage

Control Voltage, or CV, is the cornerstone of modular synthesizers, serving as the primary means of communication and control among different modules within a Eurorack system. CV is an analog signal that is used to modulate various parameters of a synthesizer, such as pitch, filter cutoff, amplitude, and more. It allows for the dynamic control of these parameters in real-time, either manually by the user or automatically through sequencers, low-frequency oscillators (LFOs), and other modulation sources.

The idea behind CV is simple: by varying the voltage sent to a module, you can control a specific aspect of that module's behavior. For example, a higher voltage might increase the pitch of an oscillator or open up a filter wider, while a lower voltage would do the opposite. This direct, voltage-based control system is what gives modular synthesizers their unparalleled flexibility and expressiveness, allowing users to create complex, evolving soundscapes by patching together different modules with cables.

CV signals can be continuous (varying smoothly over a range) or discrete (stepping between specific values), enabling a wide variety of modulation effects. The standardized use of CV in Eurorack systems ensures compatibility across different manufacturers' modules, allowing for endless possibilities in configuring and reconfiguring one's modular setup.

The 1V/oct Standard

1V/oct CV, read as “one volt per octave,” is a specific standard for control voltage that relates to pitch modulation in synthesizers. Under this standard, a change of one volt in the control voltage results in a change of one octave in the pitch of the oscillator being controlled. This means that if a CV of 1V triggers a C note, then a CV of 2V would trigger the C note one octave higher, 3V would trigger two octaves higher, and so on. This linear scaling makes the 1V/oct standard particularly straightforward for musical applications, as it aligns with Western musical scales, where pitch doubles with each octave.

The 1V/oct standard is widely adopted in the world of modular synthesizers because it allows for easy and intuitive pitch control across different modules. When using a MIDI controller or a software-based sequencer on a laptop, these digital signals must be converted to control voltages (CV) through DC-coupled interfaces or dedicated MIDI-to-CV converters.

However, unlike MIDI, not all Eurorack modules adhere to a single universal standard of 1V/oct CV. Pitch CV within the Eurorack ecosystem may follow either a unipolar or bipolar format. Unipolar voltage typically ranges from 0-10V or 0-8V, originating at 0V and extending upward. Bipolar pitch CV, conversely, often encompasses a range from -5V to +5V, establishing 0V as a central pitch. This central pitch is also the pitch you would tune your oscillator to; applying negative voltage to the oscillator would make the pitch go lower, and applying positive voltage would make the pitch go higher.

This bipolar approach is particularly valued for its tuning flexibility, allowing for a mid-range frequency, such as C3, to be set at 0V. In this article we will focus on sending bipolar pitch voltage (in its digital equivalent form) from the laptop to the DC-coupled interface for use in the Eurorack.

Although 1V/oct is a standard representation of pitch developed for and by analog synthesists, many Digital Audio Workstations (DAW) and music programming environments can also send a digital signal to a synthesizer. To convert digital information into control voltage, we just have to understand how our interface interprets digital information as voltage.

Sequencing with CV or MIDI?

This article will focus on directly controlling a Eurorack with a computer using the Expert Sleepers ES-8 and ES-9 DC-coupled audio interfaces due to their unique position in the ecosystem of electronic music production. But any DC-coupled audio interface will work. This type of interface bridges the gap between the digital and analog worlds, allowing computers to send and receive CV directly to and from Eurorack systems. However, it’s worth noting that a more common approach to sequencing via a computer uses MIDI to control a synthesizer.

Control Voltage (CV) and the Musical Instrument Digital Interface (MIDI) are both used to control electronic music instruments, but they work in very different ways. CV is an analog signal that changes continuously, directly affecting things like pitch, filter settings, and loudness. This means you can get really precise and smooth changes in your sound.

MIDI data, however, is all about efficiency. The MIDI protocol sends specific instructions like when to start and stop notes, how hard to hit them, and other performance info. Because the MIDI standard is based on 8-bit bytes, only 7-bits of which are used to represent most information, the result is that most MIDI messages are in a range of 0-127. When CV is approximated with this limited number of values, changes in sound can sometimes seem a bit stepped or jagged, not as smooth as with CV.

While MIDI is good at representing tempered pitch, note onset, and velocity, etc., it's not so good at handling the detailed control that CV does so well. It wouldn’t be ideal for creating very specific waveforms (LFOs) or tuning notes just a bit off from the familiar 12-note scale (microtonality). This matters a lot in Eurorack setups, where these kinds of precise controls are common. If you're trying to use your computer to create these CV controls, using MIDI can mean you lose some of that precision. So, while MIDI has its perks, when it comes to the nitty-gritty of controlling synths in detailed ways, there's a bit of a gap that needs bridging to get all the detail required to really integrate digital and hardware systems.

Open Sound Control: MIDI's Spicy Sibling

Open Sound Control (OSC) is a more recent protocol developed at the Center for New Music and Audio Technologies (CNMAT) at the University of California, Berkeley for networking of musical devices and computers, offering several advantages over MIDI, including higher resolution, faster rates, and more flexible naming conventions. OSC messages are structured with an addressing scheme similar to URLs, which means each message specifies not only the data being sent but also where it's intended to go. For example, an OSC message could be directed to "/synthesizer/oscillator1/frequency," specifying that the accompanying data (e.g., a frequency value) is intended to control the frequency of oscillator 1 on a synthesizer. This method of addressing allows for highly organized and targeted control over complex systems.

Although a tutorial on the full capabilities of OSC is beyond the scope of this essay, we’ll circle back to this at the end of the article to see how OSC can be used like a data pipeline, facilitating the transfer of information between various software applications on a computer. This pipeline ultimately extends to a DC-coupled audio interface, providing a missing link between code and control voltage, allowing the user to connect arbitrary data sources to their synthesizer (or even control it from websites and networks!).

Max/MSP and Pure Data

Max/MSP, often referred to simply as Max, is a visual programming language for music and multimedia developed by Miller Puckette at IRCAM in the late 1980s. Originally conceived to provide composers with an environment for developing interactive music performances, Max has evolved to include MSP, which stands for Max Signal Processing, adding extensive capabilities for real-time audio synthesis and DSP. Following his work on Max, Miller Puckette went on to create Pure Data (Pd), an open-source counterpart to Max, in the 1990s. Pure Data shares many of the conceptual frameworks of Max but is designed to be more lightweight and is freely available, making it accessible to a wider audience. Both platforms allow users to create their own software using a drag-and-drop interface of boxes and connecting lines, which represent different functions and the flow of information, respectively. This approach to programming, known (by way of reference to synthesizers themselves) as patching, enables the creation of complex digital sound synthesis, processing, and analysis applications without traditional text-based coding.

For Eurorack synthesists, the interface of a Max or Pure Data patch may feel surprisingly familiar. Much like the patch cables in a Eurorack system, creating a patch in Max involves connecting different objects with virtual cables. Although typically representing much more low-level functions, each object in Max can be thought of as a software equivalent to a Eurorack module, performing specific tasks such as generating sound, processing input, or controlling parameters. The modular, signal-flow-based nature of Max's environment mirrors the hands-on, experimental ethos of Eurorack synthesis, making it an appealing tool for synthesists looking to build custom tools for sequencing and modulating a hardware synthesizer.

Modulating Eurorack with Max/MSP

In Max/MSP, with the ES-8 or ES-9 interface connected via USB, converting digital output to CV is as simple as selecting the Expert Sleepers interface as the output device in the Audio Status window.

Sending a very slow sine wave to output channel 1 in Max/MSP should result in a slow pulsing LED lighting up on the Expert Sleepers channel 1 output. This Low-Frequency Oscillation (LFO) is like any other modulation source in your rack. It can be used to modulate any module. It can also be modulated in Max/MSP itself. Multiplying two LFOs in Max/MSP, for instance, results in a ring-modulated sine wave, just as if you were modulating an LFO with a bipolar VCA in your rack.

Things get a bit more complicated if we require precise voltages for sequencing. The ES-8 and ES-9 interfaces interpret digital pitch information within a -1.0 to 1.0 floating-point range, which maps to the module’s +/- 10V DC output range. This translates to a 0.1 increment in Max/MSP per volt, aligning with the 1V/oct standard in modular synthesis.

For our purpose, let's focus on converting MIDI pitch information to bipolar pitch CV, but remember that with a DC-coupled interface you can map any value to a precise voltage. That means that, by controlling your Eurorack with Max/MSP, you can sequence with alternative tuning systems like Just Intonation or 22-TET, non-octave-repeating scales like Wendy Carlos’s Alpha and Beta scales, complex modulation sources, generative algorithms, or even open-source scientific data and live data streams.

Converting MIDI to 1V/oct

Since we want to use a bipolar pitch CV, we need to tune the hardware oscillator to a central reference pitch. For simplicity let’s use Middle C (C3) as our reference pitch. Middle C is note 60 in the MIDI pitch standard. In our Eurorack, this pitch will be represented by a control voltage of 0V, so we’ll set C3 as our reference point in our Max patch. With 0V connected to the 1V/oct input, we then tune our oscillator either by ear or with an electronic tuner.

In order to map the MIDI note range of 0 to 127 to our digital output range of -1.0 to 1.0, with the 0 centered on MIDI note 60, we need to apply a simple linear transformation. Implementing this conversion requires some basic arithmetic.

For a MIDI note M, we use the following formula to convert to a decimal that the interface can understand as voltage:

Here M is the MIDI note input, R is the reference pitch, and the final term (S) is a scaling factor. We derive this scaling factor by dividing the representation of an octave in voltage (0.1) by the number of notes per octave (12). So, assuming we’ve tuned our oscillator to Middle C (60), the formula would be:

Max/MSP includes several objects such as the scale and zmap, which exist to map one range of values onto another range of values. However, working with the formula directly has the advantage of greater observability. For this reason, I prefer to work with the expr object, which is also available in Pure Data as well. In “exper” we can represent our equation with terms represented by numbered input values (e.g. $f1)

In Figure 1 we use our linear transformation formula to map MIDI note values onto 1V/oct standard for a DC-coupled audio interface. To convert our -1.0 to 1.0 range to a convenient bipolar pitch standard used by many oscillators.

[Figure 1: A simple Max/MSP patch representing the conversion of MIDI pitches values to the 1V/oct standard for the Expert Sleepers Es-8 or ES-9 audio interfaces. The patch can be downloaded from the author’s GitHub.]

In theory this representation of pitch should match the 1V/oct standard in our Eurorack exactly. But things are rarely so simple once binary translates into voltage. Every module tracks slightly differently. Slight differences in calibration between the audio interface and an oscillator or filter become much more apparent the further a sequence strays from the reference pitch.

Through trial and error, I’ve found that adding a calibration feature greatly increases the accuracy of the CV conversion in many cases. To compensate for tracking anomalies, we can divide the output value by a slightly-offset constant. The process begins with fine-tuning the reference pitch. Following this, we identify the lowest and highest pitches we intend to use in our musical sequence. We then apply a minor adjustment to a denominator until these extreme pitches are in tune. This adjustment either expands or contracts the tracking range to compensate for the cumulative discrepancy that arises between the reference pitch and the sequence's extremities.

A Note About Frequency to 1V/oct

To convert frequency to voltage is a bit trickier, since we perceive pitch logarithmically in relation to frequency. The formula for this would be:

Where f is the frequency for which we want to find the corresponding voltage, fref is the reference frequency, and log2 denotes the base-2 logarithm, reflecting the exponential relationship between voltage and frequency. We then divide this by 10 to get the numeric representation of voltage used by our ES-8 and ES-9.

For example, if our reference pitch is Middle C (approximately 261.63 hz) and we want to know what voltage would give us C4 (an octave up from Middle C and approximately 523.26 hz), we would use the formula:

This correctly predicts that we would need to send the floating-point value 0.1 to our DC-coupled interface in order to play a note an octave up from our reference pitch.

Pure Data

Pure Data, commonly referred to as Pd, is an open-source visual programming language for creating interactive multimedia works, developed by Miller Puckette in the 1990s as a free alternative to Max/MSP. Originating from the same innovative spirit that led to the creation of Max, Pure Data offers a platform for artists, musicians, and researchers to experiment with sound in real-time, without requiring any knowledge of code. Like its predecessor, Pure Data employs a graphical interface where users connect objects with virtual cables to construct programs, or "patches,” a workflow that is intuitively similar to modular synthesis, where components are interconnected to generate and manipulate signals.

Translating our MIDI to CV Max patch into Pure Data is a straightforward process. Although Pd has fewer graphical user interface (GUI) components, many of the concepts, such as numbers, expressions, and DSP objects, translate directly from Max/MSP.

[Figure 2: The Pure Data alternative to the Max/MSP patch (download example) representing the conversion of MIDI pitches values to the 1V/oct standard for the Expert Sleepers ES-8 or ES-9 audio interfaces.]

SuperCollider

SuperCollider was developed by James McCartney (unrelated to Paul McCartney) in the mid-1990s. It’s a free, open-source, and highly versatile environment for sound design, live coding, and electronic music composition. Unlike Max/MSP's visual programming interface, SuperCollider employs a text-based scripting language with a syntax inspired by C and Smalltalk. Like modular synthesis, SuperCollider allows for the dynamic routing of audio and control signals, facilitating real-time manipulation and experimentation with sound textures and patterns.

SuperCollider operates on a client-server architecture: a server, which is responsible for audio processing, and a client that acts as both the programming language interface and the mediator sending instructions to the server. This setup allows for efficient sound synthesis and processing, with the server handling the audio workload while the client manages coding and command translation.

SuperCollider can be downloaded for free for Mac, Linux, and Windows. Once downloaded, SuperCollider opens with a dedicated integrated development environment (IDE), i.e. a box where you can type and run code. There’s also searchable help documentation and a post window to log errors for debugging.

Connecting SuperCollider to Eurorack

As long as SuperCollider recognises the ES-8 or ES-9 as its output device, it can immediately send audio or control voltage to your Eurorack.

Live coding is an unusual feature of both SuperCollider and ChucK: the ability to dynamically alter code during runtime without necessitating a halt or restart of the program. This feature might be particularly surprising for people accustomed to other high-level programming languages, where dynamic, real-time code modification during execution is not commonly supported. But, with practice, live coding allows these audio synthesis environments to feel improvisatory, much in the same way that hardware synthesis has elements of performativity as well as process.

To send a basic Low-Frequency Oscillation (LFO) to your Eurorack from SuperCollider requires just one line of code (minus some brackets and boilerplate):

{ Out.ar(0, SinOsc.ar(1, 0, 0.1));}.play;

This code (see Figure 3) creates a sine-wave oscillator with a frequency of 1 Hz, a phase offset of 0, and an amplitude of 0.1 (which will translate to a peak amplitude of 1V through the Expert Sleepers interface). The Out.ar method is then used to output this sine wave to the first audio channel (index 0) of the audio interface.

[Figure 3: A sine wave functioning as a Low-Frequency Oscillator for Eurorack. Example code, with instructions on how to run it in SuperCollider, is available in the example code directory on GitHub.]

Sequencing from MIDI in SuperCollider (see example 2) is similar to our function in Max/MSP. We’ll use the same formula to convert MIDI to CV. This time we transform a list of MIDI values (a stand-in for, perhaps, a more complex and dynamic method of sequencing) into a list of CV values using the .collect method on SuperCollider’s collection class, the output of which we assign to the global variable ~generateValues.

To output these CV values, a SynthDef named \dcBuffer is defined. In SuperCollider, a SynthDef is essentially a template for a sound synthesis or processing algorithm; it can be thought of as an instrument or module that does something musically significant. The \dcBuffer SynthDef is tasked with generating a constant DC signal that carries the CV information, modulating this signal with the calculated CV values, and routing it to an audio output channel. This allows the CV to be sent directly to Eurorack modules for modulation purposes. The playback of the CV sequence is handled by a Pmono pattern, which iterates over the CV values generated by ~generateValues, using the \dcBuffer SynthDef to output each value in sequence. This setup mimics the functionality found in Max/MSP for MIDI-to-CV conversion but is tailored to the text-based, scriptable nature of SuperCollider.

While this approach is relatively straightforward, it does bring us face to face with one of the many quirks of the SuperCollider architecture. The output sequence may sound like a series of DC voltages, but on close examination, there is an almost imperceptible slew of a few milliseconds between each note. This is apparently caused by the interpolation of low-sample-rate control parameters of a SynthDef to high-sample rate audio rate values used by the SuperCollider server. To work around this, some users on the scsynth.org forum proposed a “slightly naughty” workaround: defining a one-frame buffer, the contents of which are set from the client side but read back from the server side. This yields beautiful stepped voltages which perfectly emulate in-rack hardware sequencing.

This problem also demonstrates some of the “dark corners” of SuperCollider. While it’s a beautifully expressive language, it was first defined in 1996, and while it has evolved significantly, there are still aspects of its design that reflect the technological and conceptual frameworks of that time. Users often have to be creative and sometimes employ unconventional methods to achieve their desired outcomes. These challenges, while potentially daunting, also contribute to the depth and richness of SuperCollider as a tool for audio synthesis and algorithmic composition. They encourage a deeper understanding of both the software and the principles of sound itself, leading to innovative solutions and new possibilities in sound design.

Two Buck ChucK

If you fail to find SuperCollider’s quirks (and dynamic typing) endearing, you might be a fan of a relative newcomer in the audio programming community: ChucK is an open-source, concurrent, “strongly-timed” music programming language tailored for real-time sound synthesis and music creation, offering a unique blend of precision and expressivity. Created by computer scientist and musician Ge Wang in 2003 and developed at Princeton University, ChucK has been most notably associated with the Princeton Laptop Orchestra and Stanford Laptop Orchestra, ensembles that focus on computer-mediated live music performance and improvisation.

Unlike SuperCollider—and a rarity among music programming languages—ChucK is also a strongly-typed language and is also built around a temporal model that facilitates precise control over audio processing and exact synchronization and scheduling of musical events. Like SuperCollider, the ChucK architecture supports on-the-fly programming, enabling composers and performers to modify and manipulate algorithms in real time during a performance, a feature that’s been critical to its success in various laptop “orchestras.” ChucK is particularly well suited to live coding, interactive performance, and experimental music projects. Additionally, ChucK’s capacity for handling concurrency and a robust timing model allows developers to explore complex audio synthesis, algorithmic composition, and digital signal processing with a high degree of control and creativity.

Connecting ChucK to Eurorack

Setting up ChucK to control your Eurorack might be even more concise than setting up SuperCollider, although there are some surprises further afield. Designed for live coding, ChucK’s syntax prioritizes brevity. Setting up a simple sine-wave oscillator to function as a 1hz low-frequency oscillator can be done in just four terse lines of code:

SinOsc s => dac;

0.1 => s.gain;

1 => s.freq;

while ( true ) 1::day => now;

You’ll notice that, unlike virtually all modern programming languages, assignment in ChucK functions from left to right (expressions, on the left, are assigned to variables on the right), although the ChucK operator (=>) does vastly more than just assignment. The ChucK operator can also be used to call functions and even to indicate the signal flow between sound sources, effects, and the sound-card abstraction, which neatly simulates patching in code!

You might also notice that we specify time here. In this case, time is specified as an infinite loop, but ChucK supports a variety of temporal abstractions ranging from a single sample to a duration of one week. This is what the ChucK language specification refers to as “strongly-timed” programming. By mandating the explicit management of time within the code, ChucK enables composers and sound artists to synchronize sounds with incredible accuracy, effectively turning the programming environment itself into an instrument.

Sequencing in ChucK (example 2) is simple using ChucK’s built in Step unit generator (or UGen for short). (Think of a UGen like a Eurorack module. Each UGen does a different job; some make sounds while others can control parts of the sound or apply effects.) The Step UGen works almost identically to a sample and hold circuit. The Step UGen takes a value and holds it for all following samples until its value is updated.

Just as in other audio programming environments such as Max, Pd, and SuperCollider, we use a simple function in ChucK to transform MIDI note numbers into decimal values. These decimals are then used as DC voltage by our interface, effectively becoming control voltage for our Eurorack system. A notable difference in ChucK is the need to explicitly define both the input and output types in our generateCVValue function. This ensures clarity in what the function is doing and what types of data it handles.

Controlling a sequence over time in ChucK is pretty straightforward, much like what you'd expect if you're familiar with any high-level programming language. We create a sequence by using a loop that goes through each MIDI note, converting it into a decimal value suitable for the Step UGen to use. This loop isn't just about conversion; it also sets the pace of our sequence. By including a duration of 200 milliseconds before the loop repeats, we introduce a rhythmic element to the sequence. This simple timing mechanism is an effective way to add a sense of rhythm to our sequences, making the process both intuitive and efficient for creating musical patterns.

[Figure 4: A simple sequence in ChucK, optimized for a DC-coupled Eurorack interface. (see code example)]

One Last Hack: Using Max/MSP as a Receiver via OSC

The majority of this article has focused on demystifying the process of sending DC voltage directly from your programming environment to your Eurorack via a DC-coupled audio interface, but there is a way to integrate various programming environments with your synthesizer while still using Max/MSP or Pure Data as a receiver and soundcard abstraction.

Open Sound Control functions like a data pipeline, allowing you to route arbitrary data from an application sending data to an application receiving it. It does this using a network-based protocol where a client application sends OSC messages to a server application, which listens for incoming messages on a specific IP address and port number.

With OSC we can do all our sequencing in SuperCollider, send the sequence as a stream of numbers to Max/MSP, and use Max/MSP to route that voltage to our Eurorack. Or we can use Max/MSP to integrate a haptic controller, send the output of that controller to SuperCollider, and then use SuperCollider to synthesize some audio which is then sent to our Eurorack. With OSC it’s even possible to control your Eurorack with the accelerometers in your cellphone, using a Max patch or Pd as a receiver on your laptop.

OSC is quick to get up and running and is supported by most audio programming environments including Max/MSP, Pure Data, SuperCollider, and ChucK. There’s even a JavaScript library called osc.js on NPM, so if you want to control your Eurorack with a website or React Native app, you can do that!

Conclusion

While controlling a hardware synthesizer with Max/MSP, Pure Data, or a text-based scripting language is not for everyone, getting started is easier than most musicians assume. The key to unlocking this potential often lies in starting simple: exploring a basic example and tweaking it to be your own. The initial effort to grasp the necessary syntax is quickly rewarded by the vast creative possibilities this approach unlocks.