diff --git a/src/sequencer.rs b/src/sequencer.rs
index 45ff8cef..d4ba4a41 100644
--- a/src/sequencer.rs
+++ b/src/sequencer.rs
@@ -17,7 +17,13 @@ pub struct Sequencer {
     exited:   bool,
     jack:     Jack<Notifications>,
     cursor:   (u16, u16, u16),
-    sequence: Vec<()>,
+    sequence: Vec<Vec<Option<Event>>>,
+}
+
+#[derive(Clone)]
+pub enum Event {
+    NoteOn(u8, u8),
+    NoteOff(u8)
 }
 
 impl Sequencer {
@@ -38,7 +44,7 @@ impl Sequencer {
             exited: false,
             cursor: (0, 0, 0),
             jack,
-            sequence: vec![],
+            sequence: vec![vec![None;64];4],
         })
     }
 }
diff --git a/src/sequencer/handle.rs b/src/sequencer/handle.rs
index 6fe93fa6..cebac790 100644
--- a/src/sequencer/handle.rs
+++ b/src/sequencer/handle.rs
@@ -1,7 +1,7 @@
 use crate::prelude::*;
 use super::Sequencer;
 
-pub fn handle (state: &mut Sequencer,event: &Event) -> Result<(), Box<dyn Error>> {
+pub fn handle (state: &mut Sequencer, event: &Event) -> Result<(), Box<dyn Error>> {
 
     if let Event::Key(event) = event {
 
@@ -11,6 +11,34 @@ pub fn handle (state: &mut Sequencer,event: &Event) -> Result<(), Box<dyn Error>
                     state.exit();
                 }
             },
+            KeyCode::Down => {
+                state.cursor.0 = if state.cursor.0 >= 3 {
+                    0
+                } else {
+                    state.cursor.0 + 1
+                }
+            },
+            KeyCode::Up => {
+                state.cursor.0 = if state.cursor.0 == 0 {
+                    3
+                } else {
+                    state.cursor.0 - 1
+                }
+            },
+            KeyCode::Left => {
+                state.cursor.1 = if state.cursor.1 == 0 {
+                    63
+                } else {
+                    state.cursor.1 - 1
+                }
+            },
+            KeyCode::Right => {
+                state.cursor.1 = if state.cursor.1 == 63 {
+                    0
+                } else {
+                    state.cursor.1 + 1
+                }
+            },
             KeyCode::Char('[') => {
                 if state.cursor.2 > 0 {
                     state.cursor.2 = state.cursor.2 - 1
@@ -19,36 +47,15 @@ pub fn handle (state: &mut Sequencer,event: &Event) -> Result<(), Box<dyn Error>
             KeyCode::Char(']') => {
                 state.cursor.2 = state.cursor.2 + 1
             },
-            KeyCode::Down => {
-                state.cursor.1 = if state.cursor.1 >= 3 {
-                    0
-                } else {
-                    state.cursor.1 + 1
+            KeyCode::Char('a') => {
+                let row      = state.cursor.0 as usize;
+                let step     = state.cursor.1 as usize;
+                let duration = state.cursor.2 as usize;
+                state.sequence[row][step] = Some(super::Event::NoteOn(35, 128));
+                if state.cursor.2 > 0 {
+                    state.sequence[row][step + duration] = Some(super::Event::NoteOff(35));
                 }
             },
-            KeyCode::Up => {
-                state.cursor.1 = if state.cursor.1 == 0 {
-                    3
-                } else {
-                    state.cursor.1 - 1
-                }
-            },
-            KeyCode::Left => {
-                state.cursor.0 = if state.cursor.0 == 0 {
-                    63
-                } else {
-                    state.cursor.0 - 1
-                }
-            },
-            KeyCode::Right => {
-                state.cursor.0 = if state.cursor.0 == 63 {
-                    0
-                } else {
-                    state.cursor.0 + 1
-                }
-            },
-            KeyCode::Char('A') => {
-            },
             _ => {
                 println!("{event:?}");
             }
diff --git a/src/sequencer/render.rs b/src/sequencer/render.rs
index 225ee87d..b5253462 100644
--- a/src/sequencer/render.rs
+++ b/src/sequencer/render.rs
@@ -20,7 +20,7 @@ fn render_grid (
     let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
     let bg = "┊···············┊···············┊···············┊···············";
     let cursor: String = if state.cursor.2 == 0 {
-        "X".into()
+        "❱".into()
     } else {
         std::iter::repeat("·")
             .take(state.cursor.2 as usize)
@@ -30,12 +30,23 @@ fn render_grid (
         .queue(move_to(1,  3))?.queue(Print("1.1"))?
         .queue(move_to(17, 3))?.queue(Print("1.2"))?
         .queue(move_to(33, 3))?.queue(Print("1.3"))?
-        .queue(move_to(49, 3))?.queue(Print("1.4"))?
-        .queue(move_to(1, 4))?.queue(PrintStyledContent(bg.grey()))?
-        .queue(move_to(1, 5))?.queue(PrintStyledContent(bg.grey()))?
-        .queue(move_to(1, 6))?.queue(PrintStyledContent(bg.grey()))?
-        .queue(move_to(1, 7))?.queue(PrintStyledContent(bg.grey()))?
-        .queue(move_to(1 + state.cursor.0, 4 + state.cursor.1))?
+        .queue(move_to(49, 3))?.queue(Print("1.4"))?;
+    for (index, row) in state.sequence.iter().enumerate() {
+        let y = index as u16 + 4;
+        stdout.queue(move_to(1, y))?.queue(
+            PrintStyledContent(bg.grey())
+        )?;
+        for (index, step) in row.iter().enumerate() {
+            if step.is_some() {
+                let x = index as u16 + 1;
+                stdout.queue(move_to(x, y))?.queue(
+                    PrintStyledContent("X".white().bold())
+                )?;
+            }
+        }
+    }
+    stdout
+        .queue(move_to(1 + state.cursor.1, 4 + state.cursor.0))?
         .queue(PrintStyledContent(cursor.reverse()))?;
     Ok(())
 }