diff --git a/src/main.rs b/src/main.rs
index 5d38ba9..9581223 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -29,15 +29,18 @@ struct Cli {
 
 #[derive(Subcommand, Debug)]
 enum Command {
-    #[clap(about = "Initialize the workspaces for all the outputs")]
+    #[clap(about = "Initialize the workspace groups for all the outputs")]
     Init(InitAction),
 
-    #[clap(about = "Move the focused container to another workspace on the same output")]
+    #[clap(about = "Move the focused container to another workspace on the same workspace group")]
     Move(MoveAction),
 
-    #[clap(about = "Focus to another workspace on the same output")]
+    #[clap(about = "Focus to another workspace on the same workspace group")]
     Focus(FocusAction),
 
+    #[clap(about = "Focus to workspace group")]
+    FocusGroup(FocusAction),
+
     #[clap(about = "Focus to another workspace on all the outputs")]
     FocusAllOutputs(FocusAction),
 
@@ -47,6 +50,12 @@ enum Command {
     #[clap(about = "Move the focused container to the previous output")]
     PrevOutput,
 
+    #[clap(about = "Move the focused container to the next group")]
+    NextGroup,
+
+    #[clap(about = "Move the focused container to the previous group")]
+    PrevGroup,
+
     #[clap(about = "Rearrange already opened workspaces")]
     RearrangeWorkspaces,
 }
@@ -195,7 +204,7 @@ fn get_current_output_index(stream: &UnixStream) -> usize {
     let outputs = get_outputs(stream);
 
     match outputs.iter().position(|x| x.focused) {
-        Some(i) => i,
+        Some(i) => i + 1,
         None => panic!("WTF! No focused output???"),
     }
 }
@@ -211,9 +220,111 @@ fn get_current_output_name(stream: &UnixStream) -> String {
     focused_output_index.to_string()
 }
 
+fn get_current_workspace(stream: &UnixStream) -> Workspace {
+    let outputs = get_outputs(stream);
+    let workspaces = get_workspaces(stream);
+    workspaces
+        .into_iter()
+        .find(|w| w.visible && outputs.iter().find(|o| o.name == w.output).unwrap().focused)
+        .unwrap()
+}
+
 fn move_container_to_workspace(stream: &UnixStream, workspace_index: usize) {
+    if workspace_index < 10 {
+        move_container_to_workspace_relative(stream, workspace_index);
+    } else {
+        move_container_to_workspace_absolute(stream, workspace_index);
+    }
+}
+
+fn move_container_to_workspace_absolute(stream: &UnixStream, workspace_index: usize) {
+    let output_index = (workspace_index / 10) as usize;
+    let outputs = get_outputs(stream);
+    let workspaces = get_workspaces(stream);
+
+    // If the workspace already exists
+    match workspaces.iter().find(|w| w.num == workspace_index) {
+        Some(_) => {
+            let mut focus_cmd: String = "move container to workspace number ".to_string();
+            focus_cmd.push_str(&workspace_index.to_string());
+            send_command(stream, &focus_cmd);
+        }
+        None => {
+            let target_group = workspace_index / 10;
+            let target_screen_index = match workspaces.iter().find(|w| w.num / 10 == target_group) {
+                // If other workspaces on the same group exists
+                Some(other_workspace) => Some(
+                    outputs
+                        .iter()
+                        .enumerate()
+                        .find(|i| i.1.name == other_workspace.output)
+                        .unwrap()
+                        .0,
+                ),
+                None => {
+                    // Or if the targeted output is currently connected
+                    if output_index < outputs.len() {
+                        Some(output_index)
+                    } else {
+                        None
+                    }
+                }
+            };
+
+            match target_screen_index {
+                // If we have to send it to another screen
+                Some(target_screen_index) => {
+                    let target_output = &outputs[target_screen_index - 1];
+
+                    let current_output_name = get_current_output_name(stream);
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&target_output.name);
+                    send_command(stream, &focus_cmd);
+
+                    let focused_workspace_index = get_current_workspace(stream).num;
+
+                    let mut focus_cmd: String = "workspace ".to_string();
+                    focus_cmd.push_str(&workspace_index.to_string());
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&current_output_name);
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "move container to workspace ".to_string();
+                    focus_cmd.push_str(&workspace_index.to_string());
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&target_output.name);
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "workspace ".to_string();
+                    focus_cmd.push_str(&focused_workspace_index.to_string());
+                    send_command(stream, &focus_cmd);
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&current_output_name);
+                    send_command(stream, &focus_cmd);
+                }
+                None => {
+                    // Else, we send the container on the current output
+                    let mut focus_cmd: String = "move container to workspace ".to_string();
+                    focus_cmd.push_str(&workspace_index.to_string());
+                    send_command(stream, &focus_cmd);
+                }
+            };
+        }
+    }
+}
+
+fn move_container_to_workspace_relative(stream: &UnixStream, workspace_index: usize) {
+    let current_workspace_index: usize = get_current_workspace(stream).num;
+    let focused_output_index = current_workspace_index / 10;
+
     let mut cmd: String = "move container to workspace number ".to_string();
-    let full_ws_name = format!("{}{}", get_current_output_index(stream), workspace_index)
+    let full_ws_name = format!("{}{}", focused_output_index, workspace_index)
         .parse::<i32>()
         .unwrap();
     cmd.push_str(&full_ws_name.to_string());
@@ -221,14 +332,136 @@ fn move_container_to_workspace(stream: &UnixStream, workspace_index: usize) {
 }
 
 fn focus_to_workspace(stream: &UnixStream, workspace_index: usize) {
+    if workspace_index < 10 {
+        focus_to_workspace_relative(stream, workspace_index);
+    } else {
+        focus_to_workspace_absolute(stream, workspace_index);
+    }
+}
+
+fn focus_to_workspace_absolute(stream: &UnixStream, workspace_index: usize) {
+    let output_index = (workspace_index / 10) as usize;
+    let outputs = get_outputs(stream);
+    let workspaces = get_workspaces(stream);
+
+    // If the workspace already exists
+    match workspaces.iter().find(|w| w.num == workspace_index) {
+        Some(_) => {
+            let mut focus_cmd: String = "workspace number ".to_string();
+            focus_cmd.push_str(&workspace_index.to_string());
+            send_command(stream, &focus_cmd);
+        }
+        None => {
+            let target_group = workspace_index / 10;
+            let target_screen_index = match workspaces.iter().find(|w| w.num / 10 == target_group) {
+                // If other workspaces on the same group exists
+                Some(other_workspace) => Some(
+                    outputs
+                        .iter()
+                        .enumerate()
+                        .find(|i| i.1.name == other_workspace.output)
+                        .unwrap()
+                        .0,
+                ),
+                None => {
+                    // Or if the targeted output is currently connected
+                    if output_index < outputs.len() {
+                        Some(output_index)
+                    } else {
+                        None
+                    }
+                }
+            };
+
+            match target_screen_index {
+                // If we have to send it to another screen
+                Some(target_screen_index) => {
+                    let target_output = &outputs[target_screen_index - 1];
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&target_output.name);
+                    send_command(stream, &focus_cmd);
+                }
+                None => {}
+            };
+            // Then we focus the workspace
+            let mut focus_cmd: String = "workspace number ".to_string();
+            focus_cmd.push_str(&workspace_index.to_string());
+            send_command(stream, &focus_cmd);
+        }
+    }
+}
+
+fn focus_to_workspace_relative(stream: &UnixStream, workspace_index: usize) {
+    let current_workspace_index: usize = get_current_workspace(stream).num;
+    let focused_output_index = current_workspace_index / 10;
+
     let mut cmd: String = "workspace number ".to_string();
-    let full_ws_name = format!("{}{}", get_current_output_index(stream), &workspace_index)
+    let full_ws_name = format!("{}{}", focused_output_index, &workspace_index)
         .parse::<i32>()
         .unwrap();
     cmd.push_str(&full_ws_name.to_string());
     send_command(stream, &cmd);
 }
 
+fn focus_to_group(stream: &UnixStream, group_index: usize) {
+    let outputs = get_outputs(stream);
+    let workspaces = get_workspaces(stream);
+
+    let current_workspace_index: usize = get_current_workspace(stream).num;
+    let contextual_target_workspace_index =
+        current_workspace_index - (current_workspace_index / 10) * 10;
+
+    let target_workspace_index = group_index * 10 + contextual_target_workspace_index;
+
+    // If the workspace already exists
+    match workspaces.iter().find(|w| w.num == target_workspace_index) {
+        Some(_) => {
+            let mut focus_cmd: String = "workspace number ".to_string();
+            focus_cmd.push_str(&target_workspace_index.to_string());
+            send_command(stream, &focus_cmd);
+        }
+        None => {
+            let target_screen_index = match workspaces.iter().find(|w| w.num / 10 == group_index) {
+                // If other workspaces on the same group exists
+                Some(other_workspace) => Some(
+                    outputs
+                        .iter()
+                        .enumerate()
+                        .find(|i| i.1.name == other_workspace.output)
+                        .unwrap()
+                        .0
+                        + 1,
+                ),
+                None => {
+                    // Or if the targeted output is currently connected
+                    if group_index <= outputs.len() {
+                        Some(group_index)
+                    } else {
+                        None
+                    }
+                }
+            };
+
+            match target_screen_index {
+                // If we have to send it to another screen
+                Some(target_screen_index) => {
+                    let target_output = &outputs[target_screen_index - 1];
+
+                    let mut focus_cmd: String = "focus output ".to_string();
+                    focus_cmd.push_str(&target_output.name);
+                    send_command(stream, &focus_cmd);
+                }
+                None => {}
+            };
+            // Then we focus the workspace
+            let mut focus_cmd: String = "workspace number ".to_string();
+            focus_cmd.push_str(&target_workspace_index.to_string());
+            send_command(stream, &focus_cmd);
+        }
+    }
+}
+
 fn focus_all_outputs_to_workspace(stream: &UnixStream, workspace_index: usize) {
     let current_output = get_current_output_name(stream);
 
@@ -258,15 +491,12 @@ fn move_container_to_prev_output(stream: &UnixStream) {
 
 fn move_container_to_next_or_prev_output(stream: &UnixStream, go_to_prev: bool) {
     let outputs = get_outputs(stream);
-    let focused_output_index = match outputs.iter().position(|x| x.focused) {
-        Some(i) => i,
-        None => panic!("WTF! No focused output???"),
-    };
+    let focused_output_index = get_current_output_index(stream);
 
     let target_output = if go_to_prev {
-        &outputs[(focused_output_index + outputs.len() - 1) % outputs.len()]
+        &outputs[(focused_output_index + outputs.len() - 1) % outputs.len() - 1]
     } else {
-        &outputs[(focused_output_index + 1) % outputs.len()]
+        &outputs[(focused_output_index + 1) % outputs.len() - 1]
     };
 
     let workspaces = get_workspaces(stream);
@@ -286,6 +516,25 @@ fn move_container_to_next_or_prev_output(stream: &UnixStream, go_to_prev: bool)
     send_command(stream, &cmd);
 }
 
+fn focus_container_to_next_group(stream: &UnixStream) {
+    focus_container_to_next_or_prev_group(stream, false);
+}
+
+fn focus_container_to_prev_group(stream: &UnixStream) {
+    focus_container_to_next_or_prev_group(stream, true);
+}
+
+fn focus_container_to_next_or_prev_group(stream: &UnixStream, go_to_prev: bool) {
+    let current_workspace_index: usize = get_current_workspace(stream).num;
+    let focused_group_index = current_workspace_index / 10;
+
+    if go_to_prev {
+        focus_to_group(stream, focused_group_index - 1);
+    } else {
+        focus_to_group(stream, focused_group_index + 1);
+    };
+}
+
 fn init_workspaces(stream: &UnixStream, workspace_index: usize) {
     let outputs = get_outputs(stream);
 
@@ -294,7 +543,13 @@ fn init_workspaces(stream: &UnixStream, workspace_index: usize) {
         let mut cmd = cmd_prefix.clone();
         cmd.push_str(output.name.as_str());
         send_command(stream, &cmd);
-        focus_to_workspace(stream, workspace_index);
+
+        let mut cmd: String = "workspace number ".to_string();
+        let full_ws_name = format!("{}{}", get_current_output_index(stream), &workspace_index)
+            .parse::<i32>()
+            .unwrap();
+        cmd.push_str(&full_ws_name.to_string());
+        send_command(stream, &cmd);
     }
 }
 
@@ -310,9 +565,9 @@ fn rearrange_workspaces(stream: &UnixStream) {
         send_command(stream, &focus_cmd);
 
         let output_index = workspace.num / 10;
-        if output_index < outputs.len() {
+        if output_index <= outputs.len() - 1 {
             let mut move_cmd = move_cmd_prefix.clone();
-            move_cmd.push_str(&outputs[output_index].name);
+            move_cmd.push_str(&outputs[output_index.max(1) - 1].name);
             send_command(stream, &move_cmd);
         }
     }
@@ -332,6 +587,9 @@ fn main() {
         Command::Focus(action) => {
             focus_to_workspace(&stream, action.index);
         }
+        Command::FocusGroup(action) => {
+            focus_to_group(&stream, action.index);
+        }
         Command::FocusAllOutputs(action) => {
             focus_all_outputs_to_workspace(&stream, action.index);
         }
@@ -341,6 +599,12 @@ fn main() {
         Command::PrevOutput => {
             move_container_to_prev_output(&stream);
         }
+        Command::NextGroup => {
+            focus_container_to_next_group(&stream);
+        }
+        Command::PrevGroup => {
+            focus_container_to_prev_group(&stream);
+        }
         Command::RearrangeWorkspaces => {
             rearrange_workspaces(&stream);
         }