diff --git a/rio-window/src/event.rs b/rio-window/src/event.rs
--- a/rio-window/src/event.rs
+++ b/rio-window/src/event.rs
@@ -140,7 +140,7 @@
 #[derive(Debug, Clone, PartialEq)]
 pub enum Hook {
     CreateTab,
-    CloseTab,
+    Close,
     Copy,
     Paste,
     SplitDown,
diff --git a/frontends/rioterm/src/application.rs b/frontends/rioterm/src/application.rs
--- a/frontends/rioterm/src/application.rs
+++ b/frontends/rioterm/src/application.rs
@@ -1118,8 +1118,8 @@
                     route.window.screen.create_tab();
                 }
             }
-            Hook::CloseTab => {
-                route.window.screen.close_tab();
+            Hook::Close => {
+                route.window.screen.close_split_or_tab();
             }
             Hook::SplitDown => {
                 // route.window.screen.close_tab();
diff --git a/rio-backend/src/config/split.rs b/rio-backend/src/config/split.rs
--- a/rio-backend/src/config/split.rs
+++ b/rio-backend/src/config/split.rs
@@ -1,8 +1,15 @@
 use crate::config::default_bool_true;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Default, Serialize, Deserialize, PartialEq, Clone, Copy)]
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Copy)]
 pub struct Split {
     #[serde(default = "default_bool_true")]
     pub enable: bool,
+}
+
+#[allow(clippy::derivable_impls)]
+impl Default for Split {
+    fn default() -> Split {
+        Split { enable: true }
+    }
 }
diff --git a/frontends/rioterm/src/context/grid.rs b/frontends/rioterm/src/context/grid.rs
--- a/frontends/rioterm/src/context/grid.rs
+++ b/frontends/rioterm/src/context/grid.rs
@@ -1,7 +1,9 @@
 use crate::context::Context;
 use rio_backend::crosswords::grid::Dimensions;
 use rio_backend::event::EventListener;
-use rio_backend::sugarloaf::{layout::SugarDimensions, Object, RichText, Quad, ComposedQuad};
+use rio_backend::sugarloaf::{
+    layout::SugarDimensions, ComposedQuad, Object, Quad, RichText,
+};
 
 const MIN_COLS: usize = 2;
 const MIN_LINES: usize = 1;
@@ -44,6 +46,8 @@
     pub height: f32,
     pub current: usize,
     pub margin: Delta<f32>,
+    border_color: [f32; 4],
+    active_border_color: [f32; 4],
     inner: Vec<ContextGridItem<T>>,
 }
 
@@ -67,8 +71,26 @@
     }
 }
 
+impl<T: rio_backend::event::EventListener> ContextGridItem<T> {
+    #[inline]
+    pub fn context(&self) -> &Context<T> {
+        &self.val
+    }
+
+    #[inline]
+    pub fn context_mut(&mut self) -> &mut Context<T> {
+        &mut self.val
+    }
+}
+
 impl<T: rio_backend::event::EventListener> ContextGrid<T> {
-    pub fn new(context: Context<T>, margin: Delta<f32>) -> Self {
+    pub fn new(
+        context: Context<T>,
+        margin: Delta<f32>,
+        split_colors: ([f32; 4], [f32; 4]),
+    ) -> Self {
+        let border_color = split_colors.0;
+        let active_border_color = split_colors.1;
         let width = context.dimension.width;
         let height = context.dimension.height;
         let inner = vec![ContextGridItem::new(context)];
@@ -78,12 +100,24 @@
             margin,
             width,
             height,
+            border_color,
+            active_border_color,
         }
     }
 
     #[inline]
     pub fn get_grid_item(&self, index: usize) -> &ContextGridItem<T> {
         &self.inner[index]
+    }
+
+    #[inline]
+    pub fn contexts(&self) -> &Vec<ContextGridItem<T>> {
+        &self.inner
+    }
+
+    #[inline]
+    pub fn contexts_mut(&mut self) -> &mut Vec<ContextGridItem<T>> {
+        &mut self.inner
     }
 
     #[inline]
@@ -119,8 +153,21 @@
         objects
     }
 
-    pub fn plot_objects(&self, objects: &mut Vec<Object>, index: usize, margin: Delta<f32>) {
+    pub fn plot_objects(
+        &self,
+        objects: &mut Vec<Object>,
+        index: usize,
+        margin: Delta<f32>,
+    ) {
         if let Some(item) = self.inner.get(index) {
+            let border_color = if index == self.current {
+                self.active_border_color
+            } else {
+                self.border_color
+            };
+
+            let border_width = 1.0;
+
             objects.push(Object::Quad(ComposedQuad {
                 color: [0.0, 0.0, 0.0, 0.0],
                 quad: Quad {
@@ -128,23 +175,28 @@
                     shadow_blur_radius: 0.0,
                     shadow_offset: [0.0, 0.0],
                     shadow_color: [0.0, 0.0, 0.0, 0.5],
-                    border_color: [1.0, 0.0, 1.0, 1.0],
-                    border_width: 2.0,
+                    border_color,
+                    border_width: 1.0,
                     border_radius: [0.0, 0.0, 0.0, 0.0],
-                    size: [item.width, item.height],
+                    size: [
+                        item.width / item.val.dimension.dimension.scale,
+                        item.height / item.val.dimension.dimension.scale,
+                    ],
                 },
             }));
 
             objects.push(Object::RichText(RichText {
                 id: item.val.rich_text_id,
-                position: [margin.x + PADDING, margin.top_y + PADDING],
+                position: [margin.x + border_width, margin.top_y - border_width],
             }));
 
             if let Some(right_item) = item.right {
                 let new_margin = Delta {
-                    x: margin.x + item.val.dimension.width,
-                    top_y: 20.,
-                    bottom_y: 20.,
+                    x: margin.x
+                        + PADDING
+                        + (item.width / item.val.dimension.dimension.scale),
+                    top_y: margin.top_y,
+                    bottom_y: margin.bottom_y,
                 };
                 self.plot_objects(objects, right_item, new_margin);
             }
@@ -163,20 +215,56 @@
         };
     }
 
+    pub fn remove_current_grid(&mut self) {}
+
     pub fn split_right(&mut self, context: Context<T>) {
-        let old_grid_item_width = self.inner[self.current].val.dimension.width;
-        let new_grid_item_width = old_grid_item_width / 2.0;
+        // If we are moving from first to second context, needs to change height
+        let should_change_height = self.inner.len() == 1;
+
+        if should_change_height {
+            self.inner[self.current].height -= self.margin.top_y
+                * self.inner[self.current].val.dimension.dimension.scale;
+            // self.inner[self.current].val.dimension.height -= PADDING * 2.0;
+        }
+
+        let old_grid_item_width = self.inner[self.current].width;
+        let new_grid_item_width = (old_grid_item_width / 2.0) - PADDING;
         // Change grid item by half
         self.inner[self.current].width = new_grid_item_width;
         // Move content to middle
-        self.inner[self.current].val.dimension.width = new_grid_item_width - (PADDING * 2.0);
+        self.inner[self.current]
+            .val
+            .dimension
+            .update_width(new_grid_item_width - (PADDING * 2.0));
+
+        let mut terminal = self.inner[self.current].val.terminal.lock();
+        terminal.resize::<ContextDimension>(self.inner[self.current].val.dimension);
+        drop(terminal);
+        let winsize = crate::renderer::utils::terminal_dimensions(
+            &self.inner[self.current].val.dimension,
+        );
+        let _ = self.inner[self.current].val.messenger.send_resize(winsize);
 
         let mut new_context = ContextGridItem::new(context);
         new_context.width = new_grid_item_width;
-        new_context.val.dimension.width = new_grid_item_width - (PADDING * 2.0);
+        new_context.height = self.inner[self.current].height;
+
+        new_context
+            .val
+            .dimension
+            .update_width(new_grid_item_width - (PADDING * 2.0));
 
         self.inner.push(new_context);
         let new_current = self.inner.len() - 1;
+
+        let mut terminal = self.inner[new_current].val.terminal.lock();
+        terminal.resize::<ContextDimension>(self.inner[new_current].val.dimension);
+        drop(terminal);
+        let winsize = crate::renderer::utils::terminal_dimensions(
+            &self.inner[new_current].val.dimension,
+        );
+        let _ = self.inner[new_current].val.messenger.send_resize(winsize);
+
         self.inner[self.current].right = Some(new_current);
         self.current = new_current;
     }
@@ -211,6 +299,14 @@
             dimension,
             margin,
         }
+    }
+
+    pub fn update_width(&mut self, width: f32) {
+        self.width = width;
+        let (columns, lines) =
+            compute(self.width, self.height, self.dimension, 1.0, self.margin);
+        self.columns = columns;
+        self.lines = lines;
     }
 
     #[inline]
@@ -254,10 +350,6 @@
     }
 }
 
-// TODO: ContextGridItem should contain quad?
-//    - Qual a regra do quad?
-// TODO: Split right
-
 #[cfg(test)]
 pub mod test {
     use super::*;
@@ -282,7 +374,7 @@
                 height: 9.,
             },
             1.0,
-            Delta::<f32>::default()
+            Delta::<f32>::default(),
         );
 
         assert_eq!(context_dimension.columns, 66);
@@ -299,7 +391,11 @@
         let context_width = context.dimension.width;
         let context_height = context.dimension.height;
         let context_margin = context.dimension.margin;
-        let grid = ContextGrid::<VoidListener>::new(context, margin);
+        let grid = ContextGrid::<VoidListener>::new(
+            context,
+            margin,
+            ([0., 0., 0., 0.], [0., 0., 0., 0.]),
+        );
         // The first context should fill completely w/h grid
         assert_eq!(grid.width, context_width);
         assert_eq!(grid.height, context_height);
@@ -338,7 +434,7 @@
                 height: 8.,
             },
             1.0,
-            Delta::<f32>::default()
+            Delta::<f32>::default(),
         );
 
         assert_eq!(context_dimension.columns, 85);
@@ -355,7 +451,7 @@
                     rich_text_id,
                     context_dimension,
                 ),
-                rich_text_id
+                rich_text_id,
             )
         };
 
@@ -370,11 +466,15 @@
                     rich_text_id,
                     context_dimension,
                 ),
-                rich_text_id
+                rich_text_id,
             )
         };
 
-        let mut grid = ContextGrid::<VoidListener>::new(first_context, margin);
+        let mut grid = ContextGrid::<VoidListener>::new(
+            first_context,
+            margin,
+            ([0., 0., 0., 0.], [0., 0., 0., 0.]),
+        );
 
         assert_eq!(
             grid.objects(),
diff --git a/frontends/rioterm/src/context/mod.rs b/frontends/rioterm/src/context/mod.rs
--- a/frontends/rioterm/src/context/mod.rs
+++ b/frontends/rioterm/src/context/mod.rs
@@ -50,6 +50,22 @@
     }
 }
 
+impl<T: EventListener> Context<T> {
+    #[inline]
+    pub fn renderable_content(&mut self) -> &RenderableContent {
+        let terminal = self.terminal.lock();
+        self.renderable_content.update(
+            terminal.visible_rows(),
+            terminal.display_offset(),
+            terminal.cursor(),
+            terminal.blinking_cursor,
+        );
+        drop(terminal);
+
+        &self.renderable_content
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct ContextManagerConfig {
     pub shell: Shell,
@@ -60,6 +76,7 @@
     pub use_current_path: bool,
     pub is_native: bool,
     pub should_update_titles: bool,
+    pub split_colors: ([f32; 4], [f32; 4]),
 }
 
 pub struct ContextManagerTitles {
@@ -324,7 +341,11 @@
             current_index: 0,
             current_route: 0,
             acc_current_route: 0,
-            contexts: vec![ContextGrid::new(initial_context, margin)],
+            contexts: vec![ContextGrid::new(
+                initial_context,
+                margin,
+                ctx_config.split_colors,
+            )],
             capacity: DEFAULT_CONTEXT_CAPACITY,
             event_proxy,
             window_id,
@@ -351,6 +372,7 @@
             is_native: false,
             should_update_titles: false,
             use_current_path: false,
+            split_colors: ([0., 0., 0., 0.], [0., 0., 0., 0.]),
         };
         let initial_context = ContextManager::create_context(
             (&CursorState::new('_'), false),
@@ -369,7 +391,11 @@
             current_index: 0,
             current_route: 0,
             acc_current_route: 0,
-            contexts: vec![ContextGrid::new(initial_context, Delta::<f32>::default())],
+            contexts: vec![ContextGrid::new(
+                initial_context,
+                Delta::<f32>::default(),
+                config.split_colors,
+            )],
             capacity,
             event_proxy,
             window_id,
@@ -616,8 +642,23 @@
     }
 
     #[inline]
+    pub fn current_grid_len(&self) -> usize {
+        self.contexts.len()
+    }
+
+    #[inline]
+    pub fn remove_current_grid(&self) {
+        self.contexts.remove_current_grid();
+    }
+
+    #[inline]
     pub fn current_grid_mut(&mut self) -> &mut ContextGrid<T> {
         &mut self.contexts[self.current_index]
+    }
+
+    #[inline]
+    pub fn current_grid(&mut self) -> &ContextGrid<T> {
+        &self.contexts[self.current_index]
     }
 
     #[cfg(test)]
@@ -631,21 +672,6 @@
             self.current_index = context_id;
             self.current_route = self.current().route_id;
         }
-    }
-
-    #[inline]
-    pub fn renderable_content(&mut self) -> &RenderableContent {
-        let current = self.current_mut();
-        let terminal = current.terminal.lock();
-        current.renderable_content.update(
-            terminal.visible_rows(),
-            terminal.display_offset(),
-            terminal.cursor(),
-            terminal.blinking_cursor,
-        );
-        drop(terminal);
-
-        &current.renderable_content
     }
 
     #[inline]
@@ -731,7 +757,11 @@
         self.current_route = self.current().route_id;
     }
 
-    pub fn split_right(&mut self, cursor_state: (&CursorState, bool)) {
+    pub fn split_right(
+        &mut self,
+        rich_text_id: usize,
+        cursor_state: (&CursorState, bool),
+    ) {
         let mut working_dir = None;
         if self.config.use_current_path && self.config.working_dir.is_none() {
             #[cfg(not(target_os = "windows"))]
@@ -764,8 +794,8 @@
             cursor_state,
             self.event_proxy.clone(),
             self.window_id,
-            0,
             self.acc_current_route,
+            rich_text_id,
             self.current().dimension,
             &cloned_config,
         ) {
@@ -779,7 +809,12 @@
     }
 
     #[inline]
-    pub fn add_context(&mut self, redirect: bool, cursor_state: (&CursorState, bool)) {
+    pub fn add_context(
+        &mut self,
+        redirect: bool,
+        rich_text_id: usize,
+        cursor_state: (&CursorState, bool),
+    ) {
         let mut working_dir = None;
         if self.config.use_current_path && self.config.working_dir.is_none() {
             #[cfg(not(target_os = "windows"))]
@@ -823,15 +858,18 @@
                 cursor_state,
                 self.event_proxy.clone(),
                 self.window_id,
-                0,
                 self.acc_current_route,
+                rich_text_id,
                 self.current().dimension,
                 &cloned_config,
             ) {
                 Ok(new_context) => {
                     let previous_margin = self.contexts[self.current_index].margin;
-                    self.contexts
-                        .push(ContextGrid::new(new_context, previous_margin));
+                    self.contexts.push(ContextGrid::new(
+                        new_context,
+                        previous_margin,
+                        self.config.split_colors,
+                    ));
                     if redirect {
                         self.current_index = last_index;
                         self.current_route = self.current().route_id;
@@ -904,12 +942,12 @@
         assert_eq!(context_manager.current_index, 0);
 
         let should_redirect = false;
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         assert_eq!(context_manager.capacity, 5);
         assert_eq!(context_manager.current_index, 0);
 
         let should_redirect = true;
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         assert_eq!(context_manager.capacity, 5);
         assert_eq!(context_manager.current_index, 2);
     }
@@ -923,13 +961,17 @@
         assert_eq!(context_manager.capacity, 3);
         assert_eq!(context_manager.current_index, 0);
         let should_redirect = false;
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         assert_eq!(context_manager.len(), 2);
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         assert_eq!(context_manager.len(), 3);
 
         for _ in 0..20 {
-            context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+            context_manager.add_context(
+                should_redirect,
+                0,
+                (&CursorState::new('_'), false),
+            );
         }
 
         assert_eq!(context_manager.len(), 3);
@@ -944,7 +986,7 @@
             ContextManager::start_with_capacity(8, VoidListener {}, window_id).unwrap();
         let should_redirect = true;
 
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         assert_eq!(context_manager.current_index, 1);
         context_manager.set_current(0);
         assert_eq!(context_manager.current_index, 0);
@@ -952,8 +994,8 @@
         assert_eq!(context_manager.capacity, 8);
 
         let should_redirect = false;
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         context_manager.set_current(3);
         assert_eq!(context_manager.current_index, 3);
 
@@ -969,8 +1011,8 @@
             ContextManager::start_with_capacity(3, VoidListener {}, window_id).unwrap();
         let should_redirect = false;
 
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         assert_eq!(context_manager.len(), 3);
 
         assert_eq!(context_manager.current_index, 0);
@@ -992,10 +1034,10 @@
             ContextManager::start_with_capacity(5, VoidListener {}, window_id).unwrap();
         let should_redirect = false;
 
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
 
         context_manager.close_current_context();
         context_manager.close_current_context();
@@ -1005,7 +1047,7 @@
         assert_eq!(context_manager.len(), 1);
         assert_eq!(context_manager.current_index, 0);
 
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
 
         assert_eq!(context_manager.len(), 2);
         context_manager.set_current(1);
@@ -1023,8 +1065,8 @@
             ContextManager::start_with_capacity(2, VoidListener {}, window_id).unwrap();
         let should_redirect = false;
 
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         assert_eq!(context_manager.len(), 2);
         assert_eq!(context_manager.current_index, 0);
 
@@ -1044,11 +1086,11 @@
             ContextManager::start_with_capacity(5, VoidListener {}, window_id).unwrap();
         let should_redirect = false;
 
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
-        context_manager.add_context(should_redirect, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
+        context_manager.add_context(should_redirect, 0, (&CursorState::new('_'), false));
         assert_eq!(context_manager.len(), 5);
         assert_eq!(context_manager.current_index, 0);
 
diff --git a/frontends/rioterm/src/renderer/mod.rs b/frontends/rioterm/src/renderer/mod.rs
--- a/frontends/rioterm/src/renderer/mod.rs
+++ b/frontends/rioterm/src/renderer/mod.rs
@@ -724,80 +724,82 @@
         hints: &mut Option<HintMatches>,
         focused_match: &Option<RangeInclusive<Pos>>,
     ) {
+        let content = sugarloaf.content();
+
+        for grid_context in context_manager.current_grid_mut().contexts_mut() {
+            let context = grid_context.context_mut();
+            let rich_text_id = context.rich_text_id;
+            let renderable_content = context.renderable_content();
+            self.cursor.state = renderable_content.cursor.clone();
+            let mut is_cursor_visible = self.cursor.state.is_visible();
+
+            self.term_has_blinking_enabled = renderable_content.has_blinking_enabled;
+
+            // Only blink cursor if does not contain selection
+            let has_selection = self.selection_range.is_some();
+            if !has_selection && self.has_blinking_enabled() {
+                let mut should_blink = true;
+                if let Some(last_typing_time) = self.last_typing {
+                    if last_typing_time.elapsed() < Duration::from_secs(1) {
+                        should_blink = false;
+                    }
+                }
+
+                if should_blink {
+                    self.is_blinking = !self.is_blinking;
+                    is_cursor_visible = self.is_blinking;
+                }
+            }
+            let display_offset = renderable_content.display_offset;
+
+            // let mut render_strategy = &renderable_content.strategy;
+            // if has_selection {
+            //     render_strategy = &RenderableContentStrategy::Full;
+            // }
+
+            match &renderable_content.strategy {
+                RenderableContentStrategy::Full => {
+                    content.sel(rich_text_id);
+                    content.clear();
+                    for (i, row) in renderable_content.inner.iter().enumerate() {
+                        let has_cursor =
+                            is_cursor_visible && self.cursor.state.pos.row == i;
+                        self.create_line(
+                            content,
+                            row,
+                            has_cursor,
+                            None,
+                            Line((i as i32) - display_offset),
+                            hints,
+                            focused_match,
+                        );
+                    }
+                    content.build();
+                }
+                RenderableContentStrategy::Lines(lines) => {
+                    content.sel(rich_text_id);
+                    for line in lines {
+                        let line = *line;
+                        let has_cursor =
+                            is_cursor_visible && self.cursor.state.pos.row == line;
+                        content.clear_line(line);
+                        self.create_line(
+                            content,
+                            &renderable_content.inner[line],
+                            has_cursor,
+                            Some(line),
+                            Line((line as i32) - display_offset),
+                            hints,
+                            focused_match,
+                        );
+                    }
+                }
+                RenderableContentStrategy::Noop => {}
+            }
+        }
+
         let window_size = sugarloaf.window_size();
         let scale_factor = sugarloaf.scale_factor();
-        let renderable_content = context_manager.renderable_content();
-        self.cursor.state = renderable_content.cursor.clone();
-        let mut is_cursor_visible = self.cursor.state.is_visible();
-
-        self.term_has_blinking_enabled = renderable_content.has_blinking_enabled;
-
-        // Only blink cursor if does not contain selection
-        let has_selection = self.selection_range.is_some();
-        if !has_selection && self.has_blinking_enabled() {
-            let mut should_blink = true;
-            if let Some(last_typing_time) = self.last_typing {
-                if last_typing_time.elapsed() < Duration::from_secs(1) {
-                    should_blink = false;
-                }
-            }
-
-            if should_blink {
-                self.is_blinking = !self.is_blinking;
-                is_cursor_visible = self.is_blinking;
-            }
-        }
-
-        let content = sugarloaf.content();
-        let display_offset = renderable_content.display_offset;
-
-        // let mut render_strategy = &renderable_content.strategy;
-        // if has_selection {
-        //     render_strategy = &RenderableContentStrategy::Full;
-        // }
-
-        // let start = std::time::Instant::now();
-        match &renderable_content.strategy {
-            RenderableContentStrategy::Full => {
-                content.sel(0);
-                content.clear();
-                for (i, row) in renderable_content.inner.iter().enumerate() {
-                    let has_cursor = is_cursor_visible && self.cursor.state.pos.row == i;
-                    self.create_line(
-                        content,
-                        row,
-                        has_cursor,
-                        None,
-                        Line((i as i32) - display_offset),
-                        hints,
-                        focused_match,
-                    );
-                }
-                content.build();
-            }
-            RenderableContentStrategy::Lines(lines) => {
-                content.sel(0);
-                for line in lines {
-                    let line = *line;
-                    let has_cursor =
-                        is_cursor_visible && self.cursor.state.pos.row == line;
-                    content.clear_line(line);
-                    self.create_line(
-                        content,
-                        &renderable_content.inner[line],
-                        has_cursor,
-                        Some(line),
-                        Line((line as i32) - display_offset),
-                        hints,
-                        focused_match,
-                    );
-                }
-            }
-            RenderableContentStrategy::Noop => {}
-        }
-        // let duration = start.elapsed();
-        // println!("Total loop rows: {:?}", duration);
-
         let mut objects = Vec::with_capacity(30);
         self.navigation.build_objects(
             (window_size.width, window_size.height, scale_factor),
diff --git a/frontends/rioterm/src/screen/mod.rs b/frontends/rioterm/src/screen/mod.rs
--- a/frontends/rioterm/src/screen/mod.rs
+++ b/frontends/rioterm/src/screen/mod.rs
@@ -203,6 +203,7 @@
             // does not make sense fetch for foreground process names
             should_update_titles: !(is_collapsed
                 && config.navigation.color_automation.is_empty()),
+            split_colors: (config.colors.split, config.colors.split_active),
         };
 
         let rich_text_id = sugarloaf.create_rich_text();
@@ -963,7 +964,9 @@
     }
 
     pub fn split_right(&mut self) {
+        let rich_text_id = self.sugarloaf.create_rich_text();
         self.context_manager.split_right(
+            rich_text_id,
             (
                 &self.renderer.get_cursor_state_from_ref(),
                 self.renderer.config_has_blinking_enabled,
@@ -976,8 +979,10 @@
     pub fn create_tab(&mut self) {
         let redirect = true;
 
+        let rich_text_id = self.sugarloaf.create_rich_text();
         self.context_manager.add_context(
             redirect,
+            rich_text_id,
             (
                 &self.renderer.get_cursor_state_from_ref(),
                 self.renderer.config_has_blinking_enabled,
@@ -988,6 +993,14 @@
         self.cancel_search();
         self.resize_top_or_bottom_line(num_tabs);
         self.render();
+    }
+
+    pub fn close_split_or_tab(&mut self) {
+        self.clear_selection();
+
+        if self.context_manager.current_grid_len() > 1 {
+            self.context_manager.remove_current_grid();
+        }
     }
 
     pub fn close_tab(&mut self) {
diff --git a/rio-backend/src/config/colors/defaults.rs b/rio-backend/src/config/colors/defaults.rs
--- a/rio-backend/src/config/colors/defaults.rs
+++ b/rio-backend/src/config/colors/defaults.rs
@@ -141,6 +141,20 @@
 }
 
 #[inline]
+pub fn split() -> ColorArray {
+    ColorBuilder::from_hex(String::from("#292527"), Format::SRGB0_1)
+        .unwrap()
+        .to_arr()
+}
+
+#[inline]
+pub fn split_active() -> ColorArray {
+    ColorBuilder::from_hex(String::from("#12d0ff"), Format::SRGB0_1)
+        .unwrap()
+        .to_arr()
+}
+
+#[inline]
 pub fn dim_blue() -> ColorArray {
     ColorBuilder::from_hex(String::from("#0E91B7"), Format::SRGB0_1)
         .unwrap()
diff --git a/rio-backend/src/config/colors/mod.rs b/rio-backend/src/config/colors/mod.rs
--- a/rio-backend/src/config/colors/mod.rs
+++ b/rio-backend/src/config/colors/mod.rs
@@ -240,8 +240,13 @@
         rename = "selection-foreground"
     )]
     pub selection_foreground: ColorArray,
-    #[serde(default = "defaults::cursor", deserialize_with = "deserialize_to_arr")]
+    #[serde(default = "defaults::split", deserialize_with = "deserialize_to_arr")]
     pub split: ColorArray,
+    #[serde(
+        default = "defaults::split_active",
+        deserialize_with = "deserialize_to_arr"
+    )]
+    pub split_active: ColorArray,
     #[serde(
         default = "defaults::search_match_background",
         deserialize_with = "deserialize_to_arr",
@@ -284,7 +289,8 @@
             tabs_active_foreground: defaults::tabs_active_foreground(),
             tabs_foreground: defaults::tabs_foreground(),
             cursor: defaults::cursor(),
-            split: defaults::cursor(),
+            split: defaults::split(),
+            split_active: defaults::split_active(),
             vi_cursor: defaults::vi_cursor(),
             black: defaults::black(),
             cyan: defaults::cyan(),
diff --git a/rio-window/src/platform_impl/macos/app_delegate.rs b/rio-window/src/platform_impl/macos/app_delegate.rs
--- a/rio-window/src/platform_impl/macos/app_delegate.rs
+++ b/rio-window/src/platform_impl/macos/app_delegate.rs
@@ -195,10 +195,10 @@
             }
         }
 
-        #[method(rioCloseTab:)]
+        #[method(rioClose:)]
         fn close_tab(&self, _sender: Option<&AnyObject>) {
             if self.is_launched() {
-                self.dispatch_hook(Hook::CloseTab);
+                self.dispatch_hook(Hook::Close);
             }
         }
 
diff --git a/rio-window/src/platform_impl/macos/menu.rs b/rio-window/src/platform_impl/macos/menu.rs
--- a/rio-window/src/platform_impl/macos/menu.rs
+++ b/rio-window/src/platform_impl/macos/menu.rs
@@ -132,11 +132,11 @@
         }),
     );
 
-    let close_tab_item_title = ns_string!("Close Tab");
-    let close_tab_item = menu_item(
+    let close_item_title = ns_string!("Close");
+    let close_item = menu_item(
         mtm,
-        close_tab_item_title,
-        Some(sel!(rioCloseTab:)),
+        close_item_title,
+        Some(sel!(rioClose:)),
         Some(KeyEquivalent {
             key: ns_string!("w"),
             masks: Some(NSEventModifierFlags::NSEventModifierFlagCommand),
@@ -207,7 +207,7 @@
     app_menu_item.setSubmenu(Some(&app_menu));
     shell_menu.addItem(&create_window_item);
     shell_menu.addItem(&create_tab_item);
-    shell_menu.addItem(&close_tab_item);
+    shell_menu.addItem(&close_item);
     shell_menu.addItem(&create_split_horizontally_item);
     shell_menu.addItem(&create_split_vertical_item);
     shell_menu_item.setSubmenu(Some(&shell_menu));