feat(synth): Add rhythmic arpeggiator effect

Introduces a new arpeggiator to transform chords into lively, rhythmic patterns, a key technique for reducing stiffness in 8-bit music.

The feature operates as a parallel audio layer, mixing the arpeggiated sound with the original synthesis.

Capabilities:
- Automatically syncs to the MIDI's tempo with selectable rhythmic patterns (e.g., "16ths," "Upbeat").
- Intelligently protects the lead melody, only arpeggiating the harmony parts.
- "Humanizes" the output with micro-randomization of timing and velocity.
- Includes full user control over pattern direction, octave range, velocity, and stereo panning.

app.py

@@ -44,6 +44,7 @@ import os
 import hashlib
 import time as reqtime
 import copy
+import random
 import shutil
 import librosa
 import pyloudnorm as pyln
@@ -183,6 +184,16 @@ class AppParameters:
     s8bit_chord_velocity_threshold: int = 100          # Min average velocity for a chord to be tamed
     s8bit_chord_velocity_scale: float = 0.75           # Velocity multiplier for loud, dense chords
 
+    # --- Arpeggiator Parameters ---
+    s8bit_enable_arpeggiator: bool = False               # Master switch for the arpeggiator
+    s8bit_arpeggiate_only_lower_tracks: bool = True      # Only arpeggiate lower tracks (melody protection)
+    s8bit_arpeggio_velocity_scale: float = 0.7           # Velocity multiplier for arpeggiated notes (0.0 to 1.0)
+    s8bit_arpeggio_density: float = 0.5                  # Density factor for rhythmic patterns (0.0 to 1.0)
+    s8bit_arpeggio_rhythm: str = "Classic Upbeat (8th)"  # Rhythmic pattern for arpeggiation
+    s8bit_arpeggio_pattern: str = "Up"                   # Pattern of the arpeggio (e.g., Up, Down, UpDown)
+    s8bit_arpeggio_octave_range: int = 1                 # How many octaves the pattern spans
+    s8bit_arpeggio_panning: str = "Stereo"               # Panning mode for arpeggiated notes (Stereo, Left, Right, Center)
+
 # =================================================================================================
 # === Helper Functions ===
 # =================================================================================================
@@ -243,6 +254,183 @@ def preprocess_midi_for_harshness(midi_data: pretty_midi.PrettyMIDI, params: App
         
     return midi_data # Return the modified object
 
+
+def arpeggiate_midi(midi_data: pretty_midi.PrettyMIDI, params: AppParameters):
+    """
+    Applies a tempo-synced, rhythmic arpeggiator effect. It can generate
+    various rhythmic patterns (not just continuous notes) to create a more
+    musical and less "stiff" accompaniment.
+    Improved rhythmic arpeggiator with dynamic density, stereo layer splitting,
+    micro-randomization, and cross-beat continuity.
+    
+    Args:
+        midi_data: The original PrettyMIDI object.
+        params: AppParameters containing arpeggiator settings.
+        
+    Returns:
+        A new PrettyMIDI object with arpeggiated chords.
+    """
+    print("Applying rhythmic arpeggiator to MIDI data...")
+    # Work on a deep copy to avoid modifying the original object passed to the function
+    processed_midi = copy.deepcopy(midi_data)
+    
+    # --- Step 1: Estimate Tempo ---
+    try:
+        # Estimate the main tempo of the piece.
+        bpm = midi_data.estimate_tempo()
+        print(f"  - Estimated MIDI Tempo: {bpm:.2f} BPM")
+    except:
+        bpm = 120.0
+    beat_duration_s = 60.0 / bpm
+    print(f"  - Arpeggiator using tempo: {bpm:.2f} BPM")
+
+    # --- Step 2: Define Rhythmic Patterns ---
+    # Each pattern is a list of tuples: (start_offset_in_beat, duration_in_beat)
+    # A beat is a quarter note.
+    rhythm_patterns = {
+        "Continuous 16ths": [(0.0, 0.25), (0.25, 0.25), (0.5, 0.25), (0.75, 0.25)],
+        "Classic Upbeat (8th)": [(0.5, 0.25), (0.75, 0.25)],# Two 16th notes on the upbeat
+        "Galloping": [(0.0, 0.75), (0.75, 0.25)],
+        "Pulsing 8ths": [(0.0, 0.5), (0.5, 0.5)],
+        "Simple Quarter Notes": [(0.0, 1.0)],
+        "Pulsing 4ths": [(0.0, 0.5)],
+    }
+    selected_rhythm = rhythm_patterns.get(params.s8bit_arpeggio_rhythm, rhythm_patterns["Classic Upbeat (8th)"])
+
+    # --- The logic for lead/harmony separation, Collect all notes ---
+    all_notes = []
+    # We need to keep track of which instrument each note belongs to
+    for i, instrument in enumerate(processed_midi.instruments):
+        if not instrument.is_drum:
+            for note in instrument.notes:
+                # Use a simple object or tuple to store note and its origin
+                all_notes.append({'note': note, 'instrument_idx': i})
+
+    if not all_notes:
+        return processed_midi
+    all_notes.sort(key=lambda x: x['note'].start)
+
+    # --- Lead / Harmony separation ---
+    lead_note_objects = set()
+    harmony_note_objects = set()
+
+    if params.s8bit_arpeggiate_only_lower_tracks:
+        print("  - Lead melody protection is ON. Analyzing global timeline...")
+        note_idx = 0
+        while note_idx < len(all_notes):
+            current_slice_start = all_notes[note_idx]['note'].start
+            notes_in_slice = [item for item in all_notes[note_idx:] if (item['note'].start - current_slice_start) < 0.02]
+
+            if not notes_in_slice:
+                note_idx += 1
+                continue
+
+            notes_in_slice.sort(key=lambda x: x['note'].pitch, reverse=True)
+            lead_note_objects.add(notes_in_slice[0]['note'])
+            for item in notes_in_slice[1:]:
+                harmony_note_objects.add(item['note'])
+
+            note_idx += len(notes_in_slice)
+    else:
+        print("  - Lead melody protection is OFF.")
+        for item in all_notes:
+            harmony_note_objects.add(item['note'])
+
+    # --- Process each instrument ---
+    for instrument in processed_midi.instruments:
+        if instrument.is_drum:
+            continue
+
+        new_note_list = []
+        
+        # Separate the notes of this specific instrument into lead and harmony
+        inst_lead_notes = [n for n in instrument.notes if n in lead_note_objects]
+        inst_harmony_notes = [n for n in instrument.notes if n in harmony_note_objects]
+
+        # Add all lead notes from this instrument back directly
+        new_note_list.extend(inst_lead_notes)  # Lead notes pass through
+
+        # Process the harmony notes for this instrument to find chords
+        processed_harmony_notes_in_inst = set()
+        for note1 in inst_harmony_notes:
+            if note1 in processed_harmony_notes_in_inst:
+                continue
+            # Collect simultaneous chord notes (within 20ms)
+            chord_notes = [note1] + [note2 for note2 in inst_harmony_notes if note2 not in processed_harmony_notes_in_inst and abs(note2.start - note1.start) < 0.02]
+            for n in chord_notes:
+                processed_harmony_notes_in_inst.add(n) # Mark all chord notes as processed.
+
+            if len(chord_notes) > 1:
+                # Determine the chord's properties.
+                chord_start_time = min(n.start for n in chord_notes)
+                chord_end_time = max(n.end for n in chord_notes)
+                avg_velocity = int(np.mean([n.velocity for n in chord_notes]) * params.s8bit_arpeggio_velocity_scale)
+                avg_velocity = max(1, avg_velocity)
+                pitches = sorted([n.pitch for n in chord_notes])
+
+                # --- Dynamic density factor ---
+                # params.s8bit_arpeggio_density ∈ [0.2, 1.0], default 0.5
+                note_base_density = getattr(params, "s8bit_arpeggio_density", 0.5)
+                chord_duration = chord_end_time - chord_start_time
+                note_duration_factor = min(1.0, chord_duration / (2 * beat_duration_s))  
+
+                note_density_factor = note_base_density * note_duration_factor
+
+                # --- Build pattern with octave range ---
+                pattern = []
+                for octave in range(params.s8bit_arpeggio_octave_range):
+                    octave_pitches = [p + 12*octave for p in pitches]
+                    if params.s8bit_arpeggio_pattern == "Up":
+                        pattern.extend(octave_pitches)
+                    elif params.s8bit_arpeggio_pattern == "Down":
+                        pattern.extend(reversed(octave_pitches))
+                    elif params.s8bit_arpeggio_pattern == "UpDown":
+                        pattern.extend(octave_pitches)
+                        if len(octave_pitches) > 2:
+                            pattern.extend(reversed(octave_pitches[1:-1]))
+                if not pattern:
+                    continue
+
+                # --- Lay down rhythmic notes ---
+                current_time = chord_start_time
+                pattern_index = 0
+                while current_time < chord_end_time:
+                    # Lay down the rhythmic pattern for the current beat
+                    for start_offset, duration_beats in selected_rhythm:
+                        note_start_time = current_time + start_offset * beat_duration_s
+                        note_duration_s = duration_beats * beat_duration_s * note_density_factor
+
+                        # Ensure the note does not exceed the chord's total duration
+                        if note_start_time >= chord_end_time:
+                            break
+
+                        pitch = pattern[pattern_index % len(pattern)]
+                        pattern_index += 1
+
+                        # --- Micro-randomization ---
+                        rand_offset = random.uniform(-0.01, 0.01)  # ±10ms
+                        final_velocity = int(avg_velocity + random.randint(-5,5))
+                        final_velocity = max(1, min(127, final_velocity))
+
+                        new_note = pretty_midi.Note(
+                            velocity=final_velocity,
+                            pitch=pitch,
+                            start=max(0.0, note_start_time + rand_offset),
+                            end=min(chord_end_time, note_start_time + note_duration_s)
+                        )
+                        new_note_list.append(new_note)
+                    current_time += beat_duration_s
+
+            else: # Single harmony notes are passed through
+                new_note_list.append(note1)
+
+        # Replace the instrument's original note list with the new, processed one
+        instrument.notes = new_note_list
+        
+    print("Rhythmic arpeggiator finished.")
+    return processed_midi
+
+
 def one_pole_lowpass(x, cutoff_hz, fs):
     """Simple one-pole lowpass filter (causal), stable and cheap."""
     if cutoff_hz <= 0 or cutoff_hz >= fs/2:
@@ -418,19 +606,36 @@ def synthesize_8bit_style(*, midi_data: pretty_midi.PrettyMIDI,  fs: int, params
     # 1. First, collect all notes from all instruments into a single list.
     all_notes_with_instrument_info = []
     for i, instrument in enumerate(midi_data.instruments):
-        # --- Panning Logic ---
-        # Default to center-panned mono
-        pan_l, pan_r = 0.707, 0.707
-        if num_instruments == 2:
-            if i == 0:  # First instrument panned left
-                pan_l, pan_r = 1.0, 0.0
-            elif i == 1:  # Second instrument panned right
-                pan_l, pan_r = 0.0, 1.0
-        elif num_instruments > 2:
-            if i == 0:  # Left
+        # --- Panning Logic (with override for arpeggiator layer) ---
+        panning_override = getattr(params, '_temp_panning_override', None)
+        
+        if panning_override:
+            if panning_override == "Center":
+                pan_l, pan_r = 0.707, 0.707
+            elif panning_override == "Left":
                 pan_l, pan_r = 1.0, 0.0
-            elif i == 1: # Right
+            elif panning_override == "Right":
                 pan_l, pan_r = 0.0, 1.0
+            else: # Default to Stereo for the arp layer
+                # Wide stereo: pan instruments alternating left and right
+                if i % 2 == 0:
+                    pan_l, pan_r = 1.0, 0.0 # Even instruments to the left
+                else:
+                    pan_l, pan_r = 0.0, 1.0          # Odd instruments to the right
+        else: # Standard panning logic for the main layer
+            # --- Panning Logic ---
+            # Default to center-panned mono
+            pan_l, pan_r = 0.707, 0.707
+            if num_instruments == 2:
+                if i == 0:  # First instrument panned left
+                    pan_l, pan_r = 1.0, 0.0
+                elif i == 1:  # Second instrument panned right
+                    pan_l, pan_r = 0.0, 1.0
+            elif num_instruments > 2:
+                if i == 0:  # Left
+                    pan_l, pan_r = 1.0, 0.0
+                elif i == 1: # Right
+                    pan_l, pan_r = 0.0, 1.0
             # Other instruments remain centered
         
         # Store each note along with its parent instrument index and panning info
@@ -1121,6 +1326,10 @@ def Render_MIDI(*, input_midi_path: str, params: AppParameters, progress: gr.Pro
     """
     Processes and renders a MIDI file according to user-defined settings.
     Can render using SoundFonts or a custom 8-bit synthesizer.
+
+    This version supports a parallel arpeggiator workflow, where the original MIDI 
+    and an arpeggiated version are synthesized separately and then mixed together.
+
     Args:
         input_midi_path (str): The path to the input MIDI file.
         All other arguments are rendering options from the Gradio UI.
@@ -1340,27 +1549,71 @@ def Render_MIDI(*, input_midi_path: str, params: AppParameters, progress: gr.Pro
     srate = int(params.render_sample_rate)
     
     # --- Conditional Rendering Logic ---
+    # --- 8-BIT SYNTHESIZER WORKFLOW ---
     if params.soundfont_bank == SYNTH_8_BIT_LABEL:
-        print("Using 8-bit style synthesizer...")
+        print("Using 8-bit style synthesizer with parallel processing workflow...")
         try:
-            # Load the MIDI file with pretty_midi for manual synthesis
-            midi_data_for_synth = pretty_midi.PrettyMIDI(midi_to_render_path)
-            # --- Apply MIDI Pre-processing if enabled ---
+            # --- Step 1: Prepare MIDI data, load the MIDI file with pretty_midi for manual synthesis
+            base_midi = pretty_midi.PrettyMIDI(midi_to_render_path)
+            # Pre-process the base MIDI for harshness if enabled. This affects BOTH layers.
             if getattr(params, 's8bit_enable_midi_preprocessing', False):
-                midi_data_for_synth = preprocess_midi_for_harshness(midi_data_for_synth, params)
-
-            # Synthesize the waveform
-            # --- Passing new FX parameters to the synthesis function ---
-            audio = synthesize_8bit_style(midi_data=midi_data_for_synth, fs=srate, params=params, progress=progress)
-            # Normalize and prepare for Gradio
-            peak_val = np.max(np.abs(audio))
+                base_midi = preprocess_midi_for_harshness(base_midi, params)
+                
+            # --- Apply Arpeggiator if enabled ---
+            arpeggiated_midi = None
+            if getattr(params, 's8bit_enable_arpeggiator', False):
+                arpeggiated_midi = arpeggiate_midi(base_midi, params)
+                
+            # --- Step 2: Render the main (original) layer ---
+            print("  - Rendering main synthesis layer...")
+            # Synthesize the waveform, passing new FX parameters to the synthesis function
+            main_waveform = synthesize_8bit_style(
+                midi_data=base_midi,
+                fs=srate,
+                params=params,
+                progress=progress
+            )
+            
+            final_waveform = main_waveform
+            
+            # --- Step 3: Render the arpeggiator layer (if enabled) ---
+            if arpeggiated_midi:
+                print("  - Rendering arpeggiator layer...")
+                # Temporarily override panning for the arpeggiator synth call
+                arp_params = copy.copy(params)
+                
+                # The synthesize_8bit_style function needs to know how to handle this new panning parameter
+                # We will pass it via a temporary attribute.
+                setattr(arp_params, '_temp_panning_override', params.s8bit_arpeggio_panning)
+                
+                arpeggiated_waveform = synthesize_8bit_style(
+                    midi_data=arpeggiated_midi,
+                    fs=srate,
+                    params=arp_params,
+                    progress=None # Don't show a second progress bar
+                )
+                
+                # --- Step 4: Mix the layers together ---
+                # Ensure waveforms have the same length
+                len_main = final_waveform.shape[1]
+                len_arp = arpeggiated_waveform.shape[1]
+                if len_arp > len_main:
+                    final_waveform = np.pad(final_waveform, ((0, 0), (0, len_arp - len_main)))
+                elif len_main > len_arp:
+                    arpeggiated_waveform = np.pad(arpeggiated_waveform, ((0, 0), (0, len_main - len_arp)))
+                
+                final_waveform += arpeggiated_waveform
+                
+            # --- Step 5: Finalize audio for Gradio, normalize and prepare for Gradio
+            peak_val = np.max(np.abs(final_waveform))
             if peak_val > 0:
-                audio /= peak_val
+                final_waveform /= peak_val
             # Transpose from (2, N) to (N, 2) and convert to int16 for Gradio
-            audio_out = (audio.T * 32767).astype(np.int16)
+            audio_out = (final_waveform.T * 32767).astype(np.int16)
         except Exception as e:
             print(f"Error during 8-bit synthesis: {e}")
             return [None] * 7
+    # --- SOUNDFONT WORKFLOW ---
     else:
         print(f"Using SoundFont: {params.soundfont_bank}")
         # Get the full path from the global dictionary
@@ -3026,12 +3279,12 @@ if __name__ == "__main__":
                             # This outer group ensures the checkbox and its settings are visually linked.
                             with gr.Group():
                                 s8bit_echo_sustain = gr.Checkbox(
-                                    value=True, # Default to off as it's a special effect.
+                                    value=False, # Default to off as it's a special effect.
                                     label="Enable Echo Sustain for Long Notes",
                                     info="For 'Plucky' envelope only. Fills the silent tail of long, sustained notes with quiet, repeating pulses. Fixes 'choppy' sound on long piano notes."
                                 )
                                 # This inner group contains the sliders and is controlled by the checkbox above.
-                                with gr.Group(visible=True) as echo_sustain_settings:
+                                with gr.Group(visible=False) as echo_sustain_settings:
                                     s8bit_echo_rate_hz = gr.Slider(
                                         1.0, 20.0, value=5.0, step=0.5,
                                         label="Echo Rate (Hz)",
@@ -3048,11 +3301,80 @@ if __name__ == "__main__":
                                         info="Controls how long a note must be to trigger echoes. This value is a multiplier of the 'Decay Time'. Example: If 'Decay Time' is 0.1s and this threshold is set to 10.0, only notes longer than 1.0s (0.1 * 10.0) will produce echoes."
                                     )
                         # --- Re-architected into two separate, parallel accordions ---
-                        # --- Section 1: MIDI Pre-processing ---
-                        with gr.Accordion("MIDI Pre-processing (Anti-Harshness)", open=False):
+#                       --- Section 1: Arpeggiator (Creative Tool) ---
+                        with gr.Accordion("Arpeggiator (Creative Tool to Reduce Stiffness)", open=False):
+                            s8bit_enable_arpeggiator = gr.Checkbox(
+                                value=False,
+                                label="Enable Arpeggiator (to reduce stiffness)",
+                                info="Transforms chords into rapid sequences of notes, creating a classic, lively chiptune feel. This is a key technique to make 8-bit music sound more fluid."
+                            )
+                            with gr.Group(visible=False) as arpeggiator_settings_box:
+                                s8bit_arpeggiate_only_lower_tracks = gr.Checkbox(
+                                    value=True,
+                                    label="Arpeggiate Accompaniment Only (Protect Melody)",
+                                    info="Recommended. Automatically detects the highest-pitched instrument track and excludes it from arpeggiation, preserving the lead melody."
+                                )
+                                s8bit_arpeggio_velocity_scale = gr.Slider(
+                                    0.1, 1.5, value=0.3, step=0.05,
+                                    label="Arpeggio Velocity Scale",
+                                    info="A master volume control for the arpeggiator. 0.7 means arpeggiated notes will have 70% of the original chord's velocity."
+                                )
+                                s8bit_arpeggio_density = gr.Slider(
+                                    0.1, 1.0, value=0.4, step=0.05,
+                                    label="Arpeggio Density Scale",
+                                    info="Controls the density/sparseness of arpeggios. Lower values create more silence between notes, making long chords feel more relaxed."
+                                )
+                                s8bit_arpeggio_rhythm = gr.Dropdown(
+                                    [
+                                        "Continuous 16ths", 
+                                        "Classic Upbeat (8th)",
+                                        "Pulsing 8ths",
+                                        "Pulsing 4ths",
+                                        "Galloping",
+                                        "Simple Quarter Notes"
+                                    ],
+                                    value="Pulsing 8ths",
+                                    label="Arpeggio Rhythm Pattern",
+                                    info="""
+- **Continuous 16ths:** A constant, driving wall of sound with no breaks. Creates a very dense, high-energy texture.
+- **Classic Upbeat (8th):** The quintessential chiptune rhythm. Creates a bouncy, syncopated feel by playing on the off-beats. (Sounds like: _ _ ta-ta)
+- **Pulsing 8ths:** A steady, on-beat rhythm playing two notes per beat. Good for a solid, rhythmic foundation. (Sounds like: ta-ta ta-ta)
+- **Pulsing 4ths:** A strong, deliberate pulse on each downbeat, with a clear separation between notes. (Sounds like: ta_ ta_ ta_)
+- **Galloping:** A driving, forward-moving rhythm with a distinctive long-short pattern. Excellent for action themes. (Sounds like: ta--ta ta--ta)
+- **Simple Quarter Notes:** The most sparse pattern, playing one sustained note per beat. Creates a calm and open feel.
+                                    """
+                                )
+                                s8bit_arpeggio_pattern = gr.Dropdown(
+                                    ["Up", "Down", "UpDown"],
+                                    value="Up",
+                                    label="Arpeggio Pattern",
+                                    info="""
+- **Up:** The classic choice. Ascends from the lowest to the highest note of the chord, then jumps back to the bottom. Creates a feeling of energy, optimism, and forward momentum.
+- **Down:** Descends from the highest to the lowest note. Often creates a more melancholic, reflective, or suspenseful mood.
+- **UpDown:** Ascends to the highest note, then descends back down without jumping. This is the smoothest and most fluid pattern, creating a gentle, wave-like motion.
+                                    """
+                                )
+                                s8bit_arpeggio_octave_range = gr.Slider(
+                                    1, 4, value=1, step=1,
+                                    label="Arpeggio Octave Range",
+                                    info="How many octaves the arpeggio pattern will span before repeating."
+                                )
+                                s8bit_arpeggio_panning = gr.Dropdown(
+                                    ["Stereo", "Center", "Left", "Right"],
+                                    value="Stereo",
+                                    label="Arpeggio Layer Panning",
+                                    info="""
+- **Stereo (Recommended):** Creates a wide, immersive sound by alternating arpeggio tracks between the left and right speakers. This provides maximum clarity and separation from the main melody.
+- **Center:** Places the arpeggio directly in the middle (mono). Creates a focused, powerful, and retro sound, but may conflict with a centered lead melody.
+- **Left / Right:** Places the entire arpeggio layer on only one side. Useful for creative "call and response" effects or special mixing choices.
+                                    """
+                                )
+                        
+                        # --- Section 2: MIDI Pre-processing (Corrective Tool) ---
+                        with gr.Accordion("MIDI Pre-processing (Corrective Tool)", open=False):
                             s8bit_enable_midi_preprocessing = gr.Checkbox(
                                 value=True,
-                                label="Enable MIDI Pre-processing",
+                                label="Enable MIDI Pre-processing (Anti-Harshness)",
                                 info="Intelligently reduces the velocity of notes that are likely to cause harshness (e.g., very high notes or loud, dense chords) before synthesis begins."
                             )
                             with gr.Group(visible=True) as midi_preprocessing_settings_box:
@@ -3082,14 +3404,14 @@ if __name__ == "__main__":
                                     info="Velocity multiplier for loud, dense chords."
                                 )
                         
-                        # --- Section 2: Audio Post-processing, accordion for Anti-Aliasing and Quality Settings ---
-                        with gr.Accordion("Audio Quality & Anti-Aliasing (Advanced)", open=False):
+                        # --- Section 3: Audio Post-processing, accordion for Anti-Aliasing and Quality Settings ---
+                        with gr.Accordion("Audio Quality & Anti-Aliasing (Post-processing)", open=False):
                             s8bit_enable_anti_aliasing = gr.Checkbox(
                                 value=False,
                                 label="Enable All Audio Quality Enhancements",
                                 info="Master toggle for all settings below. Disabling may slightly speed up rendering but can result in harsher, more aliased sound."
                             )
-                            with gr.Group(visible=True) as anti_aliasing_settings_box:
+                            with gr.Group(visible=False) as anti_aliasing_settings_box:
                                 s8bit_use_additive_synthesis = gr.Checkbox(
                                     value=False,
                                     label="Use Additive Synthesis (High Quality, High CPU)",
@@ -3241,6 +3563,12 @@ if __name__ == "__main__":
             inputs=s8bit_enable_midi_preprocessing,
             outputs=midi_preprocessing_settings_box
         )
+        # Event listener for the new Arpeggiator settings box
+        s8bit_enable_arpeggiator.change(
+            fn=lambda x: gr.update(visible=x),
+            inputs=s8bit_enable_arpeggiator,
+            outputs=arpeggiator_settings_box
+        )
 
     # Launch the Gradio app
     app.queue().launch(inbrowser=True, debug=True)