diff --git a/crates/tek_sequencer/src/sequencer.rs b/crates/tek_sequencer/src/sequencer.rs
index c367f7e5..a19cda21 100644
--- a/crates/tek_sequencer/src/sequencer.rs
+++ b/crates/tek_sequencer/src/sequencer.rs
@@ -43,7 +43,7 @@ impl<E: Engine> Arranger<E> {
     pub fn new (name: &str) -> Self {
         Self {
             name:     Arc::new(RwLock::new(name.into())),
-            mode:     ArrangerViewMode::VerticalCompact2,
+            mode:     ArrangerViewMode::Vertical(2),
             selected: ArrangerFocus::Clip(0, 0),
             scenes:   vec![],
             tracks:   vec![],
@@ -306,32 +306,9 @@ impl Handle<Tui> for Arranger<Tui> {
 impl Content for Arranger<Tui> {
     type Engine = Tui;
     fn content (&self) -> impl Widget<Engine = Tui> {
-        Layers::new(move |add|{
-            //Lozenge(Style::default().fg(Nord::BG2))
-                //.draw(&mut to.alter_area(|[x, y, w, h]|[
-                    //x.saturating_sub(1),
-                    //y.saturating_sub(1),
-                    //w + 2,
-                    //h + 2,
-                //]))
-            match self.mode {
-                ArrangerViewMode::Horizontal => add(&HorizontalArranger(&self)),
-                ArrangerViewMode::VerticalCompact1 => add(&VerticalArranger(
-                    &self,
-                    track_clip_name_lengths(self.tracks.as_slice()).as_slice(),
-                    (0..=self.scenes.len()).map(|i|(96, 96*i)).collect::<Vec<_>>().as_slice(),
-                )),
-                ArrangerViewMode::VerticalCompact2 => add(&VerticalArranger(
-                    &self,
-                    track_clip_name_lengths(self.tracks.as_slice()).as_slice(),
-                    (0..=self.scenes.len()).map(|i|(192, 192*i)).collect::<Vec<_>>().as_slice()
-                )),
-                ArrangerViewMode::VerticalExpanded => add(&VerticalArranger(
-                    &self,
-                    track_clip_name_lengths(self.tracks.as_slice()).as_slice(),
-                    scene_ppqs(self.tracks.as_slice(), self.scenes.as_slice()).as_slice(),
-                )),
-            }
+        Layers::new(move |add|match self.mode {
+            ArrangerViewMode::Horizontal       => add(&HorizontalArranger(&self)),
+            ArrangerViewMode::Vertical(factor) => add(&VerticalArranger(&self, factor))
         })
     }
 }
@@ -471,40 +448,51 @@ impl ArrangerFocus {
 
 /// Display mode of arranger
 #[derive(PartialEq)]
-pub enum ArrangerViewMode { VerticalExpanded, VerticalCompact1, VerticalCompact2, Horizontal }
+pub enum ArrangerViewMode { Horizontal, Vertical(usize) }
 
 /// Arranger display mode can be cycled
 impl ArrangerViewMode {
     /// Cycle arranger display mode
     pub fn to_next (&mut self) {
         *self = match self {
-            Self::VerticalExpanded => Self::VerticalCompact1,
-            Self::VerticalCompact1 => Self::VerticalCompact2,
-            Self::VerticalCompact2 => Self::Horizontal,
-            Self::Horizontal       => Self::VerticalExpanded,
+            Self::Horizontal  => Self::Vertical(1),
+            Self::Vertical(1) => Self::Vertical(2),
+            Self::Vertical(2) => Self::Vertical(2),
+            Self::Vertical(0) => Self::Horizontal,
+            Self::Vertical(_) => Self::Vertical(0),
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-struct VerticalArranger<'a, 'b, E: Engine>(
-    &'a Arranger<E>, &'b [(usize, usize)], &'b [(usize, usize)]
-);
-
-impl<'a, 'b> Content for VerticalArranger<'a, 'b, Tui> {
+struct VerticalArranger<'a, E: Engine>(&'a Arranger<E>, usize);
+impl<'a> Content for VerticalArranger<'a, Tui> {
     type Engine = Tui;
     fn content (&self) -> impl Widget<Engine = Tui> {
-        let Self(state, cols, rows) = self;
+        let Self(state, factor) = self;
+        let ppq = 96;
+        let (cols, rows) = match factor {
+            0 => (
+                track_clip_name_lengths(state.tracks.as_slice()),
+                scene_ppqs(state.tracks.as_slice(), state.scenes.as_slice()),
+            ),
+            factor => (
+                track_clip_name_lengths(state.tracks.as_slice()),
+                (0..=state.scenes.len()).map(|i|(factor*ppq, factor*ppq*i)).collect::<Vec<_>>(),
+            ),
+        };
         let tracks: &[Sequencer<Tui>] = state.tracks.as_ref();
         let scenes = state.scenes.as_ref();
         let offset = 4 + scene_name_max_len(scenes) as u16;
         Layers::new(move |add|{
-            add(&VerticalArrangerGrid(offset, rows, cols))?;
-            add(&VerticalArrangerCursor(state.focused, state.selected, offset, cols, rows))?;
+            let rows = rows.as_ref();
+            let cols = cols.as_ref();
+            add(&VerticalArrangerGrid(offset, &rows, &cols))?;
+            add(&VerticalArrangerCursor(state.focused, state.selected, offset, &cols, &rows))?;
             add(&Split::down(|add|{
                 add(&Push::X(offset, Split::right(move |add|{
-                    for (track, (w, _)) in tracks.iter().zip(*cols) {
+                    for (track, (w, _)) in tracks.iter().zip(cols) {
                         add(&Min::XY(*w as u16, 2, Layers::new(|add|{
                             add(&Background(COLOR_BG1))?;
                             add(&track.name.read().unwrap().as_str())
@@ -513,7 +501,7 @@ impl<'a, 'b> Content for VerticalArranger<'a, 'b, Tui> {
                     Ok(())
                 })))?;
                 add(&Split::down(move |add| {
-                    for (scene, (pulses, _)) in scenes.iter().zip(*rows) {
+                    for (scene, (pulses, _)) in scenes.iter().zip(rows) {
                         let height = 1.max((pulses / 96) as u16);
                         let playing = scene.is_playing(tracks);
                         add(&Fixed::Y(height, Split::right(move |add| {