A polysynth from Ecuador

There is no completely neutral place from which to design an instrument. Every synthesizer reflects technical decisions, visual references, and listening habits shaped by the people and environments behind it.

Instruments created in the United States, Europe, and Japan shaped much of the vocabulary of modern subtractive synthesis. Andes JX builds on that legacy while articulating it from a different territory: Quito, Ecuador.

Andes JX is an open-source polyphonic subtractive synthesizer developed in C++ with the JUCE framework. It was conceived as a musical instrument, an open software project, and a platform for studying digital signal processing and audio software architecture.

In 2026, Andes JX was presented at AES LAC 2026 in Lima, Peru, as part of the convention’s technical program.

The project does not attempt to invent a new synthesis paradigm. Instead, it asks what happens when a familiar architecture is designed from a different geography, visual memory, and cultural perspective.

A familiar architecture from a different place

From a technical perspective, Andes JX uses the fundamental building blocks of subtractive synthesis: oscillators that generate harmonically rich signals, filters that reshape their spectrum, envelopes that control their evolution over time, and a low-frequency oscillator for modulation.

In addition, the instrument includes two oscillators with PolyBLEP-based aliasing reduction, independent amplitude and filter envelopes, global LFO modulation, multiple polyphony modes, glide, keyboard tracking, velocity sensitivity, and MIDI control.

One of its most significant sonic decisions is the inclusion of two switchable filter models.

The first is a State Variable Filter based on a topology-preserving structure. It provides a stable and controlled response while supporting several filtering modes within a flexible architecture.

By contrast, the nonlinear Moog Ladder filter introduces stronger saturation and a more pronounced resonant character.

Together, these two filters reflect one of the instrument’s central design principles: keep the architecture focused, but ensure that each decision produces an audible result. Andes JX does not aim to provide unlimited modules or endless modulation routing. Instead, its interface offers a deliberate set of controls, each with a clearly defined role.

Andean geography as identity

The Andean identity of Andes JX is not intended to reproduce Ecuadorian traditional music literally or to translate a landscape directly into sound. Instead, it appears through visual, conceptual, and sonic decisions that place the instrument within a specific territory.

Visual language

The interface uses a slate-blue palette, soft off-white text, and a restrained composition inspired by stone, mist, sky, and the high-altitude landscapes of the Ecuadorian Andes.

Rather than relying on bright accent colors or a futuristic aesthetic, the instrument adopts a contained visual language intended to suggest openness, stability, and the severity of mountain environments.

Factory presets

The 33 factory presets are named after real locations in the Ecuadorian Andes, combined with musical or timbral references.

Examples include:

• Cotopaxi Acid;
• Cayambe 5th;
• Imbabura Pedal;
• Quilotoa Aqua;
• Páramo Sostenuto.

These names propose associations between geography and sonic character. They are not intended as literal representations of each place. Instead, the names, landscapes, and cultural associations provide starting points for sound design.

The bank retains familiar subtractive-synthesis categories such as basses, pads, leads, brass, keys, plucks, and effects. However, it presents them through an identity connected to Ecuadorian geography.

An open educational project

Andes JX was not developed only as a production tool. It was also designed to show how a complete polyphonic synthesizer is organized internally.

The source code is available under the GNU GPL v3 license, together with bilingual documentation in English and Spanish. Its architecture separates the main responsibilities of the system:

• DSP processing;
• plugin, parameter, and MIDI management;
• preset handling;
• graphical interface;
• host integration.

This separation allows individual modules to be studied independently while also showing how they interact within a real-time audio application.

Technical and academic references accompany the PolyBLEP oscillators, Moog Ladder filter, and State Variable Filter implementations. In this way, a student or developer can begin with the source code, consult the original publications, and follow the path from a mathematical concept to its application within a functional instrument.

The project does not claim to present the only correct synthesizer architecture. Its educational value lies in offering a complete implementation that can be read, tested, questioned, and modified.

The JX lineage

The name Andes JX acknowledges two lines of influence.

The first comes from the Roland JX family of polyphonic synthesizers, known for their subtractive architecture and their association with the analog instruments of the 1980s.

The second belongs to open and educational software.

Andes JX grew from the study of JX11, the educational synthesizer developed in JUCE by Matthijs Hollemans for Creating Synthesizer Plug-Ins with C++ and JUCE. JX11, in turn, is related to MDA JX10, the freeware synthesizer created by Paul Kellett and later released as open-source software.

Andes JX continues that lineage while expanding the architecture, documentation, visual identity, and academic purpose of the project.

The term “JX” therefore acknowledges its technical ancestry, while “Andes” defines the place from which that lineage continues.

From NoiseRoomUIO to AES LAC 2026

Andes JX is part of the NoiseRoom UIO project catalog, alongside Classic Compressor CCMkI and NoiseRverb.

Although each plugin addresses a different technical problem, all three share a common intention: combining audio software development with an identity connected to the context in which the projects were created.

NoiseRverb used impulse responses captured in architectural spaces in Quito. Andes JX extends that search into synthesis and virtual instrument design.

The development of the synthesizer also led to the academic paper:

“Design and Architecture of a Polyphonic Subtractive Synthesizer as a Modular Structure for Teaching DSP and Audio Software.”

The paper was selected by the AES LAC 2026 review committee and presented at the convention in Lima, Peru. It examines how a functional synthesizer can serve as an object of study for teaching digital signal processing and audio software engineering.

Presenting Andes JX at AES LAC 2026 provided an opportunity to share work developed in Ecuador with a Latin American community of researchers, educators, engineers, and audio developers.

Try Andes JX

You can download Andes JX as a VST3 plugin for Windows.

The project includes:

• 33 factory presets;
• C++ source code;
• a bilingual user manual;
• technical documentation in English and Spanish;
• a modular architecture built with JUCE;
• GNU GPL v3 licensing.

You can download the instrument, explore the source code, and review the documentation through the following links:

Download Andes JX
GitHub repository
User manual

Andes JX is an Andean synthesizer built in Ecuador, inspired by the Andes, and designed to be heard, studied, and transformed.

Development: NoiseRoomUIO, Quito, Ecuador
Authors: Jhonatan López and Valeria Villarreal
Academic context: work developed in connection with the Numerical Simulation and Computational Analysis Laboratory at Escuela Politécnica Nacional

The post Andes JX: A Synthesizer from Latitude Zero appeared first on Jhonatan López.

New blog post — I’ve been meaning to write this for a long time. It’s about a concept that has fascinated me from the moment I encountered it. I’ll also share a small contribution I made in this area with NoiseRverb, a heritage acoustics plugin that captures the sonic identity of historic churches in Quito through convolution reverb.

We often associate heritage with visual beauty—particularly in architecture. This connection largely stems from the preservation of artistic landmarks due to their historical significance. As a result, many of these sites have become popular tourist attractions.

But what if we consider a different kind of heritage — one we can hear? Can sound hold historical value? Can it be preserved? The answer is yes. While this isn’t a new idea — researchers have studied it before — it’s starting to find its place in the audio industry as well.

While some heritage spaces are preserved through sound art, others live on through live recordings or songs. For example, the Festival Internacional de Música Sacra (FIMUSAQ) in Quito has helped preserve local culture through sacred music. While it’s not the only example globally, it clearly shows how sound can carry historical weight.

What Is Heritage Acoustics?

Heritage acoustics is a field that explores and protects the sound of historic spaces. It combines architecture, physics, and sound engineering. From cathedrals to theatres, their sound is as iconic as their structure.

The goal is to study how sound behaves in these spaces. It involves looking at reverberation, reflections, absorption, and how sound waves move. There are three main techniques used:

• On-site measurements: Microphones and speakers are placed in the space. Specific signals are played (like sine sweeps), and the room’s response is recorded. This captures real acoustic data.
• Impulse response (IR) capture: This technique records how a room reacts to a quick, broad sound. The result is a unique audio fingerprint of the space.
• Computer modelling: 3D simulations of the space are created using architectural drawings. This allows engineers to predict how sound will behave, even without access to the real location.

These methods help protect the unique sound of historical buildings and let others experience it — even from far away.

Applications in the Music Industry

The study of heritage acoustics has led to exciting tools for musicians and producers. These include:

• Convolution reverb plugins that recreate historic spaces.
• Acoustic modelling for virtual concerts.
• Restoring old recordings with their original acoustics.
• Immersive museum or VR audio experiences.

All of these are interesting, but I’ll focus on convolution reverb, as it’s where I work most.

Convolution Reverb

To understand convolution reverb, you need to know what an impulse response (IR) is. An IR is a recording of how a space reacts to a short, full-range sound — like a clap or a burst of noise. It contains key information about the room’s reflections and decay.

There are many ways to create an IR: clapping, popping a balloon, or playing a sine sweep. The results are similar, no matter the method.

Convolution reverb takes this IR and applies it to any audio signal. The result is a realistic simulation of how that signal would sound in the original space. This is done using a mathematical process called convolution. It combines the original sound with the impulse response to recreate the acoustic experience.

This technique is popular for its realism. It lets musicians take a studio recording and place it in a real, historic space — without leaving their DAW.

Heritage Acoustics Plugin

As part of our exploration, I worked with engineers Analí Pinto and Fausto Espinoza to create a VST3 plugin called NoiseRverb. It’s based on impulse responses captured in seven churches in Quito: San Francisco, Basílica, Catedral, Compañía, Guápulo, El Sagrario, and Santo Domingo.

The plugin lets musicians and producers experience these spaces inside their usual music-making software.

We recorded the impulse responses on-site and processed them digitally. Then, we used real-time convolution to bring those spaces to life inside the plugin. The result is an authentic, immersive experience.

NoiseRverb is free to download here.

Learn more about heritage acoustics and its role in cultural preservation in this introductory article on architectural acoustics and in the study on acoustic and perceptual variables in three heritage churches of Quito.

The post NoiseRverb: Heritage Acoustics in a Plugin appeared first on Jhonatan López.

Have you ever wondered how machines understand the nuances of sound? In my previous post, we explored spectral analysis and learned how spectrograms reveal the frequency content of audio signals using the Short-Time Fourier Transform (STFT). Now, let’s dive deeper into advanced spectral representations for audio analysis, including Mel Spectrograms, CQT, and HCQT, and show how they can be used for perceptual audio analysis and feature extraction. These tools are essential for building machine learning models for tasks like audio classification, a field I’m currently exploring.

Why Feature Extraction?

Spectral analysis provides us a visual map of audio frequencies, but for machine learning, we need compact, meaningful features that capture the essence of sound. Raw spectrograms are rich but high-dimensional, making them inefficient for direct use in models. By refining them into perceptually relevant or musically meaningful representations, we can extract features that align with how we hear or interpret audio. This is crucial for applications like genre classification, pitch detection, or environmental sound recognition.

Advanced Spectral Representations

Let’s explore three advanced spectral representations that address the limitations of STFT-based spectrograms: Mel Spectrograms, Constant-Q Transform (CQT), and Harmonic-CQT (HCQT). Each of these tools offers unique advantages for audio analysis and feature extraction.

Mel Spectrogram (MEL) and Log-Mel Spectrogram (LMS)

What Are They?

The Mel Spectrogram adapts the STFT to the Mel scale, a perceptual scale of pitch that reflects how humans hear frequency differences (e.g., we’re more sensitive to changes at lower frequencies). It compresses the frequency axis into Mel bins, reducing dimensionality while prioritizing auditory perception. The Log-Mel Spectrogram takes this further by applying a logarithmic transformation to the amplitude, mimicking the logarithmic response of our ears to loudness.

Why Use Them?

• Perceptual Relevance: Mel Spectrograms align with human hearing, making them ideal for speech and music analysis.
• Machine Learning Ready: Log-Mel Spectrograms are compact and widely used as input features for deep learning models.

Example in Python

```python
import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np
from google.colab import drive

# Mount Google Drive
drive.mount('/content/drive')

# Load audio
y, sr = librosa.load('/content/drive/My Drive/audio_files/sample.wav')

# Compute Mel Spectrogram
S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
S_db = librosa.power_to_db(S, ref=np.max)  # Log-Mel Spectrogram

# Plot
plt.figure(figsize=(14, 5))
librosa.display.specshow(S_db, sr=sr, x_axis='time', y_axis='mel')
plt.colorbar(format='%+2.0f dB')
plt.title('Violin Log-Mel Spectrogram')
plt.show()
```

• n_mels=128: Number of Mel bins (adjustable based on your needs).
• Output: Time vs. Mel frequency, with colour showing log-amplitude.

Constant-Q Transform (CQT)

What Is It?

The Constant-Q Transform (CQT) is an alternative to STFT that uses a logarithmic frequency scale, where the frequency resolution is constant relative to the center frequency (constant Q-factor). Unlike STFT’s fixed window size, CQT’s window size varies—longer for low frequencies, shorter for high ones.

Why Use It?

• Musical Advantage: Its logarithmic scale matches the intervals of musical notes (e.g., octaves), making it perfect for pitch-related tasks like chord recognition or music transcription.
• Better Resolution: It captures low-frequency details (e.g., bass notes) better than STFT.

Example in Python

The following example was implemented following the code used before.

```python
# Compute CQT
C = librosa.cqt(y, sr=sr)
C_db = librosa.amplitude_to_db(abs(C), ref=np.max)

# Plot
plt.figure(figsize=(14, 5))
librosa.display.specshow(C_db, sr=sr, x_axis='time', y_axis='cqt_note')
plt.colorbar(format='%+2.0f dB')
plt.title('Violin Constant-Q Transform')
plt.show()
```

y_axis=’cqt_note’: Labels the y-axis with musical notes (e.g., C4, D4), emphasizing its musical focus.

Harmonic-CQT (HCQT)

What Is It?

The Harmonic Constant-Q Transform (HCQT) extends CQT by analysing harmonic structures. It computes CQTs at multiple harmonic multiples (e.g., fundamental frequency and its overtones) and stacks them into a 3D representation.

Why Use It?

• Pitch-Related Applications: HCQT excels at separating harmonic content (e.g., a piano’s notes) from noise or percussive elements, ideal for pitch detection or source separation.
• Research Edge: It’s advanced and less common, showcasing cutting-edge techniques.

Note on Implementation

`Librosa` doesn’t directly provide HCQT, but you can approximate it by computing CQTs for harmonic multiples manually or use external libraries like `nnAudio`. Here are simplified examples using both libraries:

With `Librosa`:

```python
import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np

# Load audio file
y, sr = librosa.load('/content/drive/My Drive/audio_files/sample.wav', sr=22050)  # Replace with your file path
hop_length = 512  # Number of samples between successive frames
harmonics = [1, 2, 3]  # Harmonics to analyze (fundamental + overtones)

# Compute HCQT for the fundamental (h=1)
fmin = librosa.note_to_hz('C1') * 1  # Convert note C1 to Hz (~32.7 Hz)
n_bins = 60  # Total bins (5 octaves: 60/12 = 5)

# Check Nyquist limit (prevents aliasing)
nyquist_limit = fmin * (2 ** (n_bins / 12)) 
if nyquist_limit < sr / 2:
    # Compute Constant-Q Transform
    cqt = librosa.cqt(y, sr=sr, hop_length=hop_length, 
                     fmin=fmin, n_bins=n_bins, bins_per_octave=12)
else:
    raise ValueError("Nyquist limit exceeded! Adjust parameters.")

# Convert CQT magnitude to decibels (normalized to max amplitude)
cqt_db = librosa.amplitude_to_db(np.abs(cqt), ref=np.max)

# Generate CQT frequency axis (logarithmic scale)
frequencies = librosa.cqt_frequencies(n_bins=n_bins, fmin=fmin, bins_per_octave=12)

# Plot the spectrogram
plt.figure(figsize=(14, 5))
librosa.display.specshow(cqt_db, sr=sr, hop_length=hop_length,
                        y_axis='cqt_hz', x_axis='time',  # Log-frequency axis
                        fmin=fmin, bins_per_octave=12, 
                        vmin=-80, vmax=0)  # dB range and optional colourmap add , cmap='viridis'
plt.colorbar(format='%+2.0f dB', label='Amplitude (dB)')
plt.ylim(frequencies[0], frequencies[-1])  # Set frequency axis limits
plt.title('Violin Harmonic-CQT (Fundamental) - Librosa')
plt.xlabel('Time (s)')
plt.ylabel('Frequency (Hz)')
plt.show()
```

For efficient HCQT computation, we use `nnAudio`, a PyTorch-based library that leverages GPU acceleration. First, install it:

```python
pip install nnAudio
```

Then, run the following code:

```python
import torch
from nnAudio.features.cqt import CQT
import matplotlib.pyplot as plt

# Parameters
sr = 22050  # Sample rate
hop_length = 512  # Hop size
n_bins = 60  # Number of frequency bins (reduced to avoid Nyquist issues)
fmin = 32.7  # Minimum frequency (C1 in Hz)
harmonics = [1, 2, 3]  # Harmonics to compute

# Load audio (using librosa)
y, _ = librosa.load("/content/drive/My Drive/audio_files/sample.wav", sr=sr)

# Convert to PyTorch tensor
y_tensor = torch.tensor(y).float()

# Compute HCQT for each harmonic
hcqt = []
for h in harmonics:
    cqt = CQT(sr=sr, hop_length=hop_length, n_bins=n_bins,
              fmin=fmin * h, bins_per_octave=12, output_format='Magnitude')
    cqt_output = cqt(y_tensor)  # Shape: (1, n_bins, time)
    cqt_db = 20 * torch.log10(torch.clamp(cqt_output, min=1e-5))  # Avoid log(0)
    hcqt.append(cqt_db)

# Plot the fundamental harmonic
if hcqt:
    plt.figure(figsize=(14, 5))
    plt.imshow(hcqt[0].squeeze().numpy(), aspect='auto', origin='lower', cmap='viridis', vmin=-80, vmax=0, interpolation='bilinear')
    plt.colorbar(format='%+2.0f dB')
    plt.title('Violin Harmonic-CQT (Fundamental) - nnAudio')
    plt.xlabel('Time')
    plt.ylabel('Frequency (bins)')
    plt.show()
```

What Do These Representations Tell Us?

• Mel/Log-Mel: Highlights perceptually significant frequencies (e.g., speech formants or musical timbre).
• CQT: Reveals musical structure (e.g., note transitions in a melody).
• HCQT: Isolates harmonic patterns (e.g., a chord’s overtones), distinguishing pitched sounds from noise.

These features are more targeted than raw STFT spectrograms, making them powerful inputs for machine learning models.

Reflection

Exploring these spectral representations has been a transformative experience for me. Initially, I relied heavily on STFT, but discovering Mel Spectrograms showed me how aligning analysis with human perception could significantly boost classification accuracy—something I’m currently testing with various audio datasets. Implementing CQT was a revelation for its musical precision, though working with HCQT pushed my coding skills to the limit. I spent hours digging into research papers and experimenting with harmonic stacking to get it right. These challenges have deepened my understanding of audio feature extraction and increased my excitement for applying these techniques to machine learning models.

Conclusion

Spectral representations like Mel Spectrograms, CQT, and HCQT take us beyond basic spectrograms, offering perceptually and musically relevant features for audio analysis.

In this post, we’ve explored advanced spectral representations for audio analysis, including Mel Spectrograms, CQT, and HCQT, and seen how they can be used for audio analysis and feature extraction. These tools take us beyond waveforms and basic spectrograms, offering perceptually and musically relevant features that are essential for machine learning tasks.

Additional Resources

• Librosa Documentation: librosa.org/doc
• nnAudio: nnAudio 0.2.0
• Deep Learning 101 for Audio-based MIR, ISMIR 2024 Tutorial by Geoffroy Peeters et al. (2024).
• Z. Rafii, “The Constant-Q Harmonic Coefficients: A timbre feature designed for music signals [Lecture Notes],” in IEEE Signal Processing Magazine, vol. 39, no. 3, pp. 90-96, May 2022, doi: 10.1109/MSP.2021.3138870. keywords: {Cepstral analysis;Instruments;Transforms;Speech recognition;Power system harmonics;Harmonic analysis;Feature extraction},
• K. W. Cheuk, H. Anderson, K. Agres and D. Herremans, “nnAudio: An on-the-Fly GPU Audio to Spectrogram Conversion Toolbox Using 1D Convolutional Neural Networks,” in IEEE Access, vol. 8, pp. 161981-162003, 2020, doi: 10.1109/ACCESS.2020.3019084.

The post AllYouNeedIsSound 3: Spectral Representations and Feature Extraction appeared first on Jhonatan López.