So You Want to Build a Synthesizer: A Ghost's Guide to Making Noise on Purpose

Let's get something out of the way first.

You don't need to know how to solder. You don't need a Eurorack case, a Moog Sub37, a vintage Roland SH-101 in powder blue, or a room full of patch cables that cost more than a semester of community college. You don't need to have grown up in Düsseldorf or spent three years as Giorgio Moroder's assistant or been in a Brooklyn loft in 1983 with a beatbox and a Roland TR-808 that everyone thought sounded like a broken drum set.

What you need is curiosity about sound and the willingness to feel like an idiot for about two hours while you figure out why it makes noise at all.

Everything else follows from that.

---

What a Synthesizer Actually Is

Before you build one, you should know what you're building. Not the marketing version — the actual thing.

A synthesizer is a machine for making sound from electricity. That's it. The complexity people associate with synthesizers — the patch cables, the knobs, the modular systems that cost more than a car — is all in service of that one idea: take electrical signals and shape them until they make the sound you want.

Sound is vibration. Vibration is waves. Waves have a few properties that matter: frequency (how fast they oscillate, which we hear as pitch), amplitude (how large they are, which we hear as volume), and shape (which we hear as timbre — the difference between a piano and a violin playing the same note).

A synthesizer generates waves and then gives you tools to manipulate those three properties. That's the whole thing. Kraftwerk understood this. Moroder understood this. The engineers at Moog understood this. The kid in 1982 who figured out that an 808's bass drum could be tuned to a pitch and used as a bass line understood this, and that understanding changed popular music permanently.

You're going to understand it too.

---

The Building Blocks

Every synthesizer, from a 1970s Moog modular the size of a refrigerator to a softsynth plugin running in your DAW to the thing we're about to build, has the same core architecture. Learn these four pieces and you understand every synthesizer ever made.

1. Oscillator (VCO)

The oscillator generates the raw wave. This is the sound source — the thing that actually vibrates. It produces a basic waveform at a given frequency. The most common shapes:

Sine wave — Pure tone, single frequency, no harmonics. What a tuning fork makes. Clean, simple, slightly boring. What Giorgio Moroder's sequenced basslines were built from, layered and processed until they weren't boring at all.

Square wave — Flips between full-on and full-off. Rich in odd harmonics. Has that hollow, reedy quality. Lots of early video game music. Lots of post-punk. The Minimoog's oscillators could do this. So can yours.

Sawtooth wave — Ramps up, drops instantly, ramps up again. The most harmonically rich of the basic shapes — full of both odd and even harmonics. This is the wave that makes synthesizers sound like synthesizers. The Kraftwerk lead sounds. The Moroder strings. The MGMT arpeggios on Time to Pretend that sound like the 80s dreamed them and 2007 made them real.

Triangle wave — Somewhere between sine and square. Softer harmonics, gentler sound.

2. Filter (VCF)

The filter is where personality lives. You take the harmonically rich oscillator output and cut or boost specific frequency ranges. The most important filter in synthesis history is the low-pass filter, which lets low frequencies through and cuts high ones. Sweep a low-pass filter up and you get that classic synthesizer "open up" sound — what the 303 bassline does, what the acid house producers discovered could make people lose their minds at 130 BPM.

The filter has a cutoff frequency (where it starts cutting) and a resonance control (how much it emphasizes the frequencies right at the cutoff, which at high settings creates that characteristic synth squeal).

3. Amplifier (VCA)

Controls volume over time. Not much more to it — it's the gain stage. The interesting part is what controls the amplifier.

4. Envelope (ADSR)

The envelope is time. It's the shape of a sound from start to finish.

Attack — How long it takes to reach full volume after a note is triggered. Decay — How long it takes to fall from the attack peak to the sustain level. Sustain — The level it holds while the note is held. Release — How long it takes to fade after the note is released.

A piano has a fast attack, fast decay, no sustain, and a medium release. A string section has a slow attack, slow decay, high sustain, and a slow release. Change those four numbers and you change the entire character of a sound. The 808's iconic kick drum is a sine wave with a very fast attack, instant decay, no sustain, and no release — plus a pitch envelope that drops fast. That's the whole secret. That's what changed hip hop.

ADSR Visualization:

Volume
  |
  |     /\
  |    /  \
  |   /    \______
  |  /              \
  | /                \
  |/                  \___
  +--A---D---S--------R-----> Time

---

Let's Build One

Here's where we stop talking about synthesizers and start building one. In Python, in your browser, with no hardware required. The first version will make sound. The second version will make something you might actually want to listen to.

Step 1: The Oscillator in Python

import numpy as np
import sounddevice as sd

# Sample rate: 44100 Hz is CD quality
# This is how many samples per second we generate
SAMPLE_RATE = 44100
DURATION = 2.0  # seconds

def oscillator(frequency, waveform='sine', duration=DURATION, sample_rate=SAMPLE_RATE):
    """
    Generate a basic waveform.
    frequency: pitch in Hz (440 = A4, concert pitch)
    waveform: 'sine', 'square', 'sawtooth', 'triangle'
    """
    t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
    
    if waveform == 'sine':
        wave = np.sin(2 * np.pi * frequency * t)
    
    elif waveform == 'square':
        wave = np.sign(np.sin(2 * np.pi * frequency * t))
    
    elif waveform == 'sawtooth':
        # Sawtooth: ramps from -1 to 1 each cycle
        wave = 2 * (t * frequency - np.floor(t * frequency + 0.5))
    
    elif waveform == 'triangle':
        wave = 2 * np.abs(2 * (t * frequency - np.floor(t * frequency + 0.5))) - 1
    
    return wave.astype(np.float32)

# Make some noise
wave = oscillator(440, waveform='sawtooth')
sd.play(wave, SAMPLE_RATE)
sd.wait()

Install the dependencies first:

pip install numpy sounddevice

Run that. You'll hear a raw sawtooth wave at A4 (440 Hz). It sounds harsh and buzzy. That's correct. That's the raw material. Everything else is shaping it.

Step 2: The Envelope

def adsr_envelope(duration, attack, decay, sustain_level, release,
                  sample_rate=SAMPLE_RATE):
    """
    Returns an amplitude envelope array.
    All time values in seconds. sustain_level is 0.0 to 1.0.
    """
    total_samples = int(duration * sample_rate)
    envelope = np.zeros(total_samples)
    
    a_samples = int(attack * sample_rate)
    d_samples = int(decay * sample_rate)
    r_samples = int(release * sample_rate)
    s_samples = total_samples - a_samples - d_samples - r_samples
    s_samples = max(0, s_samples)
    
    # Attack: ramp up
    envelope[:a_samples] = np.linspace(0, 1, a_samples)
    
    # Decay: ramp down to sustain
    envelope[a_samples:a_samples+d_samples] = np.linspace(1, sustain_level, d_samples)
    
    # Sustain: hold
    envelope[a_samples+d_samples:a_samples+d_samples+s_samples] = sustain_level
    
    # Release: ramp down to zero
    envelope[total_samples-r_samples:] = np.linspace(sustain_level, 0, r_samples)
    
    return envelope.astype(np.float32)

# Sawtooth wave shaped by an envelope
wave = oscillator(440, waveform='sawtooth', duration=2.0)
env = adsr_envelope(
    duration=2.0,
    attack=0.01,     # fast attack
    decay=0.1,       # quick decay
    sustain_level=0.6,
    release=0.3      # smooth release
)

shaped = wave * env

sd.play(shaped, SAMPLE_RATE)
sd.wait()

Same frequency. Same waveform. Completely different character. The envelope is doing all of it.

Step 3: The Filter

from scipy import signal

def low_pass_filter(wave, cutoff_hz, resonance=0.7, sample_rate=SAMPLE_RATE):
    """
    Simple low-pass filter.
    cutoff_hz: filter cutoff frequency
    resonance: Q factor (higher = more resonant peak at cutoff)
    """
    # Normalize cutoff to Nyquist frequency
    nyquist = sample_rate / 2
    normalized_cutoff = cutoff_hz / nyquist
    normalized_cutoff = np.clip(normalized_cutoff, 0.001, 0.999)
    
    # Butterworth filter — smooth rolloff, no ripple
    b, a = signal.butter(2, normalized_cutoff, btype='low', analog=False)
    filtered = signal.lfilter(b, a, wave)
    
    return filtered.astype(np.float32)

# Now: oscillator → envelope → filter
wave = oscillator(110, waveform='sawtooth', duration=3.0)  # low A
env = adsr_envelope(3.0, attack=0.05, decay=0.2, sustain_level=0.7, release=0.5)
shaped = wave * env

# Apply filter — try changing cutoff_hz from 200 to 3000 and hear the difference
filtered = low_pass_filter(shaped, cutoff_hz=800)

sd.play(filtered, SAMPLE_RATE)
sd.wait()

Install scipy:

pip install scipy

Now change cutoff_hz from 200 to 4000 and run it again. That's the filter opening up. That's the sound. That's what synthesizers do.

Step 4: Play a Sequence

def note_to_hz(note_name):
    """Convert note names to frequencies. A4 = 440 Hz."""
    notes = {'C': 0, 'C#': 1, 'D': 2, 'D#': 3, 'E': 4, 'F': 5,
             'F#': 6, 'G': 7, 'G#': 8, 'A': 9, 'A#': 10, 'B': 11}
    
    name = note_name[:-1]
    octave = int(note_name[-1])
    semitones = (octave - 4) * 12 + notes[name] - 9  # relative to A4
    return 440.0 * (2 ** (semitones / 12))

def play_sequence(sequence, bpm=120, waveform='sawtooth'):
    """
    sequence: list of (note, duration_in_beats) tuples
    bpm: tempo
    """
    beat_duration = 60.0 / bpm
    audio_parts = []
    
    for note, beats in sequence:
        dur = beats * beat_duration
        freq = note_to_hz(note)
        
        wave = oscillator(freq, waveform=waveform, duration=dur)
        env = adsr_envelope(dur, attack=0.01, decay=0.05,
                            sustain_level=0.7, release=0.08)
        shaped = wave * env * 0.4  # scale amplitude down
        filtered = low_pass_filter(shaped, cutoff_hz=1200)
        audio_parts.append(filtered)
    
    full_audio = np.concatenate(audio_parts)
    sd.play(full_audio, SAMPLE_RATE)
    sd.wait()

# A simple descending sequence
# Tweak the notes and watch it turn into something
sequence = [
    ('A3', 0.5), ('G3', 0.5), ('F3', 0.5), ('E3', 0.5),
    ('D3', 0.5), ('C3', 0.5), ('D3', 0.5), ('E3', 1.0),
]

play_sequence(sequence, bpm=120, waveform='sawtooth')

You now have a sequenced synthesizer running in Python. Moroder was doing this with a Moog and a multitrack tape recorder. You're doing it with a laptop and twenty-dollar libraries. The underlying physics is identical.

---

Where This Goes

The above is a synthesizer. It's a basic one, but it has all four core components. From here, the directions you can take it are essentially unlimited.

Add a second oscillator and detune it slightly. Two oscillators at nearly — but not exactly — the same pitch create a beating interference pattern that sounds massive. This is called "supersaw" or "unison" in most synths. It's why EDM leads sound like that.

Modulate the filter cutoff with an LFO. A Low Frequency Oscillator is an oscillator running below the range of human hearing — under 20 Hz — that controls another parameter instead of making sound directly. Point an LFO at the filter cutoff and the filter opens and closes rhythmically. That's the "wah" sound. Point it at pitch and you have vibrato. Point it at amplitude and you have tremolo.

Add reverb and delay. The dry synthesizer signal you've been building lives in a dead, anechoic space. Reverb puts it in a room. Delay creates echoes. These aren't synthesizer features specifically — they're effects — but the difference between a dry synth and a processed one is the difference between a sketch and a finished painting.

Go modular. If you want to go deeper into hardware, the Eurorack modular format is the endgame rabbit hole. Individual modules — oscillators, filters, envelopes, effects — that you connect with patch cables. Every connection is a decision. The system is as complex as you make it. People build systems worth thousands of dollars. People also buy a few used modules and make genuinely interesting music. It's not about the gear.

Use a DAW. If you want to use what you've learned here but in a production environment, every major DAW (Ableton, Logic, FL Studio) ships with software synthesizers that implement everything above with a GUI. Knowing what the knobs actually do — what attack means, what the filter cutoff is, why the resonance sounds the way it does — is what separates people who make interesting music from people who move sliders and hope.

---

The Reference Library You Owe Yourself

You cannot understand synthesizers without listening to the people who built the vocabulary.

Autobahn — Kraftwerk (1974). Twenty-two minutes. Built from custom-built synthesizers and vocoders in a studio in Düsseldorf by four German guys who decided that machines were more interesting than rock bands. They were right. Every electronic music genre that came after this — techno, electro, synth-pop, EDM, ambient — traces a line back to this record.

I Feel Love — Giorgio Moroder & Donna Summer (1977). The first fully synthesized number one hit. Moroder sequenced everything on a Moog modular and then ran Donna Summer's vocal over the top. It sounds like it was recorded yesterday. Brian Eno heard it and told a journalist it had changed the face of pop music. He wasn't wrong.

Planet Rock — Afrika Bambaataa & Soulsonic Force (1982). Took the Kraftwerk drum patterns, ran them through a Roland TR-808, added a vocoder, and invented electro. Hip hop was never the same. The 808 kick drum on this record is a sine wave with a pitch envelope. The kids who figured out you could tune it and use it as a bass line invented an entire sonic universe from that one insight.

MGMT — Oracular Spectacular (2007). The 21st century's answer to all of the above. Time to Pretend opens with a sawtooth arpeggio that sounds like it was borrowed from 1983 and run through fifteen years of nostalgia and irony. The production is synth-forward, maximalist, and completely its own thing. If you're under 30 and this is your entry point into synthesizers, there are worse doors.

---

The Permission Slip

Here's the thing nobody tells you when you're starting: synthesizers are not intimidating because they're complicated. They're intimidating because the people who know about them sometimes want them to seem complicated.

The physics is four concepts. The code above is four functions. The vocabulary — oscillator, filter, envelope, LFO — is a dozen words. What takes time is ear training, aesthetic judgment, and the patience to sit with a sound and understand what it needs.

That part cannot be taught in an article. That part you do by making noise, deciding you hate it, figuring out why, and making different noise. That process is the same whether you're in a Düsseldorf studio in 1974 or a Brooklyn bedroom in 2026.

Kraftwerk didn't wait for someone to explain synthesizers to them. They built the ones they needed.

You have a Python runtime and sounddevice. Run the code. Change the numbers. Break it. Fix it. Make something that sounds bad and then make it sound less bad.

That's the whole tutorial.

---

GhostInThePrompt.com // Kraftwerk didn't wait for permission. You have fewer excuses than any of them.