Create a Drum Machine with Python and Pygame

Drum machines have been a staple in music production and live performance for decades. From the early analog rhythm boxes of the 1960s to modern digital workstations, these devices allow users to compose and perform rhythmic patterns using a selection of drum and percussion sounds. Building your own software drum machine is a great way to understand the core concepts behind these tools while creating something you can actually use in your own music-making.

In this guide, we‘ll create a fully-featured drum machine using Python and Pygame. Our virtual device will include 16 pads for triggering samples, a sequencer for creating patterns, and controls for tempo, swing, and randomization. By the end, you‘ll have a working app to use in your own productions or as a starting point for further experimentation.

Setting up the project

Before we start coding, make sure you have Python 3.x and Pygame installed. You can install Pygame with pip:

pip install pygame

Next, create a new directory for the project and add the following files and folders:

• main.py – this will contain the main logic of our app
• sounds/ – a directory to store the drum samples
• fonts/ – a directory containing any custom fonts used in the interface
• gui/ – a directory to organize the code for our graphical interface elements

For the drum sounds, you can either source your own samples or use a free sample pack. Make sure the samples are in WAV format and place them in the sounds directory. In this example, we‘ll assume there are 16 samples named kick.wav, snare.wav, hihat.wav, etc.

Creating the interface

Let‘s start by coding the basic layout of the drum machine interface. Open up main.py and add the following code:

import pygame
from pygame import mixer

pygame.init()
mixer.init()

# Load drum samples
samples = []
for i in range(16):
    samples.append(mixer.Sound(f"sounds/sample{i+1}.wav"))

# Set up the display
width, height = 800, 600
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("Drum Machine")
clock = pygame.time.Clock()

# Colors
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GRAY = (128, 128, 128) 
RED = (255, 0, 0)

def draw_interface():
    # Draw 16 drum pads
    pad_width = width // 4
    pad_height = height // 4
    for i in range(16):
        x = (i % 4) * pad_width
        y = (i // 4) * pad_height
        pygame.draw.rect(screen, GRAY, (x, y, pad_width, pad_height), 0, 5)
        pygame.draw.rect(screen, WHITE, (x+5, y+5, pad_width-10, pad_height-10), 0, 5)

     # Sequencer grid
    grid_width = width // 2
    grid_height = pad_height
    cell_size = grid_width // 16
    for i in range(16):
        for j in range(4):
            x = width // 2 + i * cell_size
            y = j * grid_height
            pygame.draw.rect(screen, GRAY, (x, y, cell_size, cell_size), 1, 3)

    # Draw buttons and labels
    font = pygame.font.Font("fonts/Roboto-Regular.ttf", 24)
    play_text = font.render("Play", True, WHITE)
    play_rect = play_text.get_rect(center=(pad_width*2, height - 30))
    screen.blit(play_text, play_rect) 
    # ...

running = True
while running:
    # Handle events 
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.MOUSEBUTTONDOWN:
            # Check if pads are clicked
            for i in range(16):
                pad = pygame.Rect((i%4)*pad_width, (i//4)*pad_height, pad_width, pad_height)
                if pad.collidepoint(event.pos):
                    samples[i].play()

    screen.fill(BLACK)
    draw_interface()

    pygame.display.flip()
    clock.tick(60)

This sets up the basic structure of our app, loads the drum samples, and draws the 16 drum pads in a 4×4 grid. It also sets up a 16-step sequencer grid that we‘ll use later for pattern creation. When you run this code, you should see the drum pads and sequencer grid, and be able to trigger the samples by clicking on the pads.

Implementing the sequencer

Now let‘s add the functionality to create sequences using the 16-step sequencer grid. We‘ll use a 2D list called pattern to store which pads are activated on each step.

# Global variables
bpm = 120
pattern = [[0 for _ in range(16)] for _ in range(4)]
playing = False

# ...

def update_sequencer():
    global current_step
    current_step = (current_step + 1) % 16

    # Play activated samples on current step
    for i in range(4):
        if pattern[i][current_step]:
            samples[i*4 + current_step % 4].play()

def draw_interface():
    # ...
    for i in range(16):
        for j in range(4):
            x = width // 2 + i * cell_size
            y = j * grid_height
            if pattern[j][i]:
                pygame.draw.rect(screen, RED, (x, y, cell_size, cell_size), 0, 3) 
            else:
                pygame.draw.rect(screen, GRAY, (x, y, cell_size, cell_size), 1, 3)

    # Highlight current sequencer step
    x = width // 2 + current_step * cell_size
    pygame.draw.rect(screen, WHITE, (x, 0, cell_size, grid_height*4), 3)

# Main loop 
current_step = 0
while running:
    # ...
    elif event.type == pygame.MOUSEBUTTONDOWN:
        # ...
        # Toggle steps in sequencer
        for i in range(16):
            for j in range(4):
                cell = pygame.Rect(width//2 + i*cell_size, j*grid_height, cell_size, cell_size)
                if cell.collidepoint(event.pos):
                    pattern[j][i] = 1 - pattern[j][i]

    if playing:
        if pygame.time.get_ticks() > next_step:
            update_sequencer() 
            next_step += 60000 // (bpm * 4) # 16th note intervals

    # ...

We‘ve added the update_sequencer function which increments the current_step counter and plays any activated samples on that step. The draw_interface function now draws activated steps in the sequencer grid in red, and highlights the current step. We‘ve also added code to the event loop to toggle steps on/off when clicked.

Finally, in the main loop, we check if the sequencer is currently playing (based on the playing flag). If so, we call update_sequencer at the appropriate time intervals based on the current BPM. This creates the repeating sequence!

Adding tempo control

To complete the core functionality of our drum machine, let‘s add the ability to change the tempo using +/- buttons.

def draw_interface():
    # ... 
    tempo_text = font.render(f"Tempo: {bpm}", True, WHITE)
    tempo_rect = tempo_text.get_rect(center=(pad_width*3, height - 30))
    screen.blit(tempo_text, tempo_rect)

    tempo_up_text = font.render("+", True, WHITE)
    tempo_up_rect = tempo_up_text.get_rect(center=(pad_width*3 + 50, height - 50))
    screen.blit(tempo_up_text, tempo_up_rect)

    tempo_down_text = font.render("-", True, WHITE) 
    tempo_down_rect = tempo_down_text.get_rect(center=(pad_width*3 - 50, height - 50))
    screen.blit(tempo_down_text, tempo_down_rect)

# Main loop
while running:
    # ...
    elif event.type == pygame.MOUSEBUTTONDOWN: 
        # ...
        if tempo_up_rect.collidepoint(event.pos):
            bpm += 5
        elif tempo_down_rect.collidepoint(event.pos):
            bpm = max(40, bpm - 5)

Now the tempo can be incremented/decremented in steps of 5 BPM using the +/- buttons. The tempo is also prevented from going below 40 BPM with the max function.

Extra features

With the core functionality in place, you can expand your drum machine with additional features:

• Swing: Implement swing by slightly delaying the playback of even-numbered steps.
• Randomization: Add a button to randomize the current pattern.
• Pattern banks: Allow the user to store and recall multiple patterns.
• Sample management: Provide an interface for loading custom samples and assigning them to pads.
• Effects: Implement effects like reverb or distortion and allow them to be applied to individual pads.
• MIDI output: Add the ability to send MIDI messages to control external hardware or software instruments.

Packaging the app

To share your drum machine with others, you can package it into a standalone executable using a tool like PyInstaller. First, install PyInstaller:

pip install pyinstaller

Then run the following command to create the executable:

pyinstaller --onefile --add-data "sounds:sounds" --add-data "fonts:fonts" main.py

This will generate an executable file in the dist directory that can be run on any machine with the same operating system, even if Python is not installed.

Conclusion

Congratulations, you‘ve created a feature-rich drum machine using Python and Pygame! This project demonstrates how to work with audio samples, create an interactive GUI, implement timing and sequencing, and respond to user input.

You can use this drum machine in your own music productions, live performances, or as a fun tool for practicing rhythms. It‘s also a great starting point for further experimentation – try adding new features, creating unique interfaces, or integrating with other software or hardware.

Building projects like this is an excellent way to develop your skills in Python and multimedia programming. You‘ll gain experience in areas like audio programming, GUI development, event-driven programming, and software architecture that can be applied to a wide range of domains.

I hope this guide has inspired you to create your own musical tools and explore the exciting intersection of music and code. Happy drumming!