feat: Viz

BootTidal.hs

@@ -6,32 +6,66 @@ import System.IO (hSetEncoding, stdout, utf8)
 
 hSetEncoding stdout utf8
 
--- DPV setup
+-- Metadata & Visualization OSC setup
 :{
-let targetdpv = Target {oName = "didacticpatternvisualizer",
-                       oAddress = "127.0.0.1",
-                       oPort = 1818,
-                       oLatency = 0.2,
-                       oWindow = Nothing,
-                       oSchedule = Live,
-                       oBusPort = Nothing,
-                       oHandshake = False
-                      }
-    formatsdpv = [OSC "/delivery" Named {requiredArgs = []} ]
-:}
+-- Target for visualizer metadata OSC messages
+metadataTarget = Target { oName = "ParVaguesViz", 
+                          oAddress = "127.0.0.1", 
+                          oPort = 57120, 
+                          oBusPort = Nothing,
+                          oLatency = 0.1, 
+                          oWindow = Nothing, 
+                          oSchedule = Live,
+                          oHandshake = False }
+
+-- DPV visualization target
+targetdpv = Target {oName = "didacticpatternvisualizer",
+                   oAddress = "127.0.0.1",
+                   oPort = 1818,
+                   oLatency = 0.2,
+                   oWindow = Nothing,
+                   oSchedule = Live,
+                   oBusPort = Nothing,
+                   oHandshake = False
+                  }
+formatsdpv = [OSC "/delivery" Named {requiredArgs = []} ]
+
 -- SuperDirt target
-:{
-let superdirtTarget' = superdirtTarget {oLatency = 0.1, oAddress = "127.0.0.1", oPort = 57120}
-:}
-:{
--- Set up targets for both SuperDirt and DPV
-let oscmapdpv = [(targetdpv, formatsdpv),
-                (superdirtTarget', [superdirtShape])
-                ]
+superdirtTarget' = superdirtTarget {oLatency = 0.1, oAddress = "127.0.0.1", oPort = 57120}
+
+-- Set up targets for both SuperDirt, DPV, and metadata
+oscmapdpv = [(targetdpv, formatsdpv),
+            (superdirtTarget', [superdirtShape]),
+            (metadataTarget, [])
+            ]
 :}
--- Initialize TidalCycles with both targets
+
+-- Initialize TidalCycles with all targets
 tidal <- startStream defaultConfig {cFrameTimespan = 1/20} oscmapdpv
 
+:{
+-- Simpler metadata system using parameters that get sent through normal patterns
+let trackName = pS "trackName"    -- Custom parameter for track name
+    trackType = pS "trackType"    -- Custom parameter for track type
+    trackSubtype = pS "trackSubtype"  -- For variants like bass2, fx2, etc.
+    
+    -- Simple shorthands - add these to ANY pattern
+    labelKick n = (# trackName n) . (# trackType "kick")
+    labelSnare n = (# trackName n) . (# trackType "snare")
+    labelHihat n = (# trackName n) . (# trackType "hihat")
+    labelBreak n = (# trackName n) . (# trackType "breaks")
+    
+    -- ParVagues specific shorthands
+    labelBass n = (# trackName n) . (# trackType "bass")
+    labelBass2 n = (# trackName n) . (# trackType "bass") . (# trackSubtype "bass2")
+    labelMelody n = (# trackName n) . (# trackType "melodic")
+    labelMelody2 n = (# trackName n) . (# trackType "melodic") . (# trackSubtype "melody2")
+    labelFX n = (# trackName n) . (# trackType "fx")
+    labelFX2 n = (# trackName n) . (# trackType "fx") . (# trackSubtype "fx2")
+    labelFX3 n = (# trackName n) . (# trackType "fx") . (# trackSubtype "fx3")
+    labelVocal n = (# trackName n) . (# trackType "vocals")
+    labelVocal2 n = (# trackName n) . (# trackType "vocals") . (# trackSubtype "vocal2")
+:}
 
 :{
 let p = streamReplace tidal
@@ -141,5 +175,33 @@ let -- DPV specific parameters
     gF3 = (# djfbus 3 (range 0.05 0.95 "^51"))
 :}
 
+-- FIXME: STALE EXAMPLES
+-- :{
+-- -- Example metadata setup for common tracks
+-- -- Run these at the start of your session
+-- setupMetadata = do
+--   labelKick 0 "Kick"            -- d1: Kick
+--   labelSnare 1 "Snare"          -- d2: Snare
+--   labelHihat 2 "Drums"          -- d3: Drums
+--   labelBass 3 "Bass"            -- d4: Bass
+--   labelMelody 4 "Synth"         -- d5: Synth
+--   labelFX 5 "FX"                -- d6: FX
+--   labelVocal 8 "Vocals"         -- d9: Vocals
+--   labelBreak 7 "Breakbeats"     -- d8: Breaks
+-- 
+-- -- For BLUE GOLD tracks
+-- setupBlueGold = do
+--   labelKick 0 "Kick"
+--   labelSnare 1 "Snare" 
+--   labelHihat 2 "Hihats"
+--   labelBass 3 "Bass"
+--   labelMelody 4 "Suns Keys"
+--   labelFX2 5 "Guitars 1"
+--   labelFX3 6 "Guitars 2"
+--   labelBreak 7 "Breakbeats"
+--   labelVocal 8 "Father Voice"
+--   labelFX 9 "Cues & Noise"
+-- :}
+
 :set prompt "tidal> "
 -- :set prompt-cont ""

viz/Background.pde

+/**
+ * Background class
+ * 
+ * Creates a dynamic cyberpunk background with subtle animations
+ */
+class Background {
+  // Background properties
+  color bgColor;
+  color accentColor1;
+  color accentColor2;
+  
+  // Movement properties
+  float noiseScale = 0.02;
+  float noiseOffset = 0;
+  float noiseSpeed = 0.005;
+  
+  // Timing
+  float cps = 0.5;
+  float lastCycleTime = 0;
+  
+  Background() {
+    // Dark cyberpunk colors
+    bgColor = color(10, 12, 18);
+    accentColor1 = color(0, 70, 100);
+    accentColor2 = color(60, 0, 80);
+  }
+  
+  void update() {
+    // Update noise movement
+    noiseOffset += noiseSpeed;
+    
+    // Check for cycle changes
+    float currentCycleTime = millis() / 1000.0 * cps;
+    if (floor(currentCycleTime) > floor(lastCycleTime)) {
+      // New cycle - could trigger effects here
+    }
+    lastCycleTime = currentCycleTime;
+  }
+  
+  void display() {
+    // Create gradient background
+    noiseDetail(8, 0.5);
+    
+    // Fill with base color
+    noStroke();
+    fill(bgColor, 40); // Semi-transparent for motion blur effect
+    rect(0, 0, width, height);
+    
+    // Add subtle noise pattern
+    float motionFactor = sin(millis() * 0.001) * 0.5 + 0.5;
+    
+    loadPixels();
+    for (int y = 0; y < height; y += 4) {
+      for (int x = 0; x < width; x += 4) {
+        float noiseVal = noise(x * noiseScale, y * noiseScale, noiseOffset);
+        
+        if (noiseVal > 0.7) {
+          color pixelColor;
+          
+          // Create different zones
+          if (noiseVal > 0.85) {
+            // Highlight areas
+            pixelColor = lerpColor(accentColor1, accentColor2, 
+                                   sin(x * 0.01 + millis() * 0.0005) * 0.5 + 0.5);
+            pixelColor = color(red(pixelColor), green(pixelColor), blue(pixelColor), 
+                              20 + 20 * motionFactor);
+          } else {
+            // Subtle accent
+            pixelColor = lerpColor(bgColor, accentColor1, 0.3);
+            pixelColor = color(red(pixelColor), green(pixelColor), blue(pixelColor), 10);
+          }
+          
+          // Draw 4x4 pixel block for better performance
+          fill(pixelColor);
+          rect(x, y, 4, 4);
+        }
+      }
+    }
+    
+    // Draw horizontal scan lines
+    drawScanlines();
+  }
+  
+  void drawScanlines() {
+    stroke(255, 8);
+    strokeWeight(1);
+    for (int y = 0; y < height; y += 4) {
+      line(0, y, width, y);
+    }
+    
+    // Draw brighter scanline that moves
+    float movingScanline = (millis() % 5000) / 5000.0 * height;
+    stroke(255, 15);
+    strokeWeight(2);
+    line(0, movingScanline, width, movingScanline);
+  }
+  
+  void setCPS(float newCps) {
+    this.cps = newCps;
+  }
+}

viz/BreakbeatEvent.pde

+/**
+ * BreakbeatEvent class
+ * 
+ * Specialized visualization for breakbeats, jungle, and deconstructed rhythms
+ * Designed specifically for d8 track in ParVagues performances
+ */
+class BreakbeatEvent extends SoundEvent {
+  // Slice visualization properties
+  int numSlices;
+  ArrayList<Slice> slices;
+  float rotation;
+  float originalSize;
+  boolean isReversePattern;
+  float beatPhase;
+  
+  BreakbeatEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    
+    // Extended lifespan for breakbeats
+    lifespan = 800 + (gain * 500);
+    originalSize = size;
+    
+    // Determine number of slices based on the sound name and gain
+    if (sound.contains("jungle")) {
+      numSlices = 16;
+    } else if (sound.contains("break")) {
+      numSlices = 8;
+    } else {
+      numSlices = int(random(4, 12));
+    }
+    
+    // Check if this might be a reversed sample
+    isReversePattern = sound.contains("rev") || random(100) < 20;
+    
+    // Random rotation for variety
+    rotation = random(TWO_PI);
+    
+    // Initialize slices
+    createSlices();
+    
+    // Beat phase for animation
+    beatPhase = random(TWO_PI);
+  }
+  
+  void createSlices() {
+    slices = new ArrayList<Slice>();
+    
+    // Create slices in a circle
+    for (int i = 0; i < numSlices; i++) {
+      float angle = map(i, 0, numSlices, 0, TWO_PI);
+      float distance = originalSize * 0.7;
+      
+      // Randomized slice properties
+      float sliceWidth = originalSize * 0.3 * random(0.5, 1.5);
+      float sliceHeight = originalSize * 0.2 * random(0.5, 1.5);
+      float fadeOffset = random(0, lifespan * 0.5);
+      
+      // Calculate position
+      float x = cos(angle) * distance;
+      float y = sin(angle) * distance;
+      
+      // Add the slice
+      slices.add(new Slice(x, y, sliceWidth, sliceHeight, angle, fadeOffset));
+    }
+  }
+  
+  @Override
+  void update() {
+    super.update();
+    
+    // Calculate age as a percentage
+    float age = millis() - birthTime;
+    float progress = constrain(age / lifespan, 0, 1);
+    
+    // Update each slice
+    for (Slice slice : slices) {
+      slice.update(progress, age);
+    }
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    float age = millis() - birthTime;
+    float progress = constrain(age / lifespan, 0, 1);
+    
+    // Display core only at the beginning
+    if (progress < 0.2) {
+      // Draw core with fading alpha
+      float coreAlpha = map(progress, 0, 0.2, alpha, 0);
+      fill(red(eventColor), green(eventColor), blue(eventColor), coreAlpha);
+      noStroke();
+      
+      pushMatrix();
+      translate(position.x, position.y);
+      rotate(rotation + (progress * PI * (isReversePattern ? -2 : 2)));
+      ellipse(0, 0, size * (1-progress), size * (1-progress));
+      popMatrix();
+    }
+    
+    // Display slices
+    pushMatrix();
+    translate(position.x, position.y);
+    
+    // Apply global rotation
+    float rotationSpeed = isReversePattern ? -1 : 1;
+    rotate(rotation + (progress * rotationSpeed * PI * 0.5));
+    
+    // Draw each slice
+    for (Slice slice : slices) {
+      slice.display(eventColor, alpha);
+    }
+    popMatrix();
+    
+    // Draw rhythmic rings
+    drawRhythmicRings(progress, age);
+  }
+  
+  void drawRhythmicRings(float progress, float age) {
+    // Number of rings depends on the track energy
+    int numRings = int(3 + (gain * 3));
+    
+    for (int i = 0; i < numRings; i++) {
+      // Each ring has its own phase and timing
+      float ringPhase = (beatPhase + (i * TWO_PI / numRings)) % TWO_PI;
+      float ringPulse = sin(ringPhase + (age * 0.01 * (isReversePattern ? -1 : 1))) * 0.5 + 0.5;
+      
+      // Ring size increases with progress and pulses with rhythm
+      float ringSize = originalSize * (0.5 + progress * 1.5) * (0.8 + ringPulse * 0.4);
+      
+      // Ring opacity fades with progress and pulses
+      float ringAlpha = alpha * (1 - progress) * ringPulse * 0.7;
+      
+      if (ringAlpha > 5) {
+        noFill();
+        stroke(red(eventColor), green(eventColor), blue(eventColor), ringAlpha);
+        strokeWeight(1 + ringPulse * 2);
+        
+        // Draw a slightly distorted ring for glitchy effect
+        beginShape();
+        for (int j = 0; j < 24; j++) {
+          float angle = j * TWO_PI / 24;
+          float distortion = 1.0 + (sin(angle * 3 + age * 0.01) * 0.1 * ringPulse);
+          float x = position.x + cos(angle) * ringSize * distortion;
+          float y = position.y + sin(angle) * ringSize * distortion;
+          vertex(x, y);
+        }
+        endShape(CLOSE);
+      }
+    }
+  }
+  
+  /**
+   * Slice inner class
+   * Represents a single slice of the breakbeat visualization
+   */
+  class Slice {
+    PVector position;
+    float width, height;
+    float angle;
+    float fadeOffset;
+    float jitterX, jitterY;
+    float originalX, originalY;
+    float pulsePhase;
+    
+    Slice(float x, float y, float w, float h, float a, float offset) {
+      originalX = x;
+      originalY = y;
+      position = new PVector(x, y);
+      width = w;
+      height = h;
+      angle = a;
+      fadeOffset = offset;
+      
+      // Random phase for pulse animation
+      pulsePhase = random(TWO_PI);
+    }
+    
+    void update(float progress, float age) {
+      // Apply movement based on progress
+      float expansionFactor = 1.0 + (progress * 2.0);
+      
+      // Add rhythmic jitter (more for jungle/break patterns)
+      jitterX = sin(age * 0.03 + pulsePhase) * width * 0.3 * progress;
+      jitterY = cos(age * 0.02 + pulsePhase) * height * 0.3 * progress;
+      
+      // Update position with expansion and jitter
+      position.x = originalX * expansionFactor + jitterX;
+      position.y = originalY * expansionFactor + jitterY;
+    }
+    
+    void display(color sliceColor, float baseAlpha) {
+      // Calculate individual alpha with offset fading
+      float age = millis() - birthTime;
+      float individualProgress = constrain((age - fadeOffset) / (lifespan - fadeOffset), 0, 1);
+      float sliceAlpha = baseAlpha * (1 - individualProgress);
+      
+      if (sliceAlpha <= 0) return;
+      
+      // Apply a pulsing effect
+      float pulse = sin(age * 0.01 + pulsePhase) * 0.5 + 0.5;
+      float pulseSize = 0.8 + (pulse * 0.4);
+      
+      // Draw the slice
+      pushMatrix();
+      translate(position.x, position.y);
+      rotate(angle + (individualProgress * PI * (isReversePattern ? -1 : 1)));
+      
+      // Main slice
+      fill(red(sliceColor), green(sliceColor), blue(sliceColor), sliceAlpha);
+      noStroke();
+      rect(-width/2 * pulseSize, -height/2 * pulseSize, 
+           width * pulseSize, height * pulseSize, 2);
+      
+      // Inner detail
+      fill(255, sliceAlpha * 0.5 * pulse);
+      rect(-width/4 * pulseSize, -height/4 * pulseSize, 
+           width/2 * pulseSize, height/2 * pulseSize, 1);
+      
+      popMatrix();
+    }
+  }
+}

viz/GlitchEffect.pde

+/**
+ * GlitchEffect class
+ * 
+ * Creates cyberpunk-style digital glitch effects
+ */
+class GlitchEffect {
+  float glitchIntensity;
+  ArrayList<GlitchLine> glitchLines;
+  ArrayList<GlitchBlock> glitchBlocks;
+  
+  // Timing
+  float lastGlitchTime;
+  float glitchDuration;
+  
+  GlitchEffect() {
+    glitchIntensity = 0;
+    glitchLines = new ArrayList<GlitchLine>();
+    glitchBlocks = new ArrayList<GlitchBlock>();
+    lastGlitchTime = 0;
+    glitchDuration = 0;
+  }
+  
+  void apply() {
+    // Natural decay of effect
+    glitchIntensity *= 0.95;
+    
+    // Check if glitch duration is over
+    if (millis() - lastGlitchTime > glitchDuration) {
+      // Random chance of a new glitch
+      if (random(100) < 2) {
+        trigger(random(0.1, 0.3));
+      }
+    }
+    
+    // Apply glitch effects if active
+    if (glitchIntensity > 0.01) {
+      // Update and draw glitch lines
+      updateGlitchLines();
+      drawGlitchLines();
+      
+      // Update and draw glitch blocks
+      updateGlitchBlocks();
+      drawGlitchBlocks();
+      
+      // Optional: Apply color shift
+      if (glitchIntensity > 0.2) {
+        applyColorShift();
+      }
+    }
+  }
+  
+  void trigger(float intensity) {
+    // Start a new glitch effect
+    glitchIntensity = min(glitchIntensity + intensity, 1.0);
+    lastGlitchTime = millis();
+    glitchDuration = random(100, 500) * intensity;
+    
+    // Create new glitch elements
+    createGlitchLines();
+    createGlitchBlocks();
+  }
+  
+  void createGlitchLines() {
+    // Clear existing lines
+    glitchLines.clear();
+    
+    // Create new lines
+    int numLines = int(5 * glitchIntensity);
+    for (int i = 0; i < numLines; i++) {
+      glitchLines.add(new GlitchLine());
+    }
+  }
+  
+  void updateGlitchLines() {
+    // Update all glitch lines
+    for (GlitchLine line : glitchLines) {
+      line.update();
+    }
+  }
+  
+  void drawGlitchLines() {
+    // Draw all glitch lines
+    for (GlitchLine line : glitchLines) {
+      line.display();
+    }
+  }
+  
+  void createGlitchBlocks() {
+    // Clear existing blocks
+    glitchBlocks.clear();
+    
+    // Create new blocks
+    int numBlocks = int(10 * glitchIntensity);
+    for (int i = 0; i < numBlocks; i++) {
+      glitchBlocks.add(new GlitchBlock());
+    }
+  }
+  
+  void updateGlitchBlocks() {
+    // Update all glitch blocks
+    for (int i = glitchBlocks.size() - 1; i >= 0; i--) {
+      GlitchBlock block = glitchBlocks.get(i);
+      block.update();
+      
+      // Remove expired blocks
+      if (block.isDead()) {
+        glitchBlocks.remove(i);
+      }
+    }
+    
+    // Add new blocks randomly
+    if (random(100) < 20 * glitchIntensity && glitchBlocks.size() < 20) {
+      glitchBlocks.add(new GlitchBlock());
+    }
+  }
+  
+  void drawGlitchBlocks() {
+    // Draw all glitch blocks
+    for (GlitchBlock block : glitchBlocks) {
+      block.display();
+    }
+  }
+  
+  void applyColorShift() {
+    // Create RGB shift effect
+    blendMode(EXCLUSION);
+    noStroke();
+    
+    // Red shift
+    fill(255, 0, 0, 40 * glitchIntensity);
+    rect(random(-5, 5), random(-5, 5), width, height);
+    
+    // Blue shift
+    fill(0, 0, 255, 40 * glitchIntensity);
+    rect(random(-5, 5), random(-5, 5), width, height);
+    
+    blendMode(BLEND);
+  }
+}
+
+/**
+ * GlitchLine class
+ * 
+ * Horizontal line that creates a scan-line glitch effect
+ */
+class GlitchLine {
+  float yPosition;
+  float height;
+  float offset;
+  float speed;
+  color lineColor;
+  float alpha;
+  
+  GlitchLine() {
+    yPosition = random(height);
+    this.height = random(2, 10);
+    offset = random(-30, 30);
+    speed = random(-2, 2);
+    
+    // Random RGB channel emphasis
+    int channel = int(random(3));
+    switch(channel) {
+      case 0:
+        lineColor = color(255, 50, 50); // Red
+        break;
+      case 1:
+        lineColor = color(50, 255, 50); // Green
+        break;
+      case 2:
+        lineColor = color(50, 50, 255); // Blue
+        break;
+    }
+    
+    alpha = random(100, 200);
+  }
+  
+  void update() {
+    // Move the line
+    yPosition += speed;
+    
+    // Wrap around screen
+    if (yPosition < 0) yPosition = height;
+    if (yPosition > height) yPosition = 0;
+    
+    // Randomize offset occasionally
+    if (random(100) < 5) {
+      offset = random(-30, 30);
+    }
+  }
+  
+  void display() {
+    // Draw the line
+    noStroke();
+    fill(red(lineColor), green(lineColor), blue(lineColor), alpha);
+    rect(0, yPosition, width, this.height);
+    
+    // Draw offset segment
+    int segmentWidth = int(random(50, width/2));
+    int segmentX = int(random(width - segmentWidth));
+    
+    // Draw offset segment
+    rect(segmentX, yPosition + offset, segmentWidth, this.height);
+  }
+}
+
+/**
+ * GlitchBlock class
+ * 
+ * Rectangular block that creates digital artifact effects
+ */
+class GlitchBlock {
+  PVector position;
+  float blockWidth;
+  float blockHeight;
+  color blockColor;
+  float alpha;
+  float lifespan;
+  
+  GlitchBlock() {
+    position = new PVector(random(width), random(height));
+    blockWidth = random(20, 100);
+    blockHeight = random(5, 30);
+    
+    // Use a bright cyberpunk color
+    float hue = random(360);
+    colorMode(HSB, 360, 100, 100);
+    blockColor = color(hue, 80, 100);
+    colorMode(RGB, 255, 255, 255);
+    
+    alpha = random(50, 150);
+    lifespan = random(10, 30);
+  }
+  
+  void update() {
+    // Decrease lifespan
+    lifespan--;
+    
+    // Random position changes
+    if (random(100) < 30) {
+      position.x = random(width);
+    }
+  }
+  
+  void display() {
+    // Draw the block
+    noStroke();
+    fill(red(blockColor), green(blockColor), blue(blockColor), alpha);
+    rect(position.x, position.y, blockWidth, blockHeight);
+    
+    // Draw some noise inside
+    fill(255, alpha * 0.7);
+    for (int i = 0; i < 5; i++) {
+      float noiseX = position.x + random(blockWidth);
+      float noiseY = position.y + random(blockHeight);
+      float noiseSize = random(2, 5);
+      rect(noiseX, noiseY, noiseSize, noiseSize);
+    }
+  }
+  
+  boolean isDead() {
+    return lifespan <= 0;
+  }
+}

viz/Grid.pde

+
+/**
+ * Grid class
+ * 
+ * Creates a cyberpunk grid with pulse effects that react to the music
+ */
+class Grid {
+  // Grid properties
+  int gridStyle = 0; // 0: standard, 1: polar, 2: hexagonal
+  int numStyles = 3;
+  
+  // Timing properties
+  float cps = 0.5;
+  float pulseIntensity = 0;
+  
+  // Colors
+  color gridColor;
+  color accentColor;
+  
+  Grid() {
+    gridColor = color(0, 150, 180, 50);
+    accentColor = color(0, 255, 255, 100);
+  }
+  
+  void update() {
+    // Decay pulse intensity
+    pulseIntensity *= 0.95;
+  }
+  
+  void display() {
+    switch(gridStyle) {
+      case 0:
+        drawStandardGrid();
+        break;
+      case 1:
+        drawPolarGrid();
+        break;
+      case 2:
+        drawHexGrid();
+        break;
+    }
+  }
+  
+  void drawStandardGrid() {
+    strokeWeight(1);
+    
+    // Draw vertical lines
+    float verticalSpacing = width / 20.0;
+    for (int i = 0; i <= 20; i++) {
+      float x = i * verticalSpacing;
+      float intensity = pulseIntensity * (1 - abs((x / width) - 0.5) * 2);
+      
+      stroke(lerpColor(gridColor, accentColor, intensity));
+      line(x, 0, x, height);
+    }
+    
+    // Draw horizontal lines
+    float horizontalSpacing = height / 15.0;
+    for (int i = 0; i <= 15; i++) {
+      float y = i * horizontalSpacing;
+      float intensity = pulseIntensity * (1 - abs((y / height) - 0.5) * 2);
+      
+      stroke(lerpColor(gridColor, accentColor, intensity));
+      line(0, y, width, y);
+    }
+    
+    // Draw horizon line with stronger pulse
+    stroke(lerpColor(gridColor, accentColor, pulseIntensity));
+    strokeWeight(2 + pulseIntensity * 3);
+    line(0, height * 0.5, width, height * 0.5);
+  }
+  
+  void drawPolarGrid() {
+    pushMatrix();
+    translate(width / 2, height / 2);
+    
+    // Draw circular grid
+    noFill();
+    for (int i = 1; i <= 10; i++) {
+      float radius = i * (min(width, height) / 20.0);
+      float intensity = pulseIntensity * (1 - (i / 10.0) * 0.8);
+      
+      stroke(lerpColor(gridColor, accentColor, intensity));
+      strokeWeight(1 + intensity * 2);
+      ellipse(0, 0, radius * 2, radius * 2);
+    }
+    
+    // Draw radial lines
+    int numRadials = 16;
+    for (int i = 0; i < numRadials; i++) {
+      float angle = i * TWO_PI / numRadials;
+      float intensity = pulseIntensity * 0.8;
+      
+      stroke(lerpColor(gridColor, accentColor, intensity));
+      strokeWeight(1 + intensity * 2);
+      
+      float radius = min(width, height) / 2;
+      line(0, 0, cos(angle) * radius, sin(angle) * radius);
+    }
+    
+    popMatrix();
+  }
+  
+  void drawHexGrid() {
+    float hexSize = 40;
+    float horizontalSpacing = hexSize * 1.5;
+    float verticalSpacing = hexSize * sqrt(3);
+    
+    stroke(lerpColor(gridColor, accentColor, pulseIntensity * 0.5));
+    strokeWeight(1 + pulseIntensity * 2);
+    noFill();
+    
+    for (int row = -1; row < height / verticalSpacing + 1; row++) {
+      for (int col = -1; col < width / horizontalSpacing + 1; col++) {
+        float xCenter = col * horizontalSpacing + ((row % 2 == 0) ? 0 : horizontalSpacing / 2);
+        float yCenter = row * verticalSpacing;
+        
+        // Intensity based on distance from center
+        float distFromCenter = dist(xCenter, yCenter, width/2, height/2) / (width/2);
+        float intensity = pulseIntensity * (1 - distFromCenter * 0.7);
+        
+        if (intensity > 0.05) {
+          stroke(lerpColor(gridColor, accentColor, intensity));
+          drawHexagon(xCenter, yCenter, hexSize);
+        }
+      }
+    }
+  }
+  
+  void drawHexagon(float xCenter, float yCenter, float size) {
+    beginShape();
+    for (int i = 0; i < 6; i++) {
+      float angle = i * TWO_PI / 6;
+      vertex(xCenter + cos(angle) * size, yCenter + sin(angle) * size);
+    }
+    endShape(CLOSE);
+  }
+  
+  void trigger(float intensity) {
+    // Trigger a pulse effect
+    pulseIntensity = min(pulseIntensity + intensity, 1.0);
+  }
+  
+  void setCPS(float newCps) {
+    this.cps = newCps;
+  }
+  
+  void toggleStyle() {
+    gridStyle = (gridStyle + 1) % numStyles;
+  }
+}

viz/Launch.pde.disabled

+/**
+ * Launcher Sketch for ParVaguesViz
+ * 
+ * This simple sketch launches the main ParVaguesViz directly,
+ * bypassing the GUI launcher issues.
+ */
+
+// Array of files to import
+String[] fileList = {
+  "ParVaguesViz.pde",
+  "TrackManager.pde",
+  "BreakbeatEvent.pde",
+  "Background.pde",
+  "Grid.pde",
+  "ParticleSystem.pde",
+  "GlitchEffect.pde",
+  "MetadataSystem.pde",
+  "SampleAnalyzer.pde",
+  "Processing4Compatibility.pde"
+};
+
+void setup() {
+  size(400, 300);
+  background(0);
+  fill(255);
+  textAlign(CENTER, CENTER);
+  textSize(16);
+  text("Launching ParVaguesViz...\nPress any key to begin.", width/2, height/2);
+}
+
+void draw() {
+  // Just wait for keypress
+}
+
+void keyPressed() {
+  background(0);
+  text("Loading sketch...", width/2, height/2);
+  
+  // Try to directly launch the main sketch
+  try {
+    String sketchPath = sketchPath("");
+    println("Sketch path: " + sketchPath);
+    
+    // Inform the user
+    println("Attempting to launch ParVaguesViz...");
+    println("If there are any errors, they will appear below:");
+    
+    // Launch the main sketch in this JVM
+    PApplet.main("ParVaguesViz");
+    
+    // Success message
+    background(0, 100, 0);
+    text("ParVaguesViz launched successfully!\nYou can close this window.", width/2, height/2);
+  } 
+  catch (Exception e) {
+    // Error handling
+    background(100, 0, 0);
+    text("Error launching sketch:\n" + e.getMessage(), width/2, height/2);
+    println("Error: " + e.getMessage());
+    e.printStackTrace();
+  }
+}

viz/MetadataSystem.pde

+/**
+ * MetadataSystem class
+ * 
+ * Manages metadata for tracks and provides an interface for:
+ * 1. Auto-detection of track types based on patterns and samples
+ * 2. Manual metadata setting through special OSC messages
+ * 3. Persistent configuration through a metadata file
+ */
+class MetadataSystem {
+  HashMap<Integer, TrackMetadata> trackMetadata;
+  HashMap<String, ArrayList<String>> sampleCategories;
+  boolean hasLoadedMetadata;
+  
+  MetadataSystem() {
+    trackMetadata = new HashMap<Integer, TrackMetadata>();
+    sampleCategories = new HashMap<String, ArrayList<String>>();
+    hasLoadedMetadata = false;
+    
+    // Initialize with default categories
+    initializeSampleCategories();
+    
+    // Try to load metadata file
+    loadMetadataFile();
+  }
+  
+  void initializeSampleCategories() {
+    // Define categories of samples for auto-detection
+    
+    // Kick drums
+    ArrayList<String> kicks = new ArrayList<String>();
+    kicks.add("bd");
+    kicks.add("kick");
+    kicks.add("808bd");
+    kicks.add("bass drum");
+    kicks.add("jazz");
+    sampleCategories.put("kick", kicks);
+    
+    // Snares
+    ArrayList<String> snares = new ArrayList<String>();
+    snares.add("sn");
+    snares.add("snare");
+    snares.add("cp");
+    snares.add("clap");
+    snares.add("rimshot");
+    sampleCategories.put("snare", snares);
+    
+    // Hi-hats
+    ArrayList<String> hats = new ArrayList<String>();
+    hats.add("hh");
+    hats.add("hat");
+    hats.add("hihat");
+    hats.add("openhat");
+    hats.add("closehat");
+    hats.add("ch");
+    hats.add("oh");
+    sampleCategories.put("hihat", hats);
+    
+    // Bass
+    ArrayList<String> bass = new ArrayList<String>();
+    bass.add("bass");
+    bass.add("sub");
+    bass.add("808");
+    bass.add("bassWarsaw");
+    sampleCategories.put("bass", bass);
+    
+    // Breaks
+    ArrayList<String> breaks = new ArrayList<String>();
+    breaks.add("break");
+    breaks.add("jungle");
+    breaks.add("amen");
+    breaks.add("think");
+    breaks.add("apache");
+    breaks.add("funky");
+    sampleCategories.put("breaks", breaks);
+    
+    // Melodic
+    ArrayList<String> melodic = new ArrayList<String>();
+    melodic.add("keys");
+    melodic.add("pad");
+    melodic.add("piano");
+    melodic.add("rhodes");
+    melodic.add("chord");
+    melodic.add("synth");
+    melodic.add("psin");
+    melodic.add("superfork");
+    sampleCategories.put("melodic", melodic);
+    
+    // FX
+    ArrayList<String> fx = new ArrayList<String>();
+    fx.add("fx");
+    fx.add("riser");
+    fx.add("sweep");
+    fx.add("weird");
+    fx.add("glitch");
+    fx.add("noise");
+    sampleCategories.put("fx", fx);
+    
+    // Vocals
+    ArrayList<String> vocals = new ArrayList<String>();
+    vocals.add("voc");
+    vocals.add("voice");
+    vocals.add("vocal");
+    vocals.add("speech");
+    vocals.add("talk");
+    vocals.add("sing");
+    sampleCategories.put("vocals", vocals);
+    
+    // ParVagues specific samples (from the code examples)
+    ArrayList<String> parVaguesSpecific = new ArrayList<String>();
+    parVaguesSpecific.add("suns_keys");
+    parVaguesSpecific.add("suns_guitar");
+    parVaguesSpecific.add("suns_voice");
+    parVaguesSpecific.add("rampleM2");
+    parVaguesSpecific.add("rampleD");
+    parVaguesSpecific.add("armora");
+    parVaguesSpecific.add("FMRhodes1");
+    sampleCategories.put("parvagues", parVaguesSpecific);
+  }
+  
+  void loadMetadataFile() {
+    // Try to load metadata from a file
+    try {
+      String[] lines = loadStrings("parvagues_metadata.txt");
+      if (lines != null && lines.length > 0) {
+        for (String line : lines) {
+          if (line.trim().startsWith("#") || line.trim().isEmpty()) continue; // Skip comments and empty lines
+          
+          String[] parts = line.split(":");
+          if (parts.length >= 3) {
+            int orbit = int(parts[0].trim());
+            String trackName = parts[1].trim();
+            String trackType = parts[2].trim();
+            
+            // Create metadata
+            TrackMetadata metadata = new TrackMetadata(orbit, trackName, trackType);
+            
+            // Add additional properties if available
+            if (parts.length > 3) {
+              String[] properties = parts[3].split(",");
+              for (String prop : properties) {
+                String[] keyValue = prop.split("=");
+                if (keyValue.length == 2) {
+                  metadata.setProperty(keyValue[0].trim(), keyValue[1].trim());
+                }
+              }
+            }
+            
+            // Store metadata
+            trackMetadata.put(orbit, metadata);
+          }
+        }
+        hasLoadedMetadata = true;
+        println("Loaded metadata for " + trackMetadata.size() + " tracks");
+      }
+    } catch (Exception e) {
+      println("Could not load metadata file: " + e.getMessage());
+      // File might not exist yet, that's OK
+    }
+  }
+  
+  void saveMetadataFile() {
+    // Save metadata to a file
+    ArrayList<String> lines = new ArrayList<String>();
+    lines.add("# ParVagues Visualization Metadata");
+    lines.add("# Format: orbit:name:type:prop1=value1,prop2=value2,...");
+    lines.add("");
+    
+    for (int orbit : trackMetadata.keySet()) {
+      TrackMetadata metadata = trackMetadata.get(orbit);
+      String line = orbit + ":" + metadata.name + ":" + metadata.type;
+      
+      // Add properties
+      if (metadata.properties.size() > 0) {
+        line += ":";
+        boolean first = true;
+        for (String key : metadata.properties.keySet()) {
+          if (!first) line += ",";
+          line += key + "=" + metadata.properties.get(key);
+          first = false;
+        }
+      }
+      
+      lines.add(line);
+    }
+    
+    saveStrings("data/parvagues_metadata.txt", lines.toArray(new String[0]));
+    println("Saved metadata for " + trackMetadata.size() + " tracks");
+  }
+  
+  TrackMetadata getMetadata(int orbit) {
+    // Get metadata for a specific orbit
+    if (trackMetadata.containsKey(orbit)) {
+      return trackMetadata.get(orbit);
+    }
+    
+    // Create default metadata if none exists
+    TrackMetadata defaultMetadata = createDefaultMetadata(orbit);
+    trackMetadata.put(orbit, defaultMetadata);
+    return defaultMetadata;
+  }
+  
+  TrackMetadata createDefaultMetadata(int orbit) {
+    // Create default metadata based on orbit
+    String name = "Track " + (orbit + 1);
+    String type = "default";
+    
+    // Assign types based on common usage
+    switch(orbit) {
+      case 0: 
+        type = "kick"; 
+        name = "Kick";
+        break;
+      case 1: 
+        type = "snare"; 
+        name = "Snare";
+        break;
+      case 2: 
+        type = "hihat"; 
+        name = "Drums";
+        break;
+      case 3: 
+        type = "bass"; 
+        name = "Bass";
+        break;
+      case 7: // d8
+        type = "breaks"; 
+        name = "Breakbeats";
+        break;
+    }
+    
+    return new TrackMetadata(orbit, name, type);
+  }
+  
+  void updateFromSample(int orbit, String sample) {
+    // Update metadata based on sample name detection
+    if (sample == null || sample.isEmpty()) return;
+    
+    TrackMetadata metadata = getMetadata(orbit);
+    
+    // If this is the first sample for this track, try to determine type
+    if (!metadata.hasDetectedSample) {
+      // Detect sample type
+      String detectedType = detectSampleType(sample);
+      if (detectedType != null) {
+        metadata.type = detectedType;
+        
+        // Also update name if it's still default
+        if (metadata.name.equals("Track " + (orbit + 1))) {
+          metadata.name = detectedType.substring(0, 1).toUpperCase() + detectedType.substring(1);
+        }
+      }
+      
+      metadata.hasDetectedSample = true;
+    }
+    
+    // Record this sample
+    metadata.addRecentSample(sample);
+    
+    // Save metadata periodically (after acquiring some data)
+    if (trackMetadata.size() >= 3 && !hasLoadedMetadata) {
+      saveMetadataFile();
+      hasLoadedMetadata = true;
+    }
+  }
+  
+  String detectSampleType(String sample) {
+    // Detect the type of a sample based on its name
+    String lowerSample = sample.toLowerCase();
+    
+    // Check each category
+    for (String category : sampleCategories.keySet()) {
+      ArrayList<String> keywords = sampleCategories.get(category);
+      for (String keyword : keywords) {
+        if (lowerSample.contains(keyword.toLowerCase())) {
+          return category;
+        }
+      }
+    }
+    
+    // No match found
+    return null;
+  }
+  
+  void processMetadataMessage(OscMessage msg) {
+    // Process a special metadata OSC message
+    // Format: /parvagues/metadata orbit "name" "type" ["prop1=value1,prop2=value2"]
+    
+    try {
+      // Extract data
+      int orbit = msg.get(0).intValue();
+      String name = msg.get(1).stringValue();
+      String type = msg.get(2).stringValue();
+      
+      // Create or update metadata
+      TrackMetadata metadata = getMetadata(orbit);
+      metadata.name = name;
+      metadata.type = type;
+      
+      // Process properties if present
+      if (msg.arguments().length > 3) {
+        String props = msg.get(3).stringValue();
+        String[] properties = props.split(",");
+        for (String prop : properties) {
+          String[] keyValue = prop.split("=");
+          if (keyValue.length == 2) {
+            metadata.setProperty(keyValue[0].trim(), keyValue[1].trim());
+          }
+        }
+      }
+      
+      // Track that this is explicit metadata
+      metadata.isExplicit = true;
+      
+      // Save metadata file
+      saveMetadataFile();
+      
+      println("Updated metadata for orbit " + orbit + ": " + name + " (" + type + ")");
+      
+    } catch (Exception e) {
+      println("Error processing metadata message: " + e.getMessage());
+    }
+  }
+  
+  String getDebugInfo() {
+    // Generate debug info about current metadata
+    StringBuilder info = new StringBuilder();
+    info.append("Track Metadata:\n");
+    
+    for (int orbit : trackMetadata.keySet()) {
+      TrackMetadata metadata = trackMetadata.get(orbit);
+      info.append("d" + (orbit + 1) + ": " + metadata.name + " (" + metadata.type + ")");
+      
+      // Add sample info
+      if (metadata.recentSamples.size() > 0) {
+        info.append(" - Samples: ");
+        for (int i = 0; i < Math.min(3, metadata.recentSamples.size()); i++) {
+          if (i > 0) info.append(", ");
+          info.append(metadata.recentSamples.get(i));
+        }
+        if (metadata.recentSamples.size() > 3) {
+          info.append(", ...");
+        }
+      }
+      
+      info.append("\n");
+    }
+    
+    return info.toString();
+  }
+}
+
+/**
+ * TrackMetadata class
+ * 
+ * Stores metadata about a track
+ */
+class TrackMetadata {
+  int orbit;
+  String name;
+  String type;
+  HashMap<String, String> properties;
+  ArrayList<String> recentSamples;
+  boolean isExplicit;
+  boolean hasDetectedSample;
+  
+  TrackMetadata(int orbit, String name, String type) {
+    this.orbit = orbit;
+    this.name = name;
+    this.type = type;
+    this.properties = new HashMap<String, String>();
+    this.recentSamples = new ArrayList<String>();
+    this.isExplicit = false;
+    this.hasDetectedSample = false;
+  }
+  
+  void setProperty(String key, String value) {
+    properties.put(key, value);
+  }
+  
+  String getProperty(String key, String defaultValue) {
+    if (properties.containsKey(key)) {
+      return properties.get(key);
+    }
+    return defaultValue;
+  }
+  
+  void addRecentSample(String sample) {
+    // Add to recent samples, avoiding duplicates
+    if (!recentSamples.contains(sample)) {
+      recentSamples.add(sample);
+      
+      // Keep only the 10 most recent samples
+      if (recentSamples.size() > 10) {
+        recentSamples.remove(0);
+      }
+    }
+  }
+  
+  color getTrackColor() {
+    // Get the color for this track based on type or explicit setting
+    
+    // Check if color is explicitly set in properties
+    if (properties.containsKey("color")) {
+      String hexColor = properties.get("color");
+      if (hexColor.startsWith("#")) {
+        hexColor = hexColor.substring(1);
+      }
+      return unhex("FF" + hexColor);
+    }
+    
+    // Otherwise, use default color based on orbit
+    return orbitColors[orbit];
+  }
+}

viz/ParVaguesViz.pde

+/**
+ * ParVaguesViz - Cyberpunk TidalCycles Visualizer
+ * 
+ * A Processing-based visualizer that works with SuperDirt OSC messages
+ * to create cyberpunk-style visualizations for TidalCycles performances.
+ * 
+ * Features:
+ * - Automatic track detection and visualization
+ * - Cyberpunk aesthetic with neon colors and grid effects
+ * - Real-time audio-reactive visual elements
+ * - Orbit-based color schemes
+ * - Metadata system for track identification
+ */
+
+import oscP5.*;
+import netP5.*;
+
+// Processing 4.x compatibility check
+boolean isProcessing4 = true;
+
+// OSC connection settings
+OscP5 oscP5;
+NetAddress superdirtAddress;
+int listenPort = 57120; // Default SuperDirt port
+
+// Visualization components
+TrackManager trackManager;
+Grid grid;
+Background background;
+ParticleSystem particleSystem;
+GlitchEffect glitchEffect;
+
+// Metadata system
+MetadataSystem metadataSystem;
+
+// Sample analyzer
+SampleAnalyzer sampleAnalyzer;
+
+// UI settings
+boolean debug = false;
+boolean showHelp = false;
+boolean showMetadata = false;
+PFont debugFont;
+PFont titleFont;
+PFont metadataFont;
+
+// Timing
+float bpm = 120;
+float cps = 0.5;
+float currentCycle = 0;
+float elapsedTime = 0;
+float lastBeatTime = 0;
+
+// Colors (cyberpunk palette)
+color[] orbitColors = {
+  #00FFFF, // Cyan (d1 - kick)
+  #FF00FF, // Magenta (d2 - snare)
+  #00FF99, // Neon green (d3 - drums)
+  #FF5500, // Orange (d4 - bass)
+  #9900FF, // Purple (d5)
+  #FFFF00, // Yellow (d6)
+  #FF0066, // Pink (d7)
+  #0099FF, // Blue (d8 - breaks)
+  #33FF33, // Green (d9)
+  #FF3300, // Red (d10)
+  #CC00FF, // Violet (d11)
+  #00CCFF, // Light blue (d12)
+  #FFFFFF, // White (d13-d16)
+  #FFFFFF,
+  #FFFFFF,
+  #FFFFFF
+};
+
+void setup() {
+  // Apply Processing 4.x compatibility fixes
+  checkProcessingVersion();
+  applyProcessing4Fixes();
+  
+  size(1280, 720, P3D);
+  frameRate(60);
+  smooth(8);
+  
+  // Initialize OSC
+  oscP5 = new OscP5(this, listenPort);
+  superdirtAddress = new NetAddress("127.0.0.1", listenPort);
+  
+  // Initialize components
+  trackManager = new TrackManager();
+  grid = new Grid();
+  background = new Background();
+  particleSystem = new ParticleSystem();
+  glitchEffect = new GlitchEffect();
+  
+  // Initialize metadata system
+  metadataSystem = new MetadataSystem();
+  
+  // Initialize sample analyzer
+  sampleAnalyzer = new SampleAnalyzer();
+  
+  // Load fonts
+  debugFont = createFont("Courier New Bold", 12);
+  titleFont = createFont("Arial Bold", 24);
+  metadataFont = createFont("Arial", 14);
+  
+  // Print startup message
+  println("ParVaguesViz started");
+  println("Listening for SuperDirt OSC messages on port " + listenPort);
+}
+
+void draw() {
+  // Update timing
+  elapsedTime = millis() / 1000.0;
+  
+  // Clear background with fade effect
+  background.update();
+  background.display();
+  
+  // Update grid
+  grid.update();
+  grid.display();
+  
+  // Update and display tracks
+  trackManager.update();
+  trackManager.display();
+  
+  // Update and display particles
+  particleSystem.update();
+  particleSystem.display();
+  
+  // Apply glitch effects
+  glitchEffect.apply();
+  
+  // Draw UI elements if debug mode is on
+  if (debug) {
+    drawDebugInfo();
+  }
+  
+  // Draw metadata overlay if enabled
+  if (showMetadata) {
+    drawMetadataOverlay();
+  }
+  
+  // Draw help if enabled
+  if (showHelp) {
+    drawHelp();
+  }
+}
+
+// Handle OSC messages
+void oscEvent(OscMessage msg) {
+  // Check for metadata messages
+  if (msg.addrPattern().equals("/parvagues/metadata")) {
+    metadataSystem.processMetadataMessage(msg);
+    return;
+  }
+  
+  // Forward the message to our handler
+  if (msg.addrPattern().equals("/dirt/play")) {
+    handleDirtMessage(msg);
+  } else if (msg.addrPattern().equals("/cps")) {
+    updateCPS(msg);
+  }
+}
+
+// Process SuperDirt message
+void handleDirtMessage(OscMessage msg) {
+  // Extract basic information
+  int orbit = -1;
+  String sound = "";
+  float cycle = 0;
+  float delta = 0;
+  float gain = 1.0;
+  float pan = 0.5;
+  
+  // Extract all parameters from the message
+  for (int i = 0; i < msg.typetag().length(); i++) {
+    String paramName = msg.get(i).stringValue();
+    
+    if (paramName.equals("orbit")) {
+      orbit = msg.get(i+1).intValue();
+    } 
+    else if (paramName.equals("s")) {
+      sound = msg.get(i+1).stringValue();
+    } 
+    else if (paramName.equals("cycle")) {
+      cycle = msg.get(i+1).floatValue();
+    } 
+    else if (paramName.equals("delta")) {
+      delta = msg.get(i+1).floatValue();
+    } 
+    else if (paramName.equals("gain")) {
+      gain = msg.get(i+1).floatValue();
+    } 
+    else if (paramName.equals("pan")) {
+      pan = msg.get(i+1).floatValue();
+    }
+  }
+  
+  // Only process valid messages with an orbit
+  if (orbit >= 0) {
+    // Update metadata system with sample information
+    metadataSystem.updateFromSample(orbit, sound);
+    
+    // Update sample analyzer
+    sampleAnalyzer.processSample(orbit, sound, gain, delta);
+    
+    // Beat detection logic
+    currentCycle = cycle;
+    float now = millis() / 1000.0;
+    if (now - lastBeatTime > 0.1) { // Debounce
+      lastBeatTime = now;
+      grid.trigger(0.3); // Trigger grid effect on beats
+      glitchEffect.trigger(0.1); // Small glitch on beats
+    }
+    
+    // Create a new visual event for this sound
+    trackManager.addEvent(orbit, sound, gain, pan, delta);
+    
+    // Add particles
+    particleSystem.addParticles(orbit, pan, gain);
+  }
+}
+
+// Update timing information from CPS messages
+void updateCPS(OscMessage msg) {
+  if (msg.checkTypetag("f")) {
+    cps = msg.get(0).floatValue();
+    bpm = cps * 60 * 4; // Convert to BPM
+    
+    // Update components with new timing
+    grid.setCPS(cps);
+    background.setCPS(cps);
+  }
+}
+
+// Handle keyboard inputs
+void keyPressed() {
+  if (key == 'd' || key == 'D') {
+    debug = !debug;
+  } else if (key == 'h' || key == 'H') {
+    showHelp = !showHelp;
+  } else if (key == 'g' || key == 'G') {
+    grid.toggleStyle();
+  } else if (key == 'f' || key == 'F') {
+    // Use the compatible fullscreen toggle
+    handleFullscreenToggle();
+  } else if (key == 'r' || key == 'R') {
+    // Reset all visuals
+    trackManager.reset();
+    particleSystem.reset();
+  } else if (key == 'm' || key == 'M') {
+    // Toggle metadata display
+    showMetadata = !showMetadata;
+  }
+}
+
+// Debug information display
+void drawDebugInfo() {
+  fill(255);
+  textFont(debugFont);
+  textAlign(LEFT);
+  
+  text("FPS: " + int(frameRate), 10, 20);
+  text("CPS: " + nf(cps, 0, 2) + " (BPM: " + int(bpm) + ")", 10, 35);
+  text("Cycle: " + nf(currentCycle, 0, 2), 10, 50);
+  text("Active Tracks: " + trackManager.getActiveTrackCount(), 10, 65);
+  text("Particles: " + particleSystem.getParticleCount(), 10, 80);
+  text("Tracked Samples: " + sampleAnalyzer.getSampleCount(), 10, 95);
+  
+  // Add hint about metadata
+  fill(200);
+  text("Press 'M' to toggle metadata display", 10, 125);
+}
+
+// Draw metadata overlay
+void drawMetadataOverlay() {
+  // Semi-transparent background
+  fill(0, 200);
+  noStroke();
+  rect(width - 320, 10, 310, height - 20, 10);
+  
+  // Title
+  fill(255);
+  textFont(titleFont);
+  textAlign(CENTER);
+  text("Track Metadata", width - 165, 40);
+  
+  // Track information
+  textFont(metadataFont);
+  textAlign(LEFT);
+  float y = 70;
+  
+  // Draw metadata for each active track
+  ArrayList<Integer> activeOrbits = trackManager.getActiveOrbits();
+  
+  if (activeOrbits.size() == 0) {
+    text("No active tracks", width - 300, y);
+  } else {
+    for (Integer orbit : activeOrbits) {
+      TrackMetadata metadata = metadataSystem.getMetadata(orbit);
+      
+      // Draw track name and type with track color
+      fill(metadata.getTrackColor());
+      text("d" + (orbit + 1) + ": " + metadata.name, width - 300, y);
+      text("Type: " + metadata.type, width - 300, y + 20);
+      
+      // Draw most recent sample
+      fill(200);
+      if (metadata.recentSamples.size() > 0) {
+        text("Sample: " + metadata.recentSamples.get(metadata.recentSamples.size() - 1), width - 300, y + 40);
+      }
+      
+      // Add analyzed features if available
+      SampleFeatures features = sampleAnalyzer.getFeaturesForOrbit(orbit);
+      if (features != null) {
+        fill(180);
+        text("Tempo: " + nf(features.tempo, 0, 1) + " BPM", width - 300, y + 60);
+        text("Energy: " + nf(features.energy, 0, 2), width - 150, y + 60);
+      }
+      
+      // Draw separator
+      stroke(100);
+      line(width - 300, y + 75, width - 30, y + 75);
+      noStroke();
+      
+      // Move to next track position
+      y += 90;
+      
+      // Avoid drawing outside screen
+      if (y > height - 50) break;
+    }
+  }
+}
+
+// Help information display
+void drawHelp() {
+  fill(0, 180);
+  noStroke();
+  rect(width/2 - 200, height/2 - 150, 400, 300);
+  
+  fill(255);
+  textFont(titleFont);
+  textAlign(CENTER);
+  
+  text("ParVaguesViz Controls", width/2, height/2 - 120);
+  
+  textFont(debugFont);
+  textAlign(LEFT);
+  
+  String[] helpText = {
+    "D - Toggle debug info",
+    "H - Toggle help",
+    "G - Change grid style",
+    "F - Toggle fullscreen",
+    "R - Reset visuals",
+    "M - Toggle metadata display",
+    "",
+    "Automatically visualizes tracks d1-d16",
+    "Special visualization for d8 breakbeats",
+    "No TidalCycles configuration needed"
+  };
+  
+  for (int i = 0; i < helpText.length; i++) {
+    text(helpText[i], width/2 - 180, height/2 - 80 + i * 20);
+  }
+}
+
+// Check if currently fullscreen
+boolean isFullScreen() {
+  if (isProcessing4) {
+    return width == displayWidth && height == displayHeight;
+  } else {
+    return width == displayWidth && height == displayHeight;
+  }
+}

viz/ParVaguesViz.pde.bak

+/**
+ * ParVaguesViz - Cyberpunk TidalCycles Visualizer
+ * 
+ * A Processing-based visualizer that works with SuperDirt OSC messages
+ * to create cyberpunk-style visualizations for TidalCycles performances.
+ * 
+ * Features:
+ * - Automatic track detection and visualization
+ * - Cyberpunk aesthetic with neon colors and grid effects
+ * - Real-time audio-reactive visual elements
+ * - Orbit-based color schemes
+ * - Metadata system for track identification
+ */
+
+import oscP5.*;
+import netP5.*;
+
+// Processing 4.x compatibility check
+boolean isProcessing4 = true;
+
+// OSC connection settings
+OscP5 oscP5;
+NetAddress superdirtAddress;
+int listenPort = 57120; // Default SuperDirt port
+
+// Visualization components
+TrackManager trackManager;
+Grid grid;
+Background background;
+ParticleSystem particleSystem;
+GlitchEffect glitchEffect;
+
+// Metadata system
+MetadataSystem metadataSystem;
+
+// Sample analyzer
+SampleAnalyzer sampleAnalyzer;
+
+// UI settings
+boolean debug = false;
+boolean showHelp = false;
+boolean showMetadata = false;
+PFont debugFont;
+PFont titleFont;
+PFont metadataFont;
+
+// Timing
+float bpm = 120;
+float cps = 0.5;
+float currentCycle = 0;
+float elapsedTime = 0;
+float lastBeatTime = 0;
+
+// Colors (cyberpunk palette)
+color[] orbitColors = {
+  #00FFFF, // Cyan (d1 - kick)
+  #FF00FF, // Magenta (d2 - snare)
+  #00FF99, // Neon green (d3 - drums)
+  #FF5500, // Orange (d4 - bass)
+  #9900FF, // Purple (d5)
+  #FFFF00, // Yellow (d6)
+  #FF0066, // Pink (d7)
+  #0099FF, // Blue (d8 - breaks)
+  #33FF33, // Green (d9)
+  #FF3300, // Red (d10)
+  #CC00FF, // Violet (d11)
+  #00CCFF, // Light blue (d12)
+  #FFFFFF, // White (d13-d16)
+  #FFFFFF,
+  #FFFFFF,
+  #FFFFFF
+};
+
+void setup() {
+  // Apply Processing 4.x compatibility fixes
+  checkProcessingVersion();
+  applyProcessing4Fixes();
+  
+  size(1280, 720, P3D);
+  frameRate(60);
+  smooth(8);
+  
+  // Initialize OSC
+  oscP5 = new OscP5(this, listenPort);
+  superdirtAddress = new NetAddress("127.0.0.1", listenPort);
+  
+  // Initialize components
+  trackManager = new TrackManager();
+  grid = new Grid();
+  background = new Background();
+  particleSystem = new ParticleSystem();
+  glitchEffect = new GlitchEffect();
+  
+  // Initialize metadata system
+  metadataSystem = new MetadataSystem();
+  
+  // Initialize sample analyzer
+  sampleAnalyzer = new SampleAnalyzer();
+  
+  // Load fonts
+  debugFont = createFont("Courier New Bold", 12);
+  titleFont = createFont("Arial Bold", 24);
+  metadataFont = createFont("Arial", 14);
+  
+  // Print startup message
+  println("ParVaguesViz started");
+  println("Listening for SuperDirt OSC messages on port " + listenPort);
+}
+
+void draw() {
+  // Update timing
+  elapsedTime = millis() / 1000.0;
+  
+  // Clear background with fade effect
+  background.update();
+  background.display();
+  
+  // Update grid
+  grid.update();
+  grid.display();
+  
+  // Update and display tracks
+  trackManager.update();
+  trackManager.display();
+  
+  // Update and display particles
+  particleSystem.update();
+  particleSystem.display();
+  
+  // Apply glitch effects
+  glitchEffect.apply();
+  
+  // Draw UI elements if debug mode is on
+  if (debug) {
+    drawDebugInfo();
+  }
+  
+  // Draw metadata overlay if enabled
+  if (showMetadata) {
+    drawMetadataOverlay();
+  }
+  
+  // Draw help if enabled
+  if (showHelp) {
+    drawHelp();
+  }
+}
+
+// Handle OSC messages
+void oscEvent(OscMessage msg) {
+  // Check for metadata messages
+  if (msg.addrPattern().equals("/parvagues/metadata")) {
+    metadataSystem.processMetadataMessage(msg);
+    return;
+  }
+  
+  // Forward the message to our handler
+  if (msg.addrPattern().equals("/dirt/play")) {
+    handleDirtMessage(msg);
+  } else if (msg.addrPattern().equals("/cps")) {
+    updateCPS(msg);
+  }
+}
+
+// Process SuperDirt message
+void handleDirtMessage(OscMessage msg) {
+  // Extract basic information
+  int orbit = -1;
+  String sound = "";
+  float cycle = 0;
+  float delta = 0;
+  float gain = 1.0;
+  float pan = 0.5;
+  
+  // Extract all parameters from the message
+  for (int i = 0; i < msg.typetag().length(); i++) {
+    String paramName = msg.get(i).stringValue();
+    
+    if (paramName.equals("orbit")) {
+      orbit = msg.get(i+1).intValue();
+    } 
+    else if (paramName.equals("s")) {
+      sound = msg.get(i+1).stringValue();
+    } 
+    else if (paramName.equals("cycle")) {
+      cycle = msg.get(i+1).floatValue();
+    } 
+    else if (paramName.equals("delta")) {
+      delta = msg.get(i+1).floatValue();
+    } 
+    else if (paramName.equals("gain")) {
+      gain = msg.get(i+1).floatValue();
+    } 
+    else if (paramName.equals("pan")) {
+      pan = msg.get(i+1).floatValue();
+    }
+  }
+  
+  // Only process valid messages with an orbit
+  if (orbit >= 0) {
+    // Update metadata system with sample information
+    metadataSystem.updateFromSample(orbit, sound);
+    
+    // Update sample analyzer
+    sampleAnalyzer.processSample(orbit, sound, gain, delta);
+    
+    // Beat detection logic
+    currentCycle = cycle;
+    float now = millis() / 1000.0;
+    if (now - lastBeatTime > 0.1) { // Debounce
+      lastBeatTime = now;
+      grid.trigger(0.3); // Trigger grid effect on beats
+      glitchEffect.trigger(0.1); // Small glitch on beats
+    }
+    
+    // Create a new visual event for this sound
+    trackManager.addEvent(orbit, sound, gain, pan, delta);
+    
+    // Add particles
+    particleSystem.addParticles(orbit, pan, gain);
+  }
+}
+
+// Update timing information from CPS messages
+void updateCPS(OscMessage msg) {
+  if (msg.checkTypetag("f")) {
+    cps = msg.get(0).floatValue();
+    bpm = cps * 60 * 4; // Convert to BPM
+    
+    // Update components with new timing
+    grid.setCPS(cps);
+    background.setCPS(cps);
+  }
+}
+
+// Handle keyboard inputs
+void keyPressed() {
+  if (key == 'd' || key == 'D') {
+    debug = !debug;
+  } else if (key == 'h' || key == 'H') {
+    showHelp = !showHelp;
+  } else if (key == 'g' || key == 'G') {
+    grid.toggleStyle();
+  } else if (key == 'f' || key == 'F') {
+    // Use the compatible fullscreen toggle
+    handleFullscreenToggle();
+  } else if (key == 'r' || key == 'R') {
+    // Reset all visuals
+    trackManager.reset();
+    particleSystem.reset();
+  } else if (key == 'm' || key == 'M') {
+    // Toggle metadata display
+    showMetadata = !showMetadata;
+  }
+}
+
+// Debug information display
+void drawDebugInfo() {
+  fill(255);
+  textFont(debugFont);
+  textAlign(LEFT);
+  
+  text("FPS: " + int(frameRate), 10, 20);
+  text("CPS: " + nf(cps, 0, 2) + " (BPM: " + int(bpm) + ")", 10, 35);
+  text("Cycle: " + nf(currentCycle, 0, 2), 10, 50);
+  text("Active Tracks: " + trackManager.getActiveTrackCount(), 10, 65);
+  text("Particles: " + particleSystem.getParticleCount(), 10, 80);
+  text("Tracked Samples: " + sampleAnalyzer.getSampleCount(), 10, 95);
+  
+  // Add hint about metadata
+  fill(200);
+  text("Press 'M' to toggle metadata display", 10, 125);
+}
+
+// Draw metadata overlay
+void drawMetadataOverlay() {
+  // Semi-transparent background
+  fill(0, 200);
+  noStroke();
+  rect(width - 320, 10, 310, height - 20, 10);
+  
+  // Title
+  fill(255);
+  textFont(titleFont);
+  textAlign(CENTER);
+  text("Track Metadata", width - 165, 40);
+  
+  // Track information
+  textFont(metadataFont);
+  textAlign(LEFT);
+  float y = 70;
+  
+  // Draw metadata for each active track
+  ArrayList<Integer> activeOrbits = trackManager.getActiveOrbits();
+  
+  if (activeOrbits.size() == 0) {
+    text("No active tracks", width - 300, y);
+  } else {
+    for (Integer orbit : activeOrbits) {
+      TrackMetadata metadata = metadataSystem.getMetadata(orbit);
+      
+      // Draw track name and type with track color
+      fill(metadata.getTrackColor());
+      text("d" + (orbit + 1) + ": " + metadata.name, width - 300, y);
+      text("Type: " + metadata.type, width - 300, y + 20);
+      
+      // Draw most recent sample
+      fill(200);
+      if (metadata.recentSamples.size() > 0) {
+        text("Sample: " + metadata.recentSamples.get(metadata.recentSamples.size() - 1), width - 300, y + 40);
+      }
+      
+      // Add analyzed features if available
+      SampleFeatures features = sampleAnalyzer.getFeaturesForOrbit(orbit);
+      if (features != null) {
+        fill(180);
+        text("Tempo: " + nf(features.tempo, 0, 1) + " BPM", width - 300, y + 60);
+        text("Energy: " + nf(features.energy, 0, 2), width - 150, y + 60);
+      }
+      
+      // Draw separator
+      stroke(100);
+      line(width - 300, y + 75, width - 30, y + 75);
+      noStroke();
+      
+      // Move to next track position
+      y += 90;
+      
+      // Avoid drawing outside screen
+      if (y > height - 50) break;
+    }
+  }
+}
+
+// Help information display
+void drawHelp() {
+  fill(0, 180);
+  noStroke();
+  rect(width/2 - 200, height/2 - 150, 400, 300);
+  
+  fill(255);
+  textFont(titleFont);
+  textAlign(CENTER);
+  
+  text("ParVaguesViz Controls", width/2, height/2 - 120);
+  
+  textFont(debugFont);
+  textAlign(LEFT);
+  
+  String[] helpText = {
+    "D - Toggle debug info",
+    "H - Toggle help",
+    "G - Change grid style",
+    "F - Toggle fullscreen",
+    "R - Reset visuals",
+    "M - Toggle metadata display",
+    "",
+    "Automatically visualizes tracks d1-d16",
+    "Special visualization for d8 breakbeats",
+    "No TidalCycles configuration needed"
+  };
+  
+  for (int i = 0; i < helpText.length; i++) {
+    text(helpText[i], width/2 - 180, height/2 - 80 + i * 20);
+  }
+}
+
+// Check if currently fullscreen
+boolean sketchFullScreen() {
+  if (isProcessing4) {
+    return width == displayWidth && height == displayHeight;
+  } else {
+    return width == displayWidth && height == displayHeight;
+  }
+}

viz/ParticleSystem.pde

+/**
+ * ParticleSystem class
+ * 
+ * Creates and manages particles that respond to musical events
+ */
+class ParticleSystem {
+  ArrayList<Particle> particles;
+  int maxParticles = 500;
+  
+  ParticleSystem() {
+    particles = new ArrayList<Particle>();
+  }
+  
+  void update() {
+    // Update all particles
+    for (int i = particles.size() - 1; i >= 0; i--) {
+      Particle p = particles.get(i);
+      p.update();
+      
+      // Remove dead particles
+      if (p.isDead()) {
+        particles.remove(i);
+      }
+    }
+  }
+  
+  void display() {
+    // Display all particles
+    for (Particle p : particles) {
+      p.display();
+    }
+    
+    // Apply blending for glow effect
+    blendMode(ADD);
+    for (Particle p : particles) {
+      if (p.energy > 0.5) {
+        p.displayGlow();
+      }
+    }
+    blendMode(BLEND);
+  }
+  
+  void addParticles(int orbit, float pan, float gain) {
+    // Skip if at max capacity
+    if (particles.size() >= maxParticles) return;
+    
+    // Number of particles based on gain
+    int count = int(5 + (gain * 20));
+    
+    // Position based on orbit and pan
+    float x = map(pan, 0, 1, width * 0.3, width * 0.7);
+    float y = map(orbit, 0, 15, height * 0.2, height * 0.8);
+    
+    // Create particles
+    for (int i = 0; i < count; i++) {
+      if (particles.size() < maxParticles) {
+        particles.add(new Particle(x, y, orbitColors[orbit], gain));
+      }
+    }
+  }
+  
+  int getParticleCount() {
+    return particles.size();
+  }
+  
+  void reset() {
+    particles.clear();
+  }
+}
+
+/**
+ * Particle class
+ * 
+ * Individual particle with physics for visual effects
+ */
+class Particle {
+  PVector position;
+  PVector velocity;
+  PVector acceleration;
+  
+  color particleColor;
+  float size;
+  float lifespan;
+  float maxLife;
+  float energy;
+  
+  Particle(float x, float y, color c, float gain) {
+    position = new PVector(x, y);
+    
+    // Random velocity
+    float angle = random(TWO_PI);
+    float speed = random(1, 3 + (gain * 5));
+    velocity = new PVector(cos(angle) * speed, sin(angle) * speed);
+    
+    // Slight downward acceleration (gravity)
+    acceleration = new PVector(0, 0.05);
+    
+    // Visual properties
+    particleColor = c;
+    size = random(2, 8);
+    maxLife = random(500, 2000);
+    lifespan = maxLife;
+    energy = gain;
+  }
+  
+  void update() {
+    // Apply physics
+    velocity.add(acceleration);
+    position.add(velocity);
+    
+    // Add some random movement
+    velocity.x += random(-0.1, 0.1);
+    velocity.y += random(-0.1, 0.1);
+    
+    // Slow down over time
+    velocity.mult(0.98);
+    
+    // Decrease lifespan
+    lifespan -= 10;
+    
+    // Bounce off edges with energy loss
+    if (position.x < 0 || position.x > width) {
+      velocity.x *= -0.8;
+      position.x = constrain(position.x, 0, width);
+    }
+    
+    if (position.y < 0 || position.y > height) {
+      velocity.y *= -0.8;
+      position.y = constrain(position.y, 0, height);
+    }
+  }
+  
+  void display() {
+    // Calculate alpha based on remaining life
+    float alpha = map(lifespan, 0, maxLife, 0, 200);
+    
+    // Draw particle
+    noStroke();
+    fill(red(particleColor), green(particleColor), blue(particleColor), alpha);
+    ellipse(position.x, position.y, size, size);
+  }
+  
+  void displayGlow() {
+    // Draw glow effect
+    float glowSize = size * 3;
+    float alpha = map(lifespan, 0, maxLife, 0, 50) * energy;
+    
+    noStroke();
+    fill(red(particleColor), green(particleColor), blue(particleColor), alpha);
+    ellipse(position.x, position.y, glowSize, glowSize);
+  }
+  
+  boolean isDead() {
+    return lifespan <= 0;
+  }
+}

viz/Processing4Compatibility.pde

+/**
+ * Processing 4.x Compatibility Helper
+ * 
+ * This file contains workarounds for issues specific to Processing 4.x
+ */
+
+// NOTE: The isProcessing4 variable is now declared only in ParVaguesViz.pde
+// We reference it directly without redeclaring it here
+
+// Some helper functions for Processing 4 compatibility
+void checkProcessingVersion() {
+  // Check Processing version - this approach works with Processing 3 and 4
+  try {
+    // Get processing version using reflection to avoid errors
+    java.lang.reflect.Field versionField = processing.core.PApplet.class.getDeclaredField("VERSION");
+    versionField.setAccessible(true);
+    String versionStr = (String) versionField.get(null);
+    
+    // Parse the version
+    if (versionStr != null && versionStr.length() > 0) {
+      String[] parts = versionStr.split("\\.");
+      if (parts.length > 0) {
+        int majorVersion = Integer.parseInt(parts[0]);
+        isProcessing4 = (majorVersion >= 4);
+        println("Detected Processing version: " + versionStr);
+        println("Using Processing 4 compatibility: " + (isProcessing4 ? "yes" : "no"));
+      }
+    }
+  } catch (Exception e) {
+    // If we can't check the version, assume it's Processing 4 or higher
+    println("Could not determine Processing version: " + e.getMessage());
+    println("Assuming Processing 4 compatibility is needed");
+    isProcessing4 = true;
+  }
+}
+
+// Call this in your setup function near the beginning
+void applyProcessing4Fixes() {
+  if (isProcessing4) {
+    // Fix to allow fullscreen toggle
+    // In Processing 4, we use a different method for fullscreen
+    frameRate(60); // Ensure decent frame rate
+    
+    // Fix for certain Linux/JDK combinations
+    try {
+      // Disable potential problem with X11 toolkit
+      System.setProperty("awt.useSystemAAFontSettings", "on");
+      System.setProperty("swing.aatext", "true");
+    } catch (Exception e) {
+      println("Warning: Could not set system properties: " + e.getMessage());
+    }
+  }
+}
+
+// Use this instead of the old fullscreen toggle
+void toggleFullscreen() {
+  if (isProcessing4) {
+    // Processing 4.x way
+    if (width != displayWidth || height != displayHeight) {
+      surface.setSize(displayWidth, displayHeight);
+      surface.setLocation(0, 0);
+    } else {
+      surface.setSize(1280, 720);
+      surface.setLocation(displayWidth/2 - 640, displayHeight/2 - 360);
+    }
+  } else {
+    // Processing 3.x way (original code)
+    if (width == displayWidth && height == displayHeight) {
+      surface.setSize(1280, 720);
+    } else {
+      surface.setSize(displayWidth, displayHeight);
+    }
+  }
+}
+
+// Update your keyPressed function to use this
+void handleFullscreenToggle() {
+  toggleFullscreen();
+}

viz/SampleAnalyzer.pde

+/**
+ * SampleAnalyzer class
+ * 
+ * Analyzes sample usage patterns to detect properties like:
+ * - Tempo
+ * - Rhythmic structure
+ * - Energy
+ * - Role in the musical composition
+ */
+class SampleAnalyzer {
+  HashMap<Integer, TrackAnalysis> trackAnalysis;
+  HashMap<String, SampleFeatures> sampleFeatures;
+  
+  SampleAnalyzer() {
+    trackAnalysis = new HashMap<Integer, TrackAnalysis>();
+    sampleFeatures = new HashMap<String, SampleFeatures>();
+    
+    // Initialize with some known samples
+    initializeKnownSamples();
+  }
+  
+  void initializeKnownSamples() {
+    // Predefined features for common samples
+    
+    // Drums
+    sampleFeatures.put("bd", new SampleFeatures(120, 0.9, "kick", 0.1));
+    sampleFeatures.put("sn", new SampleFeatures(120, 0.7, "snare", 0.2));
+    sampleFeatures.put("hh", new SampleFeatures(120, 0.5, "hihat", 0.05));
+    sampleFeatures.put("cp", new SampleFeatures(120, 0.8, "clap", 0.15));
+    
+    // Breakbeats (longer durations)
+    SampleFeatures amenFeatures = new SampleFeatures(165, 0.95, "break", 0.5);
+    amenFeatures.complexity = 0.9;
+    sampleFeatures.put("jungle_breaks", amenFeatures);
+    
+    // From ParVagues examples
+    sampleFeatures.put("suns_keys", new SampleFeatures(120, 0.6, "melodic", 0.8));
+    sampleFeatures.put("suns_guitar", new SampleFeatures(120, 0.7, "melodic", 0.5));
+    sampleFeatures.put("suns_voice", new SampleFeatures(120, 0.4, "vocal", 1.0));
+    sampleFeatures.put("bassWarsaw", new SampleFeatures(120, 0.85, "bass", 0.3));
+    sampleFeatures.put("armora", new SampleFeatures(120, 0.6, "melodic", 0.4));
+    sampleFeatures.put("FMRhodes1", new SampleFeatures(120, 0.5, "melodic", 0.7));
+  }
+  
+  void processSample(int orbit, String sound, float gain, float delta) {
+    // Get or create track analysis
+    TrackAnalysis analysis = getTrackAnalysis(orbit);
+    
+    // Record hit time
+    float hitTime = millis() / 1000.0;
+    analysis.recordHit(hitTime, sound, gain, delta);
+    
+    // Extract sample name prefix (before ":" if present)
+    String samplePrefix = sound;
+    if (sound.contains(":")) {
+      samplePrefix = sound.substring(0, sound.indexOf(":"));
+    }
+    
+    // Check if we have features for this sample
+    if (!sampleFeatures.containsKey(samplePrefix)) {
+      // Try to extract features based on sample name and context
+      SampleFeatures features = extractFeatures(sound, delta, gain, analysis);
+      sampleFeatures.put(samplePrefix, features);
+    }
+  }
+  
+  SampleFeatures extractFeatures(String sound, float delta, float gain, TrackAnalysis analysis) {
+    // Attempt to extract sample features based on name and context
+    
+    // Start with defaults
+    float tempo = 120;
+    float energy = 0.7;
+    String role = "unknown";
+    float duration = 0.2;
+    
+    // Estimate tempo from delta (time between events)
+    if (delta > 0) {
+      tempo = 60.0 / delta;
+    } else if (analysis.getHitCount() > 1) {
+      tempo = analysis.estimateTempo();
+    }
+    
+    // Adjust tempo to a reasonable range
+    tempo = constrain(tempo, 60, 200);
+    
+    // Estimate energy from gain and sample name
+    energy = gain * 0.8; // Base energy on gain
+    
+    String lowerSound = sound.toLowerCase();
+    
+    // Estimate role from sample name
+    if (lowerSound.contains("bd") || lowerSound.contains("kick") || lowerSound.contains("bass drum")) {
+      role = "kick";
+      energy *= 1.2; // Kicks are typically high energy
+      duration = 0.1;
+    } 
+    else if (lowerSound.contains("sn") || lowerSound.contains("snare") || lowerSound.contains("cp") || lowerSound.contains("clap")) {
+      role = "snare";
+      energy *= 1.1;
+      duration = 0.15;
+    } 
+    else if (lowerSound.contains("hh") || lowerSound.contains("hat")) {
+      role = "hihat";
+      energy *= 0.9;
+      duration = 0.05;
+    } 
+    else if (lowerSound.contains("bass") || lowerSound.contains("sub") || lowerSound.contains("808")) {
+      role = "bass";
+      energy *= 1.1;
+      duration = 0.4;
+    } 
+    else if (lowerSound.contains("break") || lowerSound.contains("jungle") || lowerSound.contains("amen")) {
+      role = "break";
+      energy *= 1.2;
+      duration = 0.5;
+    } 
+    else if (lowerSound.contains("key") || lowerSound.contains("pad") || lowerSound.contains("chord") || lowerSound.contains("synth")) {
+      role = "melodic";
+      energy *= 0.8;
+      duration = 0.7;
+    } 
+    else if (lowerSound.contains("fx") || lowerSound.contains("riser") || lowerSound.contains("sweep")) {
+      role = "fx";
+      energy *= 0.9;
+      duration = 1.0;
+    } 
+    else if (lowerSound.contains("voc") || lowerSound.contains("voice")) {
+      role = "vocal";
+      energy *= 0.7;
+      duration = 0.8;
+    }
+    
+    // Constrain energy
+    energy = constrain(energy, 0.1, 1.0);
+    
+    return new SampleFeatures(tempo, energy, role, duration);
+  }
+  
+  TrackAnalysis getTrackAnalysis(int orbit) {
+    if (!trackAnalysis.containsKey(orbit)) {
+      trackAnalysis.put(orbit, new TrackAnalysis(orbit));
+    }
+    return trackAnalysis.get(orbit);
+  }
+  
+  SampleFeatures getFeaturesForOrbit(int orbit) {
+    TrackAnalysis analysis = getTrackAnalysis(orbit);
+    String lastSample = analysis.getLastSample();
+    
+    if (lastSample != null) {
+      // Extract sample name prefix
+      String samplePrefix = lastSample;
+      if (lastSample.contains(":")) {
+        samplePrefix = lastSample.substring(0, lastSample.indexOf(":"));
+      }
+      
+      // Get features
+      if (sampleFeatures.containsKey(samplePrefix)) {
+        return sampleFeatures.get(samplePrefix);
+      }
+    }
+    
+    return null;
+  }
+  
+  int getSampleCount() {
+    return sampleFeatures.size();
+  }
+}
+
+/**
+ * TrackAnalysis class
+ * 
+ * Analyzes the hit patterns for a specific track
+ */
+class TrackAnalysis {
+  int orbit;
+  ArrayList<HitInfo> hits;
+  String lastSample;
+  
+  // Pattern analysis
+  float[] intervalHistogram; // For tempo detection
+  float lastHitTime;
+  
+  TrackAnalysis(int orbit) {
+    this.orbit = orbit;
+    this.hits = new ArrayList<HitInfo>();
+    this.lastSample = null;
+    
+    // Initialize histogram (for intervals between 50ms and 2000ms)
+    intervalHistogram = new float[100]; // 20ms bins
+    lastHitTime = -1;
+  }
+  
+  void recordHit(float time, String sound, float gain, float delta) {
+    // Add hit info
+    hits.add(new HitInfo(time, sound, gain, delta));
+    
+    // Keep only recent hits (last 10 seconds)
+    while (hits.size() > 0 && time - hits.get(0).time > 10) {
+      hits.remove(0);
+    }
+    
+    // Update last sample
+    lastSample = sound;
+    
+    // Update interval histogram
+    if (lastHitTime > 0) {
+      float interval = time - lastHitTime;
+      if (interval >= 0.05 && interval <= 2.0) {
+        int bin = constrain(floor((interval - 0.05) * 50), 0, 99);
+        intervalHistogram[bin] += 1;
+      }
+    }
+    lastHitTime = time;
+  }
+  
+  float estimateTempo() {
+    // Find the most common interval
+    int maxBin = 0;
+    float maxValue = 0;
+    
+    for (int i = 0; i < intervalHistogram.length; i++) {
+      if (intervalHistogram[i] > maxValue) {
+        maxValue = intervalHistogram[i];
+        maxBin = i;
+      }
+    }
+    
+    // Convert bin to tempo
+    float interval = 0.05 + (maxBin / 50.0);
+    float tempo = 60.0 / interval;
+    
+    return tempo;
+  }
+  
+  int getHitCount() {
+    return hits.size();
+  }
+  
+  String getLastSample() {
+    return lastSample;
+  }
+  
+  // Inner class to store hit information
+  class HitInfo {
+    float time;
+    String sound;
+    float gain;
+    float delta;
+    
+    HitInfo(float time, String sound, float gain, float delta) {
+      this.time = time;
+      this.sound = sound;
+      this.gain = gain;
+      this.delta = delta;
+    }
+  }
+}
+
+/**
+ * SampleFeatures class
+ * 
+ * Stores detected features of a sample
+ */
+class SampleFeatures {
+  float tempo;      // Estimated tempo in BPM
+  float energy;     // 0-1 energy level
+  String role;      // Role of the sample (kick, snare, etc.)
+  float duration;   // Typical duration in seconds
+  float complexity; // 0-1 complexity level
+  
+  SampleFeatures(float tempo, float energy, String role, float duration) {
+    this.tempo = tempo;
+    this.energy = energy;
+    this.role = role;
+    this.duration = duration;
+    this.complexity = 0.5; // Default complexity
+  }
+}

viz/TrackManager.pde

+/**
+ * TrackManager class
+ * 
+ * Handles the management and visualization of TidalCycles tracks (d1-d16)
+ * Each track has its own visual representation and effects
+ */
+class TrackManager {
+  ArrayList<Track> tracks;
+  ArrayList<SoundEvent> activeEvents;
+  
+  TrackManager() {
+    tracks = new ArrayList<Track>();
+    activeEvents = new ArrayList<SoundEvent>();
+    
+    // Initialize tracks for all possible orbits (0-15)
+    for (int i = 0; i < 16; i++) {
+      tracks.add(new Track(i));
+    }
+  }
+  
+  void update() {
+    // Update all tracks
+    for (Track track : tracks) {
+      track.update();
+    }
+    
+    // Update active events and remove completed ones
+    for (int i = activeEvents.size() - 1; i >= 0; i--) {
+      SoundEvent event = activeEvents.get(i);
+      event.update();
+      
+      if (event.isDone()) {
+        activeEvents.remove(i);
+      }
+    }
+  }
+  
+  void display() {
+    // Display all tracks
+    for (Track track : tracks) {
+      track.display();
+    }
+    
+    // Display all active events
+    for (SoundEvent event : activeEvents) {
+      event.display();
+    }
+  }
+  
+  void addEvent(int orbit, String sound, float gain, float pan, float delta) {
+    // Get appropriate track
+    Track track = tracks.get(orbit);
+    
+    // Update track state
+    track.onSound(sound, gain);
+    
+    // Create new event with appropriate visualization style based on orbit and sound
+    SoundEvent event = createEvent(orbit, sound, gain, pan, delta);
+    activeEvents.add(event);
+  }
+  
+  SoundEvent createEvent(int orbit, String sound, float gain, float pan, float delta) {
+    // Different visualization based on orbit (track number)
+    switch(orbit) {
+      case 0: // d1 - typically kick
+        return new KickEvent(orbit, sound, gain, pan, delta);
+      case 1: // d2 - typically snare
+        return new SnareEvent(orbit, sound, gain, pan, delta);
+      case 2: // d3 - typically hats or percussion
+        return new HihatEvent(orbit, sound, gain, pan, delta);
+      case 3: // d4 - typically bass
+        return new BassEvent(orbit, sound, gain, pan, delta);
+      default: // Other instruments
+        if (sound.contains("suns") || sound.contains("key")) {
+          return new MelodicEvent(orbit, sound, gain, pan, delta);
+        } else if (sound.contains("break") || sound.contains("jungle")) {
+          return new BreakEvent(orbit, sound, gain, pan, delta);
+        } else if (sound.contains("voice") || sound.contains("voc")) {
+          return new VoiceEvent(orbit, sound, gain, pan, delta);
+        } else if (sound.contains("riser") || sound.contains("fx")) {
+          return new FXEvent(orbit, sound, gain, pan, delta);
+        } else {
+          return new SoundEvent(orbit, sound, gain, pan, delta);
+        }
+    }
+  }
+  
+  int getActiveTrackCount() {
+    int count = 0;
+    for (Track track : tracks) {
+      if (track.isActive()) {
+        count++;
+      }
+    }
+    return count;
+  }
+  
+  
+  ArrayList<Integer> getActiveOrbits() {
+    ArrayList<Integer> activeOrbits = new ArrayList<Integer>();
+    
+    // Add orbits of all active tracks
+    for (int i = 0; i < tracks.size(); i++) {
+      if (tracks.get(i).isActive()) {
+        activeOrbits.add(i);
+      }
+    }
+    
+    return activeOrbits;
+  }
+
+  
+  void reset() {
+    activeEvents.clear();
+    for (Track track : tracks) {
+      track.reset();
+    }
+  }
+}
+
+/**
+ * Track class
+ * 
+ * Represents a single TidalCycles track (d1-d16)
+ * Maintains state and provides visual representation
+ */
+class Track {
+  int orbit;
+  color trackColor;
+  boolean active;
+  float activity;
+  float lastTriggerTime;
+  String lastSound;
+  ArrayList<Float> historyGain;
+  
+  // Visual properties
+  float baseHeight;
+  float targetHeight;
+  float currentHeight;
+  
+  Track(int orbit) {
+    this.orbit = orbit;
+    this.trackColor = orbitColors[orbit];
+    this.active = false;
+    this.activity = 0;
+    this.lastTriggerTime = -1000;
+    this.lastSound = "";
+    
+    this.historyGain = new ArrayList<Float>();
+    
+    // Visual initialization
+    this.baseHeight = height / 32.0;
+    this.targetHeight = baseHeight;
+    this.currentHeight = baseHeight;
+  }
+  
+  void update() {
+    // Decay activity over time
+    activity *= 0.95;
+    
+    // Update height with smooth animation
+    currentHeight = lerp(currentHeight, targetHeight, 0.2);
+    
+    // Reset target height if activity is low
+    if (activity < 0.1) {
+      targetHeight = baseHeight;
+      active = false;
+    }
+  }
+  
+  void display() {
+    if (activity < 0.05) return; // Don't display inactive tracks
+    
+    float yPos = map(orbit, 0, 15, height * 0.1, height * 0.9);
+    float trackWidth = width * 0.8;
+    float xOffset = width * 0.1;
+    
+    // Draw track background with trail effect
+    noStroke();
+    fill(red(trackColor), green(trackColor), blue(trackColor), activity * 150);
+    rect(xOffset, yPos - currentHeight/2, trackWidth, currentHeight, 5);
+    
+    // Draw glowing edge
+    stroke(trackColor, activity * 255);
+    strokeWeight(2);
+    noFill();
+    rect(xOffset, yPos - currentHeight/2, trackWidth, currentHeight, 5);
+    
+    // Add glow effect
+    drawGlow(xOffset, yPos, trackWidth, currentHeight);
+    
+    // Draw activity meter
+    float meterWidth = map(activity, 0, 1, 0, trackWidth);
+    noStroke();
+    fill(trackColor, activity * 200);
+    rect(xOffset, yPos - currentHeight/3, meterWidth, currentHeight/3, 5);
+  }
+  
+  void drawGlow(float x, float y, float w, float h) {
+    // Create glow effect using multiple transparent strokes
+    for (int i = 0; i < 5; i++) {
+      float alpha = map(i, 0, 4, activity * 100, 0);
+      stroke(red(trackColor), green(trackColor), blue(trackColor), alpha);
+      strokeWeight(i * 2 + 2);
+      noFill();
+      rect(x, y - currentHeight/2, w, currentHeight, 5);
+    }
+  }
+  
+  void onSound(String sound, float gain) {
+    // Update track state
+    active = true;
+    lastTriggerTime = millis();
+    lastSound = sound;
+    activity = 1.0;
+    
+    // Store gain history (for visual patterns)
+    historyGain.add(gain);
+    if (historyGain.size() > 16) {
+      historyGain.remove(0);
+    }
+    
+    // Update visual properties
+    targetHeight = baseHeight + (gain * baseHeight * 2);
+  }
+  
+  boolean isActive() {
+    return active;
+  }
+  
+  void reset() {
+    activity = 0;
+    historyGain.clear();
+    currentHeight = baseHeight;
+    targetHeight = baseHeight;
+    active = false;
+  }
+}
+
+/**
+ * SoundEvent class
+ * 
+ * Base class for visualizing individual sound events
+ */
+class SoundEvent {
+  int orbit;
+  String sound;
+  float gain;
+  float pan;
+  float delta;
+  float birthTime;
+  float lifespan;
+  color eventColor;
+  
+  // Visual properties
+  float size;
+  float alpha;
+  PVector position;
+  
+  SoundEvent(int orbit, String sound, float gain, float pan, float delta) {
+    this.orbit = orbit;
+    this.sound = sound;
+    this.gain = gain;
+    this.pan = pan;
+    this.delta = delta;
+    this.birthTime = millis();
+    this.lifespan = 500 + (gain * 500); // Duration based on gain
+    
+    // Initialize visuals
+    this.eventColor = orbitColors[orbit];
+    this.size = 20 + (gain * 60);
+    this.alpha = 255;
+    
+    // Position based on pan value
+    float xPos = map(pan, 0, 1, width * 0.3, width * 0.7);
+    float yPos = map(orbit, 0, 15, height * 0.2, height * 0.8);
+    this.position = new PVector(xPos, yPos);
+  }
+  
+  void update() {
+    // Calculate age
+    float age = millis() - birthTime;
+    
+    // Fade out as the event ages
+    alpha = map(age, 0, lifespan, 255, 0);
+    
+    // Grow size slightly over time
+    size = 20 + (gain * 60) * (1 + (age / lifespan) * 0.5);
+  }
+  
+  void display() {
+    if (alpha <= 0) return;
+    
+    // Draw the event
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    noStroke();
+    ellipse(position.x, position.y, size, size);
+    
+    // Add glow effect
+    drawGlow(position.x, position.y, size);
+  }
+  
+  void drawGlow(float x, float y, float s) {
+    for (int i = 0; i < 5; i++) {
+      float glowAlpha = map(i, 0, 4, alpha * 0.5, 0);
+      fill(red(eventColor), green(eventColor), blue(eventColor), glowAlpha);
+      noStroke();
+      ellipse(x, y, s + (i * 10), s + (i * 10));
+    }
+  }
+  
+  boolean isDone() {
+    return (millis() - birthTime) > lifespan;
+  }
+}
+
+/**
+ * Specialized sound event classes for different orbits/instruments
+ */
+class KickEvent extends SoundEvent {
+  KickEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    lifespan = 400 + (gain * 200); // Shorter for kicks
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    // Specialized kick visualization (more impactful)
+    float age = millis() - birthTime;
+    float progress = age / lifespan;
+    
+    // Draw shock wave effect
+    noFill();
+    stroke(red(eventColor), green(eventColor), blue(eventColor), alpha * (1-progress));
+    strokeWeight(3 * (1-progress));
+    ellipse(position.x, position.y, size * (1 + progress * 3), size * (1 + progress * 3));
+    
+    // Draw core
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    noStroke();
+    ellipse(position.x, position.y, size * (1-progress*0.5), size * (1-progress*0.5));
+  }
+}
+
+class SnareEvent extends SoundEvent {
+  ArrayList<PVector> particles;
+  
+  SnareEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    lifespan = 600; // Longer for snares
+    
+    // Create particles for snare effect
+    particles = new ArrayList<PVector>();
+    int particleCount = int(10 + (gain * 20));
+    
+    for (int i = 0; i < particleCount; i++) {
+      float angle = random(TWO_PI);
+      float speed = random(1, 5);
+      particles.add(new PVector(cos(angle) * speed, sin(angle) * speed));
+    }
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    float age = millis() - birthTime;
+    float progress = age / lifespan;
+    
+    // Draw particles
+    noStroke();
+    for (PVector p : particles) {
+      float x = position.x + (p.x * age * 0.1);
+      float y = position.y + (p.y * age * 0.1);
+      float particleSize = size * 0.2 * (1-progress);
+      
+      fill(red(eventColor), green(eventColor), blue(eventColor), alpha * 0.7);
+      ellipse(x, y, particleSize, particleSize);
+    }
+    
+    // Draw core
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    ellipse(position.x, position.y, size * (1-progress*0.7), size * (1-progress*0.7));
+  }
+}
+
+class HihatEvent extends SoundEvent {
+  HihatEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    lifespan = 300; // Very short for hihats
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    float age = millis() - birthTime;
+    float progress = age / lifespan;
+    
+    // Draw star-like shape
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    noStroke();
+    
+    pushMatrix();
+    translate(position.x, position.y);
+    rotate(progress * PI);
+    
+    beginShape();
+    for (int i = 0; i < 6; i++) {
+      float angle = i * TWO_PI / 6;
+      float x1 = cos(angle) * size * 0.5 * (1-progress*0.5);
+      float y1 = sin(angle) * size * 0.5 * (1-progress*0.5);
+      vertex(x1, y1);
+      
+      angle += TWO_PI / 12;
+      float x2 = cos(angle) * size * 0.2 * (1-progress*0.5);
+      float y2 = sin(angle) * size * 0.2 * (1-progress*0.5);
+      vertex(x2, y2);
+    }
+    endShape(CLOSE);
+    
+    popMatrix();
+  }
+}
+
+class BassEvent extends SoundEvent {
+  BassEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    lifespan = 800 + (gain * 400); // Longer for bass
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    float age = millis() - birthTime;
+    float progress = age / lifespan;
+    
+    // Draw ripple effect
+    for (int i = 0; i < 3; i++) {
+      float rippleProgress = (progress + (i * 0.2)) % 1.0;
+      float rippleSize = size * (0.5 + rippleProgress * 2);
+      float rippleAlpha = alpha * (1 - rippleProgress);
+      
+      noFill();
+      stroke(red(eventColor), green(eventColor), blue(eventColor), rippleAlpha);
+      strokeWeight(3 * (1-rippleProgress));
+      ellipse(position.x, position.y, rippleSize, rippleSize * 0.5); // Oval for bass
+    }
+    
+    // Draw core
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    noStroke();
+    ellipse(position.x, position.y, size * 0.8, size * 0.4);
+  }
+}
+
+class MelodicEvent extends SoundEvent {
+  float rotation;
+  
+  MelodicEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    lifespan = 1000 + (gain * 500);
+    rotation = random(TWO_PI);
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    float age = millis() - birthTime;
+    float progress = age / lifespan;
+    
+    pushMatrix();
+    translate(position.x, position.y);
+    rotate(rotation + (progress * TWO_PI * 0.5));
+    
+    // Draw geometric shape
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    noStroke();
+    
+    float sizeScale = 1 - (progress * 0.3);
+    
+    // Create polygon shape
+    beginShape();
+    int sides = 5;
+    for (int i = 0; i < sides; i++) {
+      float angle = i * TWO_PI / sides;
+      float x = cos(angle) * size * 0.5 * sizeScale;
+      float y = sin(angle) * size * 0.5 * sizeScale;
+      vertex(x, y);
+    }
+    endShape(CLOSE);
+    
+    // Add inner detail
+    fill(0, alpha * 0.5);
+    beginShape();
+    for (int i = 0; i < sides; i++) {
+      float angle = i * TWO_PI / sides;
+      float x = cos(angle) * size * 0.3 * sizeScale;
+      float y = sin(angle) * size * 0.3 * sizeScale;
+      vertex(x, y);
+    }
+    endShape(CLOSE);
+    
+    popMatrix();
+    
+    // Add glow
+    drawGlow(position.x, position.y, size * sizeScale);
+  }
+}
+
+class BreakEvent extends SoundEvent {
+  ArrayList<PVector> chunks;
+  
+  BreakEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    lifespan = 700;
+    
+    // Create chunks for break visualization
+    chunks = new ArrayList<PVector>();
+    int chunkCount = int(5 + (gain * 10));
+    
+    for (int i = 0; i < chunkCount; i++) {
+      float angle = random(TWO_PI);
+      float distance = random(size * 0.2, size * 0.6);
+      float chunkSize = random(size * 0.1, size * 0.3);
+      chunks.add(new PVector(cos(angle) * distance, sin(angle) * distance, chunkSize));
+    }
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    float age = millis() - birthTime;
+    float progress = age / lifespan;
+    
+    // Draw chunks
+    rectMode(CENTER);
+    for (PVector chunk : chunks) {
+      float x = position.x + (chunk.x * (0.5 + progress));
+      float y = position.y + (chunk.y * (0.5 + progress));
+      float chunkSize = chunk.z * (1 - progress * 0.5);
+      
+      fill(red(eventColor), green(eventColor), blue(eventColor), alpha * 0.8);
+      noStroke();
+      rect(x, y, chunkSize, chunkSize, 2);
+    }
+    rectMode(CORNER);
+    
+    // Draw center
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    noStroke();
+    ellipse(position.x, position.y, size * 0.4 * (1-progress), size * 0.4 * (1-progress));
+  }
+}
+
+class VoiceEvent extends SoundEvent {
+  VoiceEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    lifespan = 1200;
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    float age = millis() - birthTime;
+    float progress = age / lifespan;
+    
+    // Waveform visualization
+    stroke(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    noFill();
+    strokeWeight(2);
+    
+    beginShape();
+    for (int i = 0; i < 20; i++) {
+      float x = position.x - (size/2) + (i * (size/20));
+      float waveHeight = sin(i * 0.5 + (millis() * 0.005)) * size * 0.2 * (1-progress*0.7);
+      float y = position.y + waveHeight;
+      vertex(x, y);
+    }
+    endShape();
+    
+    // Draw central point
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha);
+    noStroke();
+    ellipse(position.x, position.y, size * 0.2, size * 0.2);
+  }
+}
+
+class FXEvent extends SoundEvent {
+  FXEvent(int orbit, String sound, float gain, float pan, float delta) {
+    super(orbit, sound, gain, pan, delta);
+    lifespan = 1500;
+    size *= 1.5; // Larger for FX
+  }
+  
+  @Override
+  void display() {
+    if (alpha <= 0) return;
+    
+    float age = millis() - birthTime;
+    float progress = age / lifespan;
+    
+    // Lightning effect
+    stroke(red(eventColor), green(eventColor), blue(eventColor), alpha * (1-progress*0.5));
+    
+    // Draw multiple lightning bolts
+    for (int j = 0; j < 3; j++) {
+      float offsetX = random(-size/4, size/4);
+      float offsetY = random(-size/4, size/4);
+      
+      strokeWeight(3 * (1-progress));
+      noFill();
+      
+      beginShape();
+      vertex(position.x + offsetX, position.y - size/2);
+      
+      // Create jagged lines
+      int segments = 5;
+      for (int i = 1; i < segments; i++) {
+        float segmentY = position.y - size/2 + (i * size/segments);
+        float segmentX = position.x + offsetX + random(-size/4, size/4);
+        vertex(segmentX, segmentY);
+      }
+      
+      vertex(position.x + offsetX, position.y + size/2);
+      endShape();
+    }
+    
+    // Draw core
+    fill(red(eventColor), green(eventColor), blue(eventColor), alpha * 0.7);
+    noStroke();
+    ellipse(position.x, position.y, size * 0.3 * (1-progress*0.5), size * 0.3 * (1-progress*0.5));
+  }
+}

viz/launch.sh

+#!/bin/bash
+
+# Direct launcher script for ParVaguesViz
+# This uses what we've learned works on your system
+
+# Get the full path to the sketch directory
+SKETCH_DIR=$(cd "$(dirname "$0")" && pwd)
+
+# Colors for terminal output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Print banner
+echo -e "${BLUE}"
+echo "██████╗  █████╗ ██████╗ ██╗   ██╗ █████╗  ██████╗ ██╗   ██╗███████╗███████╗"
+echo "██╔══██╗██╔══██╗██╔══██╗██║   ██║██╔══██╗██╔════╝ ██║   ██║██╔════╝██╔════╝"
+echo "██████╔╝███████║██████╔╝██║   ██║███████║██║  ███╗██║   ██║█████╗  ███████╗"
+echo "██╔═══╝ ██╔══██║██╔══██╗╚██╗ ██╔╝██╔══██║██║   ██║██║   ██║██╔══╝  ╚════██║"
+echo "██║     ██║  ██║██║  ██║ ╚████╔╝ ██║  ██║╚██████╔╝╚██████╔╝███████╗███████║"
+echo "╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝  ╚═╝ ╚═════╝  ╚═════╝ ╚══════╝╚══════╝"
+echo -e "                     TIDALCYCLES VISUALIZER\n${NC}"
+
+# Set Java options to fix module restrictions
+export _JAVA_OPTIONS="--add-opens=java.desktop/sun.awt.X11=ALL-UNNAMED --add-opens=java.desktop/java.awt=ALL-UNNAMED -Djava.awt.headless=false -Dawt.useSystemAAFontSettings=on -Dswing.aatext=true"
+
+echo -e "${YELLOW}Starting ParVaguesViz...${NC}"
+echo -e "${BLUE}Controls:${NC}"
+echo "  D - Toggle debug info"
+echo "  H - Toggle help screen"
+echo "  G - Change grid style"
+echo "  F - Toggle fullscreen"
+echo "  R - Reset visualization"
+echo "  M - Toggle metadata display"
+echo
+
+# Launch Processing with the full path to the main sketch
+echo -e "${GREEN}Launching visualizer...${NC}"
+cd "$SKETCH_DIR"
+processing "$SKETCH_DIR/ParVaguesViz.pde"

viz/launcher/ParVaguesLauncher.pde

+/**
+ * Launcher for ParVaguesViz
+ */
+
+void setup() {
+  size(400, 300);
+  background(0);
+  fill(255);
+  textAlign(CENTER, CENTER);
+  textSize(16);
+  text("ParVaguesViz Launcher\nPress any key to launch.", width/2, height/2);
+  
+  println("Launcher ready. Press any key to start ParVaguesViz...");
+}
+
+void draw() {
+  // Empty draw loop
+}
+
+void keyPressed() {
+  background(0);
+  text("Launching...", width/2, height/2);
+  
+  try {
+    // Get the path to the main sketch
+    String mainSketchPath = sketchPath(".."); 
+    println("Main sketch path: " + mainSketchPath);
+    
+    // Launch the main sketch with its full path
+    String[] args = new String[] { 
+      mainSketchPath + "/ParVaguesViz.pde"
+    };
+    
+    // Use Java's ProcessBuilder to launch the main sketch
+    ProcessBuilder pb = new ProcessBuilder("processing", args[0]);
+    pb.directory(new File(mainSketchPath));
+    pb.inheritIO(); // Forward output to our console
+    Process p = pb.start();
+    
+    background(0, 100, 0);
+    text("ParVaguesViz launched!\nYou can close this window.", width/2, height/2);
+  } 
+  catch (Exception e) {
+    background(100, 0, 0);
+    text("Error launching sketch.", width/2, height/2);
+    println("Error: " + e.getMessage());
+    e.printStackTrace();
+  }
+}

viz/launcher/sketch.properties

+main=ParVaguesLauncher.pde

viz/readme.md

+# ParVaguesViz - Cyberpunk TidalCycles Visualizer
+
+A cyberpunk-style visualization system for TidalCycles performances that works with your existing configuration without requiring any code changes.
+
+## Features
+
+- **Zero-configuration**: Works with standard TidalCycles/SuperDirt setup without modifying your patterns
+- **Automatic track detection**: Different visual styles for different orbits (d1-d16)
+- **Cyberpunk aesthetic**: Dark mode with neon colors, grids, and glitch effects
+- **Audio-reactive**: Visualizations respond to the rhythm and intensity of your music
+- **Customizable**: Multiple visualization styles and interactive controls
+
+## Requirements
+
+- [Processing](https://processing.org/) (v3.0+)
+- [oscP5 library](https://sojamo.de/libraries/oscP5/)
+- TidalCycles with SuperDirt running on the default port (57120)
+
+## Installation
+
+1. Download this repository to your `$WORK/Tidal/viz/` directory:
+
+   ```bash
+   mkdir -p $WORK/Tidal/viz
+   cd $WORK/Tidal/viz
+   # Copy all files here
+   ```
+
+2. Make sure you have Processing installed:
+
+   ```bash
+   # On Debian/Ubuntu
+   sudo apt-get install processing
+   
+   # Or download from processing.org and install manually
+   ```
+
+3. Install the oscP5 library through the Processing IDE:
+   - Open Processing
+   - Go to Sketch > Import Library > Add Library
+   - Search for "oscP5" and install it
+
+4. Make the run script executable:
+
+   ```bash
+   chmod +x run_visualizer.sh
+   ```
+
+## Usage
+
+1. Start TidalCycles and SuperDirt as usual without any modifications
+
+2. Run the visualizer:
+
+   ```bash
+   cd $WORK/Tidal/viz
+   ./run_visualizer.sh
+   ```
+
+3. Start creating music with TidalCycles! The visualizer will automatically detect and visualize your patterns.
+
+## Controls
+
+| Key | Action |
+|-----|--------|
+| D   | Toggle debug information display |
+| H   | Toggle help screen |
+| G   | Change grid style (standard, polar, hexagonal) |
+| F   | Toggle fullscreen mode |
+| R   | Reset all visualizations |
+
+## How It Works
+
+The visualizer listens for OSC messages from SuperDirt on port 57120. When TidalCycles sends messages to SuperDirt, the visualizer intercepts these messages and creates visual representations based on:
+
+- **Orbit number**: Determines the track type and color (d1-d16)
+- **Sound name**: Influences the visualization style
+- **Gain**: Controls size and intensity of visual elements
+- **Pan**: Determines horizontal position
+- **CPS**: Affects timing and rhythm of the visualization
+
+## Visualization Guide
+
+Different tracks have distinct visual styles:
+
+- **d1 (Orbit 0)**: Kicks - Impactful circular waves (Cyan)
+- **d2 (Orbit 1)**: Snares - Particle explosions (Magenta)
+- **d3 (Orbit 2)**: Hi-hats - Star-like shapes (Neon Green)
+- **d4 (Orbit 3)**: Bass - Rippling ovals (Orange)
+- **d5-d12**: Various instruments with appropriate visualizations
+
+Sample-specific visualizations are also applied:
+
+- **Keys/melodic**: Polygonal shapes
+- **Breaks/jungle**: Chunky fragmented patterns
+- **Voice samples**: Waveform-like visualizations
+- **FX/risers**: Lightning and glow effects
+
+## Customization
+
+All visual elements can be customized by editing the Processing files. 
+The main files are:
+
+- **ParVaguesViz.pde**: Main sketch with initialization and OSC handling
+- **TrackManager.pde**: Handles track visualization and sound events
+- **Background.pde**: Creates the cyberpunk background
+- **Grid.pde**: Manages the grid system with different styles
+- **ParticleSystem.pde**: Particle effects for additional visual interest
+- **GlitchEffect.pde**: Cyberpunk-style digital glitch effects
+
+## Troubleshooting
+
+- **No visualization**: Make sure SuperDirt is running on port 57120
+- **Processing not found**: Set the correct path to processing-java in run_visualizer.sh
+- **Missing oscP5 library**: Install it through the Processing IDE
+- **Performance issues**: Lower the window size in ParVaguesViz.pde or reduce particle count
+
+## License
+
+This project is provided as-is for the ParVagues project.
+
+## Acknowledgments
+
+- TidalCycles and SuperDirt for the amazing live coding environment
+- The Processing Foundation for their visualization tools
+- The oscP5 library for OSC communication

viz/sketch.properties

+main=ParVaguesViz.pde