/// Rainbow brackets settings
 #[derive(Clone, Debug, PartialEq)]
 pub struct RainbowBracketSettings {
     pub enabled: bool,
-    pub mode: RainbowMode,
-    pub gradient_start_hue: f32,
-    pub gradient_step: f32,
-    pub show_in_minimap: bool,
-    pub pulse_active_scope: bool,
-    pub pulse_duration_ms: u32,
-    pub dim_inactive_scopes: bool,
-    pub animate_fade: bool,
-    pub animate_glow: bool,
-    pub animation_duration_ms: u32,
+    pub start_hue: f32,
+    pub hue_step: f32,
     pub max_brackets: u32,
 }
 
@@ -297,35 +282,16 @@
                 if let Some(rb) = editor.rainbow_brackets {
                     RainbowBracketSettings {
                         enabled: rb.enabled.unwrap_or(true),
-                        mode: match rb.mode.unwrap_or(settings::RainbowModeContent::Gradient) {
-                            settings::RainbowModeContent::Gradient => RainbowMode::Gradient,
-                            settings::RainbowModeContent::Classic => RainbowMode::Classic,
-                        },
-                        gradient_start_hue: rb.gradient_start_hue.unwrap_or(0.0),
-                        gradient_step: rb.gradient_step.unwrap_or(30.0),
-                        show_in_minimap: rb.show_in_minimap.unwrap_or(true),
-                        pulse_active_scope: rb.pulse_active_scope.unwrap_or(true),
-                        pulse_duration_ms: rb.pulse_duration_ms.unwrap_or(300),
-                        dim_inactive_scopes: rb.dim_inactive_scopes.unwrap_or(false),
-                        animate_fade: rb.animate_fade.unwrap_or(true),
-                        animate_glow: rb.animate_glow.unwrap_or(true),
-                        animation_duration_ms: rb.animation_duration_ms.unwrap_or(200),
+                        start_hue: rb.start_hue.unwrap_or(0.0),
+                        hue_step: rb.hue_step.unwrap_or(30.0),
                         max_brackets: rb.max_brackets.unwrap_or(100000),
                     }
                 } else {
                     // Default values when rainbow_brackets is not specified
                     RainbowBracketSettings {
                         enabled: true,
-                        mode: RainbowMode::Gradient,
-                        gradient_start_hue: 0.0,
-                        gradient_step: 30.0,
-                        show_in_minimap: true,
-                        pulse_active_scope: true,
-                        pulse_duration_ms: 300,
-                        dim_inactive_scopes: false,
-                        animate_fade: true,
-                        animate_glow: true,
-                        animation_duration_ms: 200,
+                        start_hue: 0.0,
+                        hue_step: 30.0,
                         max_brackets: 100000,
                     }

+        by_level[color_index].push(range.clone());
+    }
+
+    // Apply highlights using different type for each level
     macro_rules! apply_level {
         ($index:literal, $type:ty) => {
             if !by_level[$index].is_empty() {
-                let ranges: Vec<_> = by_level[$index].iter().map(|(r, _)| r.clone()).collect();
-                let mut color = by_level[$index][0].1; // All brackets at this level have same color
-                // If fade is active, apply a uniform alpha for this frame
-                if let Some(alpha) = editor.rainbow_bracket_tracker.calculate_fade_progress() {
-                    color = hsla(color.h, color.s, color.l, alpha);
-                }
+                let level = $index as u32;
+                let color = editor.rainbow_bracket_tracker.get_color_for_level(level);
                 editor.highlight_text::<$type>(
-                    ranges,
+                    by_level[$index].clone(),
                     HighlightStyle {
                         color: Some(color),
                         ..Default::default()
                     },
-                    cx
+                    cx,
                 );
             }
         };

 
-            let pairs_vec: Vec<_> = pairs.collect();
-            log::trace!(
-                "rainbow_brackets: tree-sitter pairs found count={} buffer_end={}",
-                pairs_vec.len(),
-                entire_buffer_range.end
-            );
-
-            for (open_range, close_range) in pairs_vec {
+            for (open_range, close_range) in pairs {
                 brackets.push((open_range.start, true, open_range));
                 brackets.push((close_range.start, false, close_range));
             }
 
-            // Sort by position so we process brackets in document order
+            // Sort by position to process in document order
             brackets.sort_by_key(|(pos, _, _)| *pos);