diff --git a/src/model/track.rs b/src/model/track.rs
index 6141416a..ac5cadae 100644
--- a/src/model/track.rs
+++ b/src/model/track.rs
@@ -141,40 +141,61 @@ impl Track {
         } else if reset {
             all_notes_off(&mut self.midi_out_buf);
         }
-        // Play from phrase into output buffer
+        // For highlighting keys and note repeat
+        // Currently playing phrase
         let phrase = &mut self.sequence.map(|id|self.phrases.get_mut(id)).flatten();
         if playing == Some(TransportState::Rolling) {
-            if let Some((start_frame, start_usec)) = started {
-                if let Some(phrase) = phrase {
-                    phrase.process_out(
-                        &mut self.midi_out_buf,
-                        &mut self.notes_on,
-                        timebase,
-                        (frame0.saturating_sub(start_frame), frames, period)
-                    );
+            if let (Some(phrase), Some((start_frame, _))) = (phrase, started) {
+                // Output playback from sequencer
+                phrase.process_out(
+                    &mut self.midi_out_buf,
+                    &mut self.notes_on,
+                    timebase,
+                    (frame0.saturating_sub(start_frame), frames, period)
+                );
+                // Monitor and record input
+                if self.recording || self.monitoring {
+                    let notes_on = &mut self.notes_on;
+                    for (frame, event, bytes) in parse_midi_input(input) {
+                        match event {
+                            LiveEvent::Midi { message, .. } => {
+                                if monitoring {
+                                    self.midi_out_buf[frame].push(bytes.to_vec())
+                                }
+                                if recording {
+                                    phrase.record_event({
+                                        let pulse = timebase.frame_to_pulse(
+                                            (frame0 + frame - start_frame) as f64
+                                        );
+                                        let quantized = (
+                                            pulse / quant as f64
+                                        ).round() as usize * quant;
+                                        let looped = quantized % phrase.length;
+                                        looped
+                                    }, message);
+                                }
+                                match message {
+                                    MidiMessage::NoteOn { key, .. } => {
+                                        notes_on[key.as_int() as usize] = true;
+                                    }
+                                    MidiMessage::NoteOff { key, .. } => {
+                                        notes_on[key.as_int() as usize] = false;
+                                    },
+                                    _ => {}
+                                }
+                            },
+                            _ => {}
+                        }
+                    }
                 }
             }
-        }
-        // Monitor and record input
-        if self.recording || self.monitoring {
-            // For highlighting keys
+        } else if self.monitoring {
+            // For highlighting keys and note repeat
             let notes_on = &mut self.notes_on;
             for (frame, event, bytes) in parse_midi_input(input) {
                 match event {
                     LiveEvent::Midi { message, .. } => {
-                        if monitoring {
-                            self.midi_out_buf[frame].push(bytes.to_vec())
-                        }
-                        if recording {
-                            if let Some((start_frame, _)) = started {
-                                phrase.as_mut().map(|p|p.record_event({
-                                    let pulse = timebase.frame_to_pulse((frame0 + frame - start_frame) as f64);
-                                    let quantized = (pulse / quant as f64).round() as usize * quant;
-                                    let looped = quantized % p.length;
-                                    looped
-                                }, message));
-                            }
-                        }
+                        self.midi_out_buf[frame].push(bytes.to_vec());
                         match message {
                             MidiMessage::NoteOn { key, .. } => {
                                 notes_on[key.as_int() as usize] = true;
diff --git a/src/view/sequencer.rs b/src/view/sequencer.rs
index ddd0daaf..468a512c 100644
--- a/src/view/sequencer.rs
+++ b/src/view/sequencer.rs
@@ -106,15 +106,17 @@ mod horizontal {
         cell_lo.set_char('▄');
         cell_lo.set_style(dim);
 
-        let keys = [&cell_lo, &cell_lo, &cell_full, &cell_hi, &cell_hi, &cell_hi];
+        let cell_keys = [&cell_lo, &cell_lo, &cell_full, &cell_hi, &cell_hi, &cell_hi];
 
         let Rect { x, y, width, height } = area;
         let height = height.min(128);
         let h = height.saturating_sub(2);
         for index in 0..h {
             let y = y + h - index;
-            *buf.get_mut(x + 1, y) = keys[(index % 6) as usize].clone();
-            *buf.get_mut(x + 2, y) = cell_full.clone();
+            let key1 = buf.get_mut(x + 1, y);
+            *key1 = cell_keys[(index % 6) as usize].clone();
+            let key2 = buf.get_mut(x + 2, y);
+            *key2 = cell_full.clone();
             for x in x+5..x+width-1 {
                 *buf.get_mut(x, y) = cell_bg.clone();
             }