Skip to content
TheChatArchiveThe Chat Archive
GPT 5.1· openaiHugging Face Frontier Reasoning Traces

Write a Python program to generate random music using MIDI.

  1. User

    Write a Python program to generate random music using MIDI.

  2. Assistant

    Generating MIDI music program

    The user wants a Python program to generate random music using MIDI. I need to define the scope, considering libraries like MIDIUtil for writing .mid files or mido for playback. Since MIDIUtil is pure Python and easier to work with, I should probably go with that option. I’ll also think about potential library installation issues. I'll provide sample code along with a brief overview of prerequisites and customizations to ensure clarity and usability.Planning a random music generator

    Okay, I need to consider that "random music" might involve defining scales, such as C major, and randomly selecting pitches, rhythms, and tempos. To start, I’ll suggest installing MIDIUtil using pip install MIDIUtil.

    The basic code will involve importing MIDIUtil and using random selections for pitches and durations. I’ll create a MIDI file, set a tempo, and loop through to add notes while keeping track of time.

    I’m also thinking about allowing for multiple tracks or channels, but a single melodic line will likely suffice for the user’s request. Using argparse could enhance customization too!Creating a Python music generator

    The user wants a simple yet organized Python program to generate random music. I should make sure it works across different environments, like saving "random_song.mid" in the working directory. It would be helpful to provide customization options for 'scale_type' and 'root_note,' but keep the explanations brief.

    First, I’ll instruct the user to install MIDIUtil. Then, I’ll include a full Python script with comments, illustrating how to customize scales like major, minor, and pentatonic. Let’s draft the code, starting with imports and defining the SCALES.Finalizing the music generation script

    I want to finalize the Python script with if __name__ == "__main__":. I’ll simplify the code structure, starting with a root note of 60 (C4) and building a major scale over three octaves. The tempo will be set at 120, with a total of 16 bars, which amounts to 64 beats.

    I’ll also ensure the durations will not exceed total beats. While generating notes, I’ll add a random chance of rests to enhance the musicality. In the end, I'll specify that the script creates a file named 'random_music.mid', which users can open in any DAW or MIDI player.Considering real-time playback requirements

    I realize that to play the generated music in real-time, additional libraries may be needed, and the requirements could be OS-specific. It’s important to inform the user about this limitation. They might need to explore options for real-time audio playback, which would require more setup than simply generating the MIDI file. I'll include this note in my response to ensure they understand what’s involved for real-time playback! Here’s a simple Python program that generates random music and saves it as a MIDI file.

    It uses the MIDIUtil library (pure Python) to write a .mid file you can open in any DAW or MIDI player.


    1. Install dependency

    pip install MIDIUtil
    

    2. Python script: random_music.py

    import random
    from midiutil import MIDIFile
    
    # ---------------- Configuration ---------------- #
    
    TEMPO_BPM = 120          # tempo of the piece
    NUM_BARS = 16            # length of the piece in bars
    BEATS_PER_BAR = 4        # time signature: 4/4
    CHANNEL = 0              # MIDI channel (0-15)
    TRACK = 0                # track index
    ROOT_NOTE = 60           # C4 in MIDI
    SCALE_TYPE = "major"     # "major", "natural_minor", "pentatonic"
    
    # Durations in beats (1 = quarter note in 4/4)
    DURATION_CHOICES = [0.25, 0.5, 1.0, 2.0]  # sixteenth, eighth, quarter, half
    
    # Probability of inserting a rest instead of a note
    REST_PROBABILITY = 0.15
    
    
    # ---------------- Scale utilities ---------------- #
    
    SCALES = {
        "major":         [0, 2, 4, 5, 7, 9, 11],
        "natural_minor": [0, 2, 3, 5, 7, 8, 10],
        "pentatonic":    [0, 3, 5, 7, 10],
    }
    
    
    def build_scale(root_note=60, scale_type="major", octaves=3):
        """Return a list of MIDI note numbers for the given scale over several octaves."""
        if scale_type not in SCALES:
            raise ValueError(f"Unknown scale type '{scale_type}'. Available: {list(SCALES.keys())}")
        intervals = SCALES[scale_type]
        notes = []
        for o in range(octaves):
            base = root_note + 12 * o
            for i in intervals:
                notes.append(base + i)
        return notes
    
    
    # ---------------- Melody generation ---------------- #
    
    def generate_random_melody(midi_file, track, channel):
        total_beats = NUM_BARS * BEATS_PER_BAR
        current_time = 0.0
    
        scale_notes = build_scale(ROOT_NOTE, SCALE_TYPE, octaves=3)
    
        while current_time < total_beats:
            duration = random.choice(DURATION_CHOICES)
    
            # Avoid overshooting the total duration
            if current_time + duration > total_beats:
                duration = total_beats - current_time
    
            # Decide if this event is a rest
            if random.random() < REST_PROBABILITY:
                # Just advance time, no note
                current_time += duration
                continue
    
            pitch = random.choice(scale_notes)
            volume = random.randint(60, 110)  # MIDI velocity (0-127)
    
            midi_file.addNote(
                track=track,
                channel=channel,
                pitch=pitch,
                time=current_time,
                duration=duration,
                volume=volume,
            )
    
            current_time += duration
    
    
    # ---------------- Main program ---------------- #
    
    def main():
        midi = MIDIFile(numTracks=1)
        midi.addTrackName(TRACK, time=0, trackName="Random Music")
        midi.addTempo(TRACK, time=0, tempo=TEMPO_BPM)
    
        generate_random_melody(midi, TRACK, CHANNEL)
    
        output_filename = "random_music.mid"
        with open(output_filename, "wb") as f:
            midi.writeFile(f)
    
        print(f"Wrote {output_filename}")
    
    
    if __name__ == "__main__":
        main()
    

    3. Run it

    python random_music.py
    

    It will create random_music.mid in the current directory.
    Open that file in a DAW (e.g. Ableton, FL Studio, Reaper), a notation program, or any MIDI player to hear the result.

    If you’d like, I can extend this to add drums, chords, or multiple tracks.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.