diff --git a/src/events.rs b/src/bridge/events.rs
similarity index 97%
rename from src/events.rs
rename to src/bridge/events.rs
index 3710e1e..a515dad 100644
--- a/src/events.rs
+++ b/src/bridge/events.rs
@@ -1,600 +1,600 @@
-use std::error;
-use std::fmt;
-
-use rmpv::Value;
-use skulpin::skia_safe::Color4f;
-
-use crate::editor::{Colors, Style, CursorMode, CursorShape};
-
-#[derive(Debug, Clone)]
-pub enum EventParseError {
-    InvalidArray(Value),
-    InvalidMap(Value),
-    InvalidString(Value),
-    InvalidU64(Value),
-    InvalidI64(Value),
-    InvalidBool(Value),
-    InvalidEventFormat
-}
-type Result<T> = std::result::Result<T, EventParseError>;
-
-impl fmt::Display for EventParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            EventParseError::InvalidArray(value) => write!(f, "invalid array format {}", value),
-            EventParseError::InvalidMap(value) => write!(f, "invalid map format {}", value),
-            EventParseError::InvalidString(value) => write!(f, "invalid string format {}", value),
-            EventParseError::InvalidU64(value) => write!(f, "invalid u64 format {}", value),
-            EventParseError::InvalidI64(value) => write!(f, "invalid i64 format {}", value),
-            EventParseError::InvalidBool(value) => write!(f, "invalid bool format {}", value),
-            EventParseError::InvalidEventFormat => write!(f, "invalid event format")
-        }
-    }
-}
-
-impl error::Error for EventParseError {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        None
-    }
-}
-
-#[derive(Debug)]
-pub struct GridLineCell {
-    pub text: String,
-    pub highlight_id: Option<u64>,
-    pub repeat: Option<u64>
-}
-
-pub type StyledContent = Vec<(u64, String)>;
-
-#[derive(Debug)]
-pub enum MessageKind {
-    Unknown,
-    Confirm,
-    ConfirmSubstitute,
-    Error,
-    Echo,
-    EchoMessage,
-    EchoError,
-    LuaError,
-    RpcError,
-    ReturnPrompt,
-    QuickFix,
-    SearchCount,
-    Warning
-}
-
-impl MessageKind {
-    pub fn parse(kind: &str) -> MessageKind {
-        match kind {
-            "confirm" => MessageKind::Confirm,
-            "confirm_sub" => MessageKind::ConfirmSubstitute,
-            "emsg" => MessageKind::Error,
-            "echo" => MessageKind::Echo,
-            "echomsg" => MessageKind::EchoMessage,
-            "echoerr" => MessageKind::EchoError,
-            "lua_error" => MessageKind::LuaError,
-            "rpc_error" => MessageKind::RpcError,
-            "return_prompt" => MessageKind::ReturnPrompt,
-            "quickfix" => MessageKind::QuickFix,
-            "search_count" => MessageKind::SearchCount,
-            "wmsg" => MessageKind::Warning,
-            _ => MessageKind::Unknown
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum GuiOption {
-    AribicShape(bool),
-    AmbiWidth(String),
-    Emoji(bool),
-    GuiFont(String),
-    GuiFontSet(String),
-    GuiFontWide(String),
-    LineSpace(u64),
-    Pumblend(u64),
-    ShowTabLine(u64),
-    TermGuiColors(bool),
-    Unknown(String, Value)
-}
-
-#[derive(Debug)]
-pub enum RedrawEvent {
-    SetTitle { title: String },
-    ModeInfoSet { cursor_modes: Vec<CursorMode> },
-    OptionSet { gui_option: GuiOption },
-    ModeChange { mode_index: u64 },
-    BusyStart,
-    BusyStop,
-    Flush,
-    Resize { grid: u64, width: u64, height: u64 },
-    DefaultColorsSet { colors: Colors },
-    HighlightAttributesDefine { id: u64, style: Style },
-    GridLine { grid: u64, row: u64, column_start: u64, cells: Vec<GridLineCell> },
-    Clear { grid: u64 },
-    CursorGoto { grid: u64, row: u64, column: u64 },
-    Scroll { grid: u64, top: u64, bottom: u64, left: u64, right: u64, rows: i64, columns: i64 },
-    CommandLineShow { content: StyledContent, position: u64, first_character: String, prompt: String, indent: u64, level: u64 },
-    CommandLinePosition { position: u64, level: u64 },
-    CommandLineSpecialCharacter { character: String, shift: bool, level: u64 },
-    CommandLineHide,
-    CommandLineBlockShow { lines: Vec<StyledContent> },
-    CommandLineBlockAppend { line: StyledContent },
-    CommandLineBlockHide,
-    MessageShow { kind: MessageKind, content: StyledContent, replace_last: bool },
-    MessageClear,
-    MessageShowMode { content: StyledContent },
-    MessageShowCommand { content: StyledContent },
-    MessageRuler { content: StyledContent },
-    MessageHistoryShow { entries: Vec<(MessageKind, StyledContent)>}
-}
-
-fn unpack_color(packed_color: u64) -> Color4f {
-    let packed_color = packed_color as u32;
-    let r = ((packed_color & 0xff0000) >> 16) as f32;
-    let g = ((packed_color & 0xff00) >> 8) as f32;
-    let b = (packed_color & 0xff) as f32;
-    Color4f {
-        r: r / 255.0,
-        g: g / 255.0,
-        b: b / 255.0,
-        a: 1.0
-    }
-}
-
-fn parse_array(array_value: &Value) -> Result<Vec<Value>> {
-    if let Value::Array(content) = array_value.clone() {
-        Ok(content.to_vec())
-    } else {
-        Err(EventParseError::InvalidArray(array_value.clone()))
-    }
-}
-
-fn parse_map(map_value: &Value) -> Result<Vec<(Value, Value)>> {
-    if let Value::Map(content) = map_value.clone() {
-        Ok(content)
-    } else {
-        Err(EventParseError::InvalidMap(map_value.clone()))
-    }
-}
-
-fn parse_string(string_value: &Value) -> Result<String> {
-    if let Value::String(content) = string_value.clone() {
-        Ok(content.into_str().ok_or(EventParseError::InvalidString(string_value.clone()))?)
-    } else {
-        Err(EventParseError::InvalidString(string_value.clone()))
-    }
-}
-
-fn parse_u64(u64_value: &Value) -> Result<u64> {
-    if let Value::Integer(content) = u64_value.clone() {
-        Ok(content.as_u64().ok_or(EventParseError::InvalidU64(u64_value.clone()))?)
-    } else {
-        Err(EventParseError::InvalidU64(u64_value.clone()))
-    }
-}
-
-fn parse_i64(i64_value: &Value) -> Result<i64> {
-    if let Value::Integer(content) = i64_value.clone() {
-        Ok(content.as_i64().ok_or(EventParseError::InvalidI64(i64_value.clone()))?)
-    } else {
-        Err(EventParseError::InvalidI64(i64_value.clone()))
-    }
-}
-
-fn parse_bool(bool_value: &Value) -> Result<bool> {
-    if let Value::Boolean(content) = bool_value.clone() {
-        Ok(content)
-    } else {
-        Err(EventParseError::InvalidBool(bool_value.clone()))
-    }
-}
-
-fn parse_set_title(set_title_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [title] = set_title_arguments.as_slice() {
-        Ok(RedrawEvent::SetTitle {
-            title: parse_string(title)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_mode_info_set(mode_info_set_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [_cursor_style_enabled, mode_info] = mode_info_set_arguments.as_slice() {
-        let mode_info_values = parse_array(mode_info)?;
-        let mut cursor_modes = Vec::new();
-        for mode_info_value in mode_info_values {
-            let info_map = parse_map(&mode_info_value)?;
-            let mut mode_info = CursorMode::new();
-            for (name, value) in info_map {
-                let name = parse_string(&name)?;
-                match name.as_ref() {
-                    "cursor_shape" => {
-                        mode_info.shape = CursorShape::from_type_name(&parse_string(&value)?);
-                    },
-                    "cell_percentage" => {
-                        mode_info.cell_percentage = Some(parse_u64(&value)? as f32 / 100.0);
-                    },
-                    "blinkwait" => {
-                        mode_info.blinkwait = Some(parse_u64(&value)?);
-                    },
-                    "blinkon" => {
-                        mode_info.blinkon = Some(parse_u64(&value)?);
-                    },
-                    "blinkoff" => {
-                        mode_info.blinkoff = Some(parse_u64(&value)?);
-                    }
-                    "attr_id" => {
-                        mode_info.style_id = Some(parse_u64(&value)?);
-                    },
-                    _ => {}
-                }
-            }
-            cursor_modes.push(mode_info);
-        }
-        Ok(RedrawEvent::ModeInfoSet {
-            cursor_modes
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_option_set(option_set_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [name, value] = option_set_arguments.as_slice() {
-        Ok(RedrawEvent::OptionSet {
-            gui_option: match parse_string(&name)?.as_ref() {
-                "arabicshape" => GuiOption::AribicShape(parse_bool(&value)?),
-                "ambiwidth" => GuiOption::AmbiWidth(parse_string(&value)?),
-                "emoji" => GuiOption::Emoji(parse_bool(&value)?),
-                "guifont" => GuiOption::GuiFont(parse_string(&value)?),
-                "guifontset" => GuiOption::GuiFontSet(parse_string(&value)?),
-                "guifontwide" => GuiOption::GuiFontWide(parse_string(&value)?),
-                "linespace" => GuiOption::LineSpace(parse_u64(&value)?),
-                "pumblend" => GuiOption::Pumblend(parse_u64(&value)?),
-                "showtabline" => GuiOption::ShowTabLine(parse_u64(&value)?),
-                "termguicolors" => GuiOption::TermGuiColors(parse_bool(&value)?),
-                unknown_option => GuiOption::Unknown(unknown_option.to_string(), value.clone())
-            }
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_mode_change(mode_change_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [_mode, mode_index] = mode_change_arguments.as_slice() {
-        Ok(RedrawEvent::ModeChange {
-            mode_index: parse_u64(&mode_index)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_grid_resize(grid_resize_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id, width, height] = grid_resize_arguments.as_slice() {
-        Ok(RedrawEvent::Resize { 
-            grid: parse_u64(&grid_id)?, width: parse_u64(&width)?, height: parse_u64(&height)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_default_colors(default_colors_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [
-        foreground, background, special, _term_foreground, _term_background
-    ] = default_colors_arguments.as_slice() {
-        Ok(RedrawEvent::DefaultColorsSet {
-            colors: Colors {
-                foreground: Some(unpack_color(parse_u64(&foreground)?)),
-                background: Some(unpack_color(parse_u64(&background)?)),
-                special: Some(unpack_color(parse_u64(special)?)),
-            }
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_style(style_map: &Value) -> Result<Style> {
-    if let Value::Map(attributes) = style_map {
-        let mut style = Style::new(Colors::new(None, None, None));
-        for attribute in attributes {
-            if let (Value::String(name), value) = attribute {
-                match (name.as_str().unwrap(), value) {
-                    ("foreground", Value::Integer(packed_color)) => style.colors.foreground = Some(unpack_color(packed_color.as_u64().unwrap())),
-                    ("background", Value::Integer(packed_color)) => style.colors.background = Some(unpack_color(packed_color.as_u64().unwrap())),
-                    ("special", Value::Integer(packed_color)) => style.colors.special = Some(unpack_color(packed_color.as_u64().unwrap())),
-                    ("reverse", Value::Boolean(reverse)) => style.reverse = *reverse,
-                    ("italic", Value::Boolean(italic)) => style.italic = *italic,
-                    ("bold", Value::Boolean(bold)) => style.bold = *bold,
-                    ("strikethrough", Value::Boolean(strikethrough)) => style.strikethrough = *strikethrough,
-                    ("underline", Value::Boolean(underline)) => style.underline = *underline,
-                    ("undercurl", Value::Boolean(undercurl)) => style.undercurl = *undercurl,
-                    ("blend", Value::Integer(blend)) => style.blend = blend.as_u64().unwrap() as u8,
-                    _ => println!("Ignored style attribute: {}", name)
-                }
-            } else {
-                println!("Invalid attribute format");
-            }
-        }
-        Ok(style)
-    } else {
-        Err(EventParseError::InvalidMap(style_map.clone()))
-    }
-}
-
-fn parse_hl_attr_define(hl_attr_define_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [
-        id, attributes, _terminal_attributes, _info
-    ] = hl_attr_define_arguments.as_slice() {
-        let style = parse_style(attributes)?;
-        Ok(RedrawEvent::HighlightAttributesDefine { id: parse_u64(&id)?, style })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_grid_line_cell(grid_line_cell: Value) -> Result<GridLineCell> {
-    let cell_contents = parse_array(&grid_line_cell)?;
-    let text_value = cell_contents.get(0).ok_or(EventParseError::InvalidEventFormat)?;
-    Ok(GridLineCell {
-        text: parse_string(&text_value)?,
-        highlight_id: cell_contents.get(1).map(|highlight_id| parse_u64(highlight_id)).transpose()?,
-        repeat: cell_contents.get(2).map(|repeat| parse_u64(repeat)).transpose()?
-    })
-}
-
-fn parse_grid_line(grid_line_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id, row, column_start, cells] = grid_line_arguments.as_slice() {
-        Ok(RedrawEvent::GridLine {
-            grid: parse_u64(&grid_id)?, 
-            row: parse_u64(&row)?, column_start: parse_u64(&column_start)?,
-            cells: parse_array(&cells)?
-                .into_iter()
-                .map(parse_grid_line_cell)
-                .collect::<Result<Vec<GridLineCell>>>()?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_clear(clear_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id] = clear_arguments.as_slice() {
-        Ok(RedrawEvent::Clear { grid: parse_u64(&grid_id)? })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_cursor_goto(cursor_goto_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id, column, row] = cursor_goto_arguments.as_slice() {
-        Ok(RedrawEvent::CursorGoto { 
-            grid: parse_u64(&grid_id)?, row: parse_u64(&row)?, column: parse_u64(&column)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_grid_scroll(grid_scroll_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id, top, bottom, left, right, rows, columns] = grid_scroll_arguments.as_slice() {
-        Ok(RedrawEvent::Scroll {
-            grid: parse_u64(&grid_id)?, 
-            top: parse_u64(&top)?, bottom: parse_u64(&bottom)?,
-            left: parse_u64(&left)?, right: parse_u64(&right)?,
-            rows: parse_i64(&rows)?, columns: parse_i64(&columns)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_styled_content(line: &Value) -> Result<StyledContent> {
-    parse_array(line)?.iter().map(|tuple| {
-        if let [style_id, text] = parse_array(tuple)?.as_slice() {
-            Ok((parse_u64(style_id)?, parse_string(text)?))
-        } else {
-            Err(EventParseError::InvalidEventFormat)
-        }
-    }).collect::<Result<StyledContent>>()
-}
-
-fn parse_cmdline_show(cmdline_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [content, position, first_character, prompt, indent, level] = cmdline_show_arguments.as_slice() {
-        Ok(RedrawEvent::CommandLineShow {
-            content: parse_styled_content(&content)?,
-            position: parse_u64(&position)?,
-            first_character: parse_string(&first_character)?,
-            prompt: parse_string(&prompt)?,
-            indent: parse_u64(&indent)?,
-            level: parse_u64(&level)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_cmdline_pos(cmdline_pos_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [position, level] = cmdline_pos_arguments.as_slice() {
-        Ok(RedrawEvent::CommandLinePosition {
-            position: parse_u64(&position)?,
-            level: parse_u64(&level)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_cmdline_special_char(cmdline_special_char_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [character, shift, level] = cmdline_special_char_arguments.as_slice() {
-        Ok(RedrawEvent::CommandLineSpecialCharacter {
-            character: parse_string(&character)?,
-            shift: parse_bool(&shift)?,
-            level: parse_u64(&level)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_cmdline_block_show(cmdline_block_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [lines] = cmdline_block_show_arguments.as_slice() {
-        Ok(RedrawEvent::CommandLineBlockShow {
-            lines: parse_array(lines)?
-                .iter()
-                .map(parse_styled_content)
-                .collect::<Result<Vec<StyledContent>>>()?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_cmdline_block_append(cmdline_block_append_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [line] = cmdline_block_append_arguments.as_slice() {
-        Ok(RedrawEvent::CommandLineBlockAppend {
-            line: parse_styled_content(line)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_msg_show(msg_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [kind, content, replace_last] = msg_show_arguments.as_slice() {
-        Ok(RedrawEvent::MessageShow {
-            kind: MessageKind::parse(&parse_string(&kind)?),
-            content: parse_styled_content(&content)?,
-            replace_last: parse_bool(&replace_last)?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_msg_showmode(msg_showmode_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [content] = msg_showmode_arguments.as_slice() {
-        Ok(RedrawEvent::MessageShowMode {
-            content: parse_styled_content(&content)?,
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_msg_showcmd(msg_showcmd_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [content] = msg_showcmd_arguments.as_slice() {
-        Ok(RedrawEvent::MessageShowCommand {
-            content: parse_styled_content(&content)?,
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_msg_ruler(msg_ruler_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [content] = msg_ruler_arguments.as_slice() {
-        Ok(RedrawEvent::MessageRuler {
-            content: parse_styled_content(&content)?,
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_msg_history_entry(entry: &Value) -> Result<(MessageKind, StyledContent)> {
-    if let [kind, content] = parse_array(entry)?.as_slice() {
-        Ok((
-            MessageKind::parse(&parse_string(kind)?),
-            parse_styled_content(content)?
-        ))
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-fn parse_msg_history_show(msg_history_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [entries] = msg_history_show_arguments.as_slice() {
-        Ok(RedrawEvent::MessageHistoryShow {
-            entries: parse_array(entries)?
-                .iter()
-                .map(parse_msg_history_entry)
-                .collect::<Result<Vec<(MessageKind, StyledContent)>>>()?
-        })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
-}
-
-pub fn parse_redraw_event(event_value: Value) -> Result<Vec<RedrawEvent>> {
-    let event_contents = parse_array(&event_value)?.to_vec();
-    let name_value = event_contents.get(0).ok_or(EventParseError::InvalidEventFormat)?;
-    let event_name = parse_string(&name_value)?;
-    let events = event_contents;
-    let mut parsed_events = Vec::new();
-
-    for event in &events[1..] {
-        let event_parameters = parse_array(&event)?;
-        let possible_parsed_event = match event_name.clone().as_ref() {
-            "set_title" => Some(parse_set_title(event_parameters)?),
-            "set_icon" => None, // Ignore set icon for now
-            "mode_info_set" => Some(parse_mode_info_set(event_parameters)?),
-            "option_set" => Some(parse_option_set(event_parameters)?),
-            "mode_change" => Some(parse_mode_change(event_parameters)?),
-            "busy_start" => Some(RedrawEvent::BusyStart),
-            "busy_stop" => Some(RedrawEvent::BusyStop),
-            "flush" => Some(RedrawEvent::Flush),
-            "grid_resize" => Some(parse_grid_resize(event_parameters)?),
-            "default_colors_set" => Some(parse_default_colors(event_parameters)?),
-            "hl_attr_define" => Some(parse_hl_attr_define(event_parameters)?),
-            "grid_line" => Some(parse_grid_line(event_parameters)?),
-            "grid_clear" => Some(parse_clear(event_parameters)?),
-            "grid_cursor_goto" => Some(parse_cursor_goto(event_parameters)?),
-            "grid_scroll" => Some(parse_grid_scroll(event_parameters)?),
-            "cmdline_show" => Some(parse_cmdline_show(event_parameters)?),
-            "cmdline_pos" => Some(parse_cmdline_pos(event_parameters)?),
-            "cmdline_special_char" => Some(parse_cmdline_special_char(event_parameters)?),
-            "cmdline_hide" => Some(RedrawEvent::CommandLineHide),
-            "cmdline_block_show" => Some(parse_cmdline_block_show(event_parameters)?),
-            "cmdline_block_append" => Some(parse_cmdline_block_append(event_parameters)?),
-            "cmdline_block_hide" => Some(RedrawEvent::CommandLineBlockHide),
-            "msg_show" => Some(parse_msg_show(event_parameters)?),
-            "msg_clear" => Some(RedrawEvent::MessageClear),
-            "msg_showmode" => Some(parse_msg_showmode(event_parameters)?),
-            "msg_showcmd" => Some(parse_msg_showcmd(event_parameters)?),
-            "msg_ruler" => Some(parse_msg_ruler(event_parameters)?),
-            "msg_history_show" => Some(parse_msg_history_show(event_parameters)?),
-            _ => None
-        };
-
-        if let Some(parsed_event) = possible_parsed_event {
-            parsed_events.push(parsed_event);
-        }
-    }
-
-    Ok(parsed_events)
-}
-
-pub fn parse_neovim_event(event_name: String, arguments: Vec<Value>) -> Result<Vec<RedrawEvent>> {
-    let mut resulting_events = Vec::new();
-    if event_name == "redraw" {
-        for event in arguments {
-            resulting_events.append(&mut parse_redraw_event(event)?);
-        }
-    } else {
-        println!("Unknown global event {}", event_name);
-    }
-    Ok(resulting_events)
-}
-
-
-
-
-
-
+use std::error;
+use std::fmt;
+
+use rmpv::Value;
+use skulpin::skia_safe::Color4f;
+
+use crate::editor::{Colors, Style, CursorMode, CursorShape};
+
+#[derive(Debug, Clone)]
+pub enum EventParseError {
+    InvalidArray(Value),
+    InvalidMap(Value),
+    InvalidString(Value),
+    InvalidU64(Value),
+    InvalidI64(Value),
+    InvalidBool(Value),
+    InvalidEventFormat
+}
+type Result<T> = std::result::Result<T, EventParseError>;
+
+impl fmt::Display for EventParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            EventParseError::InvalidArray(value) => write!(f, "invalid array format {}", value),
+            EventParseError::InvalidMap(value) => write!(f, "invalid map format {}", value),
+            EventParseError::InvalidString(value) => write!(f, "invalid string format {}", value),
+            EventParseError::InvalidU64(value) => write!(f, "invalid u64 format {}", value),
+            EventParseError::InvalidI64(value) => write!(f, "invalid i64 format {}", value),
+            EventParseError::InvalidBool(value) => write!(f, "invalid bool format {}", value),
+            EventParseError::InvalidEventFormat => write!(f, "invalid event format")
+        }
+    }
+}
+
+impl error::Error for EventParseError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        None
+    }
+}
+
+#[derive(Debug)]
+pub struct GridLineCell {
+    pub text: String,
+    pub highlight_id: Option<u64>,
+    pub repeat: Option<u64>
+}
+
+pub type StyledContent = Vec<(u64, String)>;
+
+#[derive(Debug)]
+pub enum MessageKind {
+    Unknown,
+    Confirm,
+    ConfirmSubstitute,
+    Error,
+    Echo,
+    EchoMessage,
+    EchoError,
+    LuaError,
+    RpcError,
+    ReturnPrompt,
+    QuickFix,
+    SearchCount,
+    Warning
+}
+
+impl MessageKind {
+    pub fn parse(kind: &str) -> MessageKind {
+        match kind {
+            "confirm" => MessageKind::Confirm,
+            "confirm_sub" => MessageKind::ConfirmSubstitute,
+            "emsg" => MessageKind::Error,
+            "echo" => MessageKind::Echo,
+            "echomsg" => MessageKind::EchoMessage,
+            "echoerr" => MessageKind::EchoError,
+            "lua_error" => MessageKind::LuaError,
+            "rpc_error" => MessageKind::RpcError,
+            "return_prompt" => MessageKind::ReturnPrompt,
+            "quickfix" => MessageKind::QuickFix,
+            "search_count" => MessageKind::SearchCount,
+            "wmsg" => MessageKind::Warning,
+            _ => MessageKind::Unknown
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum GuiOption {
+    AribicShape(bool),
+    AmbiWidth(String),
+    Emoji(bool),
+    GuiFont(String),
+    GuiFontSet(String),
+    GuiFontWide(String),
+    LineSpace(u64),
+    Pumblend(u64),
+    ShowTabLine(u64),
+    TermGuiColors(bool),
+    Unknown(String, Value)
+}
+
+#[derive(Debug)]
+pub enum RedrawEvent {
+    SetTitle { title: String },
+    ModeInfoSet { cursor_modes: Vec<CursorMode> },
+    OptionSet { gui_option: GuiOption },
+    ModeChange { mode_index: u64 },
+    BusyStart,
+    BusyStop,
+    Flush,
+    Resize { grid: u64, width: u64, height: u64 },
+    DefaultColorsSet { colors: Colors },
+    HighlightAttributesDefine { id: u64, style: Style },
+    GridLine { grid: u64, row: u64, column_start: u64, cells: Vec<GridLineCell> },
+    Clear { grid: u64 },
+    CursorGoto { grid: u64, row: u64, column: u64 },
+    Scroll { grid: u64, top: u64, bottom: u64, left: u64, right: u64, rows: i64, columns: i64 },
+    CommandLineShow { content: StyledContent, position: u64, first_character: String, prompt: String, indent: u64, level: u64 },
+    CommandLinePosition { position: u64, level: u64 },
+    CommandLineSpecialCharacter { character: String, shift: bool, level: u64 },
+    CommandLineHide,
+    CommandLineBlockShow { lines: Vec<StyledContent> },
+    CommandLineBlockAppend { line: StyledContent },
+    CommandLineBlockHide,
+    MessageShow { kind: MessageKind, content: StyledContent, replace_last: bool },
+    MessageClear,
+    MessageShowMode { content: StyledContent },
+    MessageShowCommand { content: StyledContent },
+    MessageRuler { content: StyledContent },
+    MessageHistoryShow { entries: Vec<(MessageKind, StyledContent)>}
+}
+
+fn unpack_color(packed_color: u64) -> Color4f {
+    let packed_color = packed_color as u32;
+    let r = ((packed_color & 0xff0000) >> 16) as f32;
+    let g = ((packed_color & 0xff00) >> 8) as f32;
+    let b = (packed_color & 0xff) as f32;
+    Color4f {
+        r: r / 255.0,
+        g: g / 255.0,
+        b: b / 255.0,
+        a: 1.0
+    }
+}
+
+fn parse_array(array_value: &Value) -> Result<Vec<Value>> {
+    if let Value::Array(content) = array_value.clone() {
+        Ok(content.to_vec())
+    } else {
+        Err(EventParseError::InvalidArray(array_value.clone()))
+    }
+}
+
+fn parse_map(map_value: &Value) -> Result<Vec<(Value, Value)>> {
+    if let Value::Map(content) = map_value.clone() {
+        Ok(content)
+    } else {
+        Err(EventParseError::InvalidMap(map_value.clone()))
+    }
+}
+
+fn parse_string(string_value: &Value) -> Result<String> {
+    if let Value::String(content) = string_value.clone() {
+        Ok(content.into_str().ok_or(EventParseError::InvalidString(string_value.clone()))?)
+    } else {
+        Err(EventParseError::InvalidString(string_value.clone()))
+    }
+}
+
+fn parse_u64(u64_value: &Value) -> Result<u64> {
+    if let Value::Integer(content) = u64_value.clone() {
+        Ok(content.as_u64().ok_or(EventParseError::InvalidU64(u64_value.clone()))?)
+    } else {
+        Err(EventParseError::InvalidU64(u64_value.clone()))
+    }
+}
+
+fn parse_i64(i64_value: &Value) -> Result<i64> {
+    if let Value::Integer(content) = i64_value.clone() {
+        Ok(content.as_i64().ok_or(EventParseError::InvalidI64(i64_value.clone()))?)
+    } else {
+        Err(EventParseError::InvalidI64(i64_value.clone()))
+    }
+}
+
+fn parse_bool(bool_value: &Value) -> Result<bool> {
+    if let Value::Boolean(content) = bool_value.clone() {
+        Ok(content)
+    } else {
+        Err(EventParseError::InvalidBool(bool_value.clone()))
+    }
+}
+
+fn parse_set_title(set_title_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [title] = set_title_arguments.as_slice() {
+        Ok(RedrawEvent::SetTitle {
+            title: parse_string(title)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_mode_info_set(mode_info_set_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [_cursor_style_enabled, mode_info] = mode_info_set_arguments.as_slice() {
+        let mode_info_values = parse_array(mode_info)?;
+        let mut cursor_modes = Vec::new();
+        for mode_info_value in mode_info_values {
+            let info_map = parse_map(&mode_info_value)?;
+            let mut mode_info = CursorMode::new();
+            for (name, value) in info_map {
+                let name = parse_string(&name)?;
+                match name.as_ref() {
+                    "cursor_shape" => {
+                        mode_info.shape = CursorShape::from_type_name(&parse_string(&value)?);
+                    },
+                    "cell_percentage" => {
+                        mode_info.cell_percentage = Some(parse_u64(&value)? as f32 / 100.0);
+                    },
+                    "blinkwait" => {
+                        mode_info.blinkwait = Some(parse_u64(&value)?);
+                    },
+                    "blinkon" => {
+                        mode_info.blinkon = Some(parse_u64(&value)?);
+                    },
+                    "blinkoff" => {
+                        mode_info.blinkoff = Some(parse_u64(&value)?);
+                    }
+                    "attr_id" => {
+                        mode_info.style_id = Some(parse_u64(&value)?);
+                    },
+                    _ => {}
+                }
+            }
+            cursor_modes.push(mode_info);
+        }
+        Ok(RedrawEvent::ModeInfoSet {
+            cursor_modes
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_option_set(option_set_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [name, value] = option_set_arguments.as_slice() {
+        Ok(RedrawEvent::OptionSet {
+            gui_option: match parse_string(&name)?.as_ref() {
+                "arabicshape" => GuiOption::AribicShape(parse_bool(&value)?),
+                "ambiwidth" => GuiOption::AmbiWidth(parse_string(&value)?),
+                "emoji" => GuiOption::Emoji(parse_bool(&value)?),
+                "guifont" => GuiOption::GuiFont(parse_string(&value)?),
+                "guifontset" => GuiOption::GuiFontSet(parse_string(&value)?),
+                "guifontwide" => GuiOption::GuiFontWide(parse_string(&value)?),
+                "linespace" => GuiOption::LineSpace(parse_u64(&value)?),
+                "pumblend" => GuiOption::Pumblend(parse_u64(&value)?),
+                "showtabline" => GuiOption::ShowTabLine(parse_u64(&value)?),
+                "termguicolors" => GuiOption::TermGuiColors(parse_bool(&value)?),
+                unknown_option => GuiOption::Unknown(unknown_option.to_string(), value.clone())
+            }
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_mode_change(mode_change_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [_mode, mode_index] = mode_change_arguments.as_slice() {
+        Ok(RedrawEvent::ModeChange {
+            mode_index: parse_u64(&mode_index)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_grid_resize(grid_resize_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [grid_id, width, height] = grid_resize_arguments.as_slice() {
+        Ok(RedrawEvent::Resize { 
+            grid: parse_u64(&grid_id)?, width: parse_u64(&width)?, height: parse_u64(&height)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_default_colors(default_colors_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [
+        foreground, background, special, _term_foreground, _term_background
+    ] = default_colors_arguments.as_slice() {
+        Ok(RedrawEvent::DefaultColorsSet {
+            colors: Colors {
+                foreground: Some(unpack_color(parse_u64(&foreground)?)),
+                background: Some(unpack_color(parse_u64(&background)?)),
+                special: Some(unpack_color(parse_u64(special)?)),
+            }
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_style(style_map: &Value) -> Result<Style> {
+    if let Value::Map(attributes) = style_map {
+        let mut style = Style::new(Colors::new(None, None, None));
+        for attribute in attributes {
+            if let (Value::String(name), value) = attribute {
+                match (name.as_str().unwrap(), value) {
+                    ("foreground", Value::Integer(packed_color)) => style.colors.foreground = Some(unpack_color(packed_color.as_u64().unwrap())),
+                    ("background", Value::Integer(packed_color)) => style.colors.background = Some(unpack_color(packed_color.as_u64().unwrap())),
+                    ("special", Value::Integer(packed_color)) => style.colors.special = Some(unpack_color(packed_color.as_u64().unwrap())),
+                    ("reverse", Value::Boolean(reverse)) => style.reverse = *reverse,
+                    ("italic", Value::Boolean(italic)) => style.italic = *italic,
+                    ("bold", Value::Boolean(bold)) => style.bold = *bold,
+                    ("strikethrough", Value::Boolean(strikethrough)) => style.strikethrough = *strikethrough,
+                    ("underline", Value::Boolean(underline)) => style.underline = *underline,
+                    ("undercurl", Value::Boolean(undercurl)) => style.undercurl = *undercurl,
+                    ("blend", Value::Integer(blend)) => style.blend = blend.as_u64().unwrap() as u8,
+                    _ => println!("Ignored style attribute: {}", name)
+                }
+            } else {
+                println!("Invalid attribute format");
+            }
+        }
+        Ok(style)
+    } else {
+        Err(EventParseError::InvalidMap(style_map.clone()))
+    }
+}
+
+fn parse_hl_attr_define(hl_attr_define_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [
+        id, attributes, _terminal_attributes, _info
+    ] = hl_attr_define_arguments.as_slice() {
+        let style = parse_style(attributes)?;
+        Ok(RedrawEvent::HighlightAttributesDefine { id: parse_u64(&id)?, style })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_grid_line_cell(grid_line_cell: Value) -> Result<GridLineCell> {
+    let cell_contents = parse_array(&grid_line_cell)?;
+    let text_value = cell_contents.get(0).ok_or(EventParseError::InvalidEventFormat)?;
+    Ok(GridLineCell {
+        text: parse_string(&text_value)?,
+        highlight_id: cell_contents.get(1).map(|highlight_id| parse_u64(highlight_id)).transpose()?,
+        repeat: cell_contents.get(2).map(|repeat| parse_u64(repeat)).transpose()?
+    })
+}
+
+fn parse_grid_line(grid_line_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [grid_id, row, column_start, cells] = grid_line_arguments.as_slice() {
+        Ok(RedrawEvent::GridLine {
+            grid: parse_u64(&grid_id)?, 
+            row: parse_u64(&row)?, column_start: parse_u64(&column_start)?,
+            cells: parse_array(&cells)?
+                .into_iter()
+                .map(parse_grid_line_cell)
+                .collect::<Result<Vec<GridLineCell>>>()?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_clear(clear_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [grid_id] = clear_arguments.as_slice() {
+        Ok(RedrawEvent::Clear { grid: parse_u64(&grid_id)? })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_cursor_goto(cursor_goto_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [grid_id, column, row] = cursor_goto_arguments.as_slice() {
+        Ok(RedrawEvent::CursorGoto { 
+            grid: parse_u64(&grid_id)?, row: parse_u64(&row)?, column: parse_u64(&column)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_grid_scroll(grid_scroll_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [grid_id, top, bottom, left, right, rows, columns] = grid_scroll_arguments.as_slice() {
+        Ok(RedrawEvent::Scroll {
+            grid: parse_u64(&grid_id)?, 
+            top: parse_u64(&top)?, bottom: parse_u64(&bottom)?,
+            left: parse_u64(&left)?, right: parse_u64(&right)?,
+            rows: parse_i64(&rows)?, columns: parse_i64(&columns)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_styled_content(line: &Value) -> Result<StyledContent> {
+    parse_array(line)?.iter().map(|tuple| {
+        if let [style_id, text] = parse_array(tuple)?.as_slice() {
+            Ok((parse_u64(style_id)?, parse_string(text)?))
+        } else {
+            Err(EventParseError::InvalidEventFormat)
+        }
+    }).collect::<Result<StyledContent>>()
+}
+
+fn parse_cmdline_show(cmdline_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [content, position, first_character, prompt, indent, level] = cmdline_show_arguments.as_slice() {
+        Ok(RedrawEvent::CommandLineShow {
+            content: parse_styled_content(&content)?,
+            position: parse_u64(&position)?,
+            first_character: parse_string(&first_character)?,
+            prompt: parse_string(&prompt)?,
+            indent: parse_u64(&indent)?,
+            level: parse_u64(&level)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_cmdline_pos(cmdline_pos_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [position, level] = cmdline_pos_arguments.as_slice() {
+        Ok(RedrawEvent::CommandLinePosition {
+            position: parse_u64(&position)?,
+            level: parse_u64(&level)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_cmdline_special_char(cmdline_special_char_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [character, shift, level] = cmdline_special_char_arguments.as_slice() {
+        Ok(RedrawEvent::CommandLineSpecialCharacter {
+            character: parse_string(&character)?,
+            shift: parse_bool(&shift)?,
+            level: parse_u64(&level)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_cmdline_block_show(cmdline_block_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [lines] = cmdline_block_show_arguments.as_slice() {
+        Ok(RedrawEvent::CommandLineBlockShow {
+            lines: parse_array(lines)?
+                .iter()
+                .map(parse_styled_content)
+                .collect::<Result<Vec<StyledContent>>>()?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_cmdline_block_append(cmdline_block_append_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [line] = cmdline_block_append_arguments.as_slice() {
+        Ok(RedrawEvent::CommandLineBlockAppend {
+            line: parse_styled_content(line)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_msg_show(msg_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [kind, content, replace_last] = msg_show_arguments.as_slice() {
+        Ok(RedrawEvent::MessageShow {
+            kind: MessageKind::parse(&parse_string(&kind)?),
+            content: parse_styled_content(&content)?,
+            replace_last: parse_bool(&replace_last)?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_msg_showmode(msg_showmode_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [content] = msg_showmode_arguments.as_slice() {
+        Ok(RedrawEvent::MessageShowMode {
+            content: parse_styled_content(&content)?,
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_msg_showcmd(msg_showcmd_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [content] = msg_showcmd_arguments.as_slice() {
+        Ok(RedrawEvent::MessageShowCommand {
+            content: parse_styled_content(&content)?,
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_msg_ruler(msg_ruler_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [content] = msg_ruler_arguments.as_slice() {
+        Ok(RedrawEvent::MessageRuler {
+            content: parse_styled_content(&content)?,
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_msg_history_entry(entry: &Value) -> Result<(MessageKind, StyledContent)> {
+    if let [kind, content] = parse_array(entry)?.as_slice() {
+        Ok((
+            MessageKind::parse(&parse_string(kind)?),
+            parse_styled_content(content)?
+        ))
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+fn parse_msg_history_show(msg_history_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    if let [entries] = msg_history_show_arguments.as_slice() {
+        Ok(RedrawEvent::MessageHistoryShow {
+            entries: parse_array(entries)?
+                .iter()
+                .map(parse_msg_history_entry)
+                .collect::<Result<Vec<(MessageKind, StyledContent)>>>()?
+        })
+    } else {
+        Err(EventParseError::InvalidEventFormat)
+    }
+}
+
+pub fn parse_redraw_event(event_value: Value) -> Result<Vec<RedrawEvent>> {
+    let event_contents = parse_array(&event_value)?.to_vec();
+    let name_value = event_contents.get(0).ok_or(EventParseError::InvalidEventFormat)?;
+    let event_name = parse_string(&name_value)?;
+    let events = event_contents;
+    let mut parsed_events = Vec::new();
+
+    for event in &events[1..] {
+        let event_parameters = parse_array(&event)?;
+        let possible_parsed_event = match event_name.clone().as_ref() {
+            "set_title" => Some(parse_set_title(event_parameters)?),
+            "set_icon" => None, // Ignore set icon for now
+            "mode_info_set" => Some(parse_mode_info_set(event_parameters)?),
+            "option_set" => Some(parse_option_set(event_parameters)?),
+            "mode_change" => Some(parse_mode_change(event_parameters)?),
+            "busy_start" => Some(RedrawEvent::BusyStart),
+            "busy_stop" => Some(RedrawEvent::BusyStop),
+            "flush" => Some(RedrawEvent::Flush),
+            "grid_resize" => Some(parse_grid_resize(event_parameters)?),
+            "default_colors_set" => Some(parse_default_colors(event_parameters)?),
+            "hl_attr_define" => Some(parse_hl_attr_define(event_parameters)?),
+            "grid_line" => Some(parse_grid_line(event_parameters)?),
+            "grid_clear" => Some(parse_clear(event_parameters)?),
+            "grid_cursor_goto" => Some(parse_cursor_goto(event_parameters)?),
+            "grid_scroll" => Some(parse_grid_scroll(event_parameters)?),
+            "cmdline_show" => Some(parse_cmdline_show(event_parameters)?),
+            "cmdline_pos" => Some(parse_cmdline_pos(event_parameters)?),
+            "cmdline_special_char" => Some(parse_cmdline_special_char(event_parameters)?),
+            "cmdline_hide" => Some(RedrawEvent::CommandLineHide),
+            "cmdline_block_show" => Some(parse_cmdline_block_show(event_parameters)?),
+            "cmdline_block_append" => Some(parse_cmdline_block_append(event_parameters)?),
+            "cmdline_block_hide" => Some(RedrawEvent::CommandLineBlockHide),
+            "msg_show" => Some(parse_msg_show(event_parameters)?),
+            "msg_clear" => Some(RedrawEvent::MessageClear),
+            "msg_showmode" => Some(parse_msg_showmode(event_parameters)?),
+            "msg_showcmd" => Some(parse_msg_showcmd(event_parameters)?),
+            "msg_ruler" => Some(parse_msg_ruler(event_parameters)?),
+            "msg_history_show" => Some(parse_msg_history_show(event_parameters)?),
+            _ => None
+        };
+
+        if let Some(parsed_event) = possible_parsed_event {
+            parsed_events.push(parsed_event);
+        }
+    }
+
+    Ok(parsed_events)
+}
+
+pub fn parse_neovim_event(event_name: String, arguments: Vec<Value>) -> Result<Vec<RedrawEvent>> {
+    let mut resulting_events = Vec::new();
+    if event_name == "redraw" {
+        for event in arguments {
+            resulting_events.append(&mut parse_redraw_event(event)?);
+        }
+    } else {
+        println!("Unknown global event {}", event_name);
+    }
+    Ok(resulting_events)
+}
+
+
+
+
+
+
diff --git a/src/bridge/handler.rs b/src/bridge/handler.rs
new file mode 100644
index 0000000..eb51270
--- /dev/null
+++ b/src/bridge/handler.rs
@@ -0,0 +1,27 @@
+use std::sync::{Arc, Mutex};
+
+use rmpv::Value;
+use nvim_rs::{Neovim, Handler, compat::tokio::Compat};
+use async_trait::async_trait;
+use tokio::process::ChildStdin;
+
+use crate::error_handling::ResultPanicExplanation;
+use crate::editor::Editor;
+use super::events::parse_neovim_event;
+
+#[derive(Clone)]
+pub struct NeovimHandler(pub Arc<Mutex<Editor>>);
+
+#[async_trait]
+impl Handler for NeovimHandler {
+    type Writer = Compat<ChildStdin>;
+
+    async fn handle_notify(&self, event_name: String, arguments: Vec<Value>, _neovim: Neovim<Compat<ChildStdin>>) {
+        let parsed_events = parse_neovim_event(event_name, arguments)
+            .unwrap_or_explained_panic("Could not parse event", "Could not parse event from neovim");
+        for event in parsed_events {
+            let mut editor = self.0.lock().unwrap();
+            editor.handle_redraw_event(event);
+        }
+    }
+}
diff --git a/src/keybindings.rs b/src/bridge/keybindings.rs
similarity index 97%
rename from src/keybindings.rs
rename to src/bridge/keybindings.rs
index 22abddf..999e1fe 100644
--- a/src/keybindings.rs
+++ b/src/bridge/keybindings.rs
@@ -1,172 +1,172 @@
-use skulpin::winit::event::{KeyboardInput, ElementState, ModifiersState, VirtualKeyCode};
-
-fn parse_keycode(keycode: VirtualKeyCode) -> Option<(String, bool)> {
-    match keycode {
-        VirtualKeyCode::Key1 => Some(("1".to_string(), false)),
-        VirtualKeyCode::Key2 => Some(("2".to_string(), false)),
-        VirtualKeyCode::Key3 => Some(("3".to_string(), false)),
-        VirtualKeyCode::Key4 => Some(("4".to_string(), false)),
-        VirtualKeyCode::Key5 => Some(("5".to_string(), false)),
-        VirtualKeyCode::Key6 => Some(("6".to_string(), false)),
-        VirtualKeyCode::Key7 => Some(("7".to_string(), false)),
-        VirtualKeyCode::Key8 => Some(("8".to_string(), false)),
-        VirtualKeyCode::Key9 => Some(("9".to_string(), false)),
-        VirtualKeyCode::Key0 => Some(("0".to_string(), false)),
-        VirtualKeyCode::A => Some(("a".to_string(), false)),
-        VirtualKeyCode::B => Some(("b".to_string(), false)),
-        VirtualKeyCode::C => Some(("c".to_string(), false)),
-        VirtualKeyCode::D => Some(("d".to_string(), false)),
-        VirtualKeyCode::E => Some(("e".to_string(), false)),
-        VirtualKeyCode::F => Some(("f".to_string(), false)),
-        VirtualKeyCode::G => Some(("g".to_string(), false)),
-        VirtualKeyCode::H => Some(("h".to_string(), false)),
-        VirtualKeyCode::I => Some(("i".to_string(), false)),
-        VirtualKeyCode::J => Some(("j".to_string(), false)),
-        VirtualKeyCode::K => Some(("k".to_string(), false)),
-        VirtualKeyCode::L => Some(("l".to_string(), false)),
-        VirtualKeyCode::M => Some(("m".to_string(), false)),
-        VirtualKeyCode::N => Some(("n".to_string(), false)),
-        VirtualKeyCode::O => Some(("o".to_string(), false)),
-        VirtualKeyCode::P => Some(("p".to_string(), false)),
-        VirtualKeyCode::Q => Some(("q".to_string(), false)),
-        VirtualKeyCode::R => Some(("r".to_string(), false)),
-        VirtualKeyCode::S => Some(("s".to_string(), false)),
-        VirtualKeyCode::T => Some(("t".to_string(), false)),
-        VirtualKeyCode::U => Some(("u".to_string(), false)),
-        VirtualKeyCode::V => Some(("v".to_string(), false)),
-        VirtualKeyCode::W => Some(("w".to_string(), false)),
-        VirtualKeyCode::X => Some(("x".to_string(), false)),
-        VirtualKeyCode::Y => Some(("y".to_string(), false)),
-        VirtualKeyCode::Z => Some(("z".to_string(), false)),
-        VirtualKeyCode::Escape => Some(("ESC".to_string(), true)),
-        VirtualKeyCode::F1 => Some(("F1".to_string(), true)),
-        VirtualKeyCode::F2 => Some(("F2".to_string(), true)),
-        VirtualKeyCode::F3 => Some(("F3".to_string(), true)),
-        VirtualKeyCode::F4 => Some(("F4".to_string(), true)),
-        VirtualKeyCode::F5 => Some(("F5".to_string(), true)),
-        VirtualKeyCode::F6 => Some(("F6".to_string(), true)),
-        VirtualKeyCode::F7 => Some(("F7".to_string(), true)),
-        VirtualKeyCode::F8 => Some(("F8".to_string(), true)),
-        VirtualKeyCode::F9 => Some(("F9".to_string(), true)),
-        VirtualKeyCode::F10 => Some(("F10".to_string(), true)),
-        VirtualKeyCode::F11 => Some(("F11".to_string(), true)),
-        VirtualKeyCode::F12 => Some(("F12".to_string(), true)),
-        VirtualKeyCode::F13 => Some(("F13".to_string(), true)),
-        VirtualKeyCode::F14 => Some(("F14".to_string(), true)),
-        VirtualKeyCode::F15 => Some(("F15".to_string(), true)),
-        VirtualKeyCode::F16 => Some(("F16".to_string(), true)),
-        VirtualKeyCode::F17 => Some(("F17".to_string(), true)),
-        VirtualKeyCode::F18 => Some(("F18".to_string(), true)),
-        VirtualKeyCode::F19 => Some(("F19".to_string(), true)),
-        VirtualKeyCode::F20 => Some(("F20".to_string(), true)),
-        VirtualKeyCode::F21 => Some(("F21".to_string(), true)),
-        VirtualKeyCode::F22 => Some(("F22".to_string(), true)),
-        VirtualKeyCode::F23 => Some(("F23".to_string(), true)),
-        VirtualKeyCode::F24 => Some(("F24".to_string(), true)),
-        VirtualKeyCode::Insert => Some(("Insert".to_string(), true)),
-        VirtualKeyCode::Home => Some(("Home".to_string(), true)),
-        VirtualKeyCode::Delete => Some(("Delete".to_string(), true)),
-        VirtualKeyCode::End => Some(("End".to_string(), true)),
-        VirtualKeyCode::PageDown => Some(("PageDown".to_string(), true)),
-        VirtualKeyCode::PageUp => Some(("PageUp".to_string(), true)),
-        VirtualKeyCode::Left => Some(("Left".to_string(), true)),
-        VirtualKeyCode::Up => Some(("Up".to_string(), true)),
-        VirtualKeyCode::Right => Some(("Right".to_string(), true)),
-        VirtualKeyCode::Down => Some(("Down".to_string(), true)),
-        VirtualKeyCode::Back => Some(("BS".to_string(), true)),
-        VirtualKeyCode::Return => Some(("Enter".to_string(), true)),
-        VirtualKeyCode::Space => Some(("Space".to_string(), true)),
-        VirtualKeyCode::Caret => Some(("^".to_string(), false)),
-        VirtualKeyCode::Apostrophe => Some(("'".to_string(), false)),
-        VirtualKeyCode::Backslash => Some(("Bslash".to_string(), true)),
-        VirtualKeyCode::Colon => Some((":".to_string(), false)),
-        VirtualKeyCode::Comma => Some((",".to_string(), false)),
-        VirtualKeyCode::Equals => Some(("=".to_string(), false)),
-        VirtualKeyCode::Grave => Some(("`".to_string(), false)),
-        VirtualKeyCode::LBracket => Some(("[".to_string(), false)),
-        VirtualKeyCode::Minus => Some(("-".to_string(), false)),
-        VirtualKeyCode::Period => Some((".".to_string(), false)),
-        VirtualKeyCode::RBracket => Some(("]".to_string(), false)),
-        VirtualKeyCode::Semicolon => Some((";".to_string(), false)),
-        VirtualKeyCode::Slash => Some(("/".to_string(), false)),
-        VirtualKeyCode::Tab => Some(("Tab".to_string(), true)),
-        _ => None
-    }
-}
-
-fn append_modifiers(modifiers: ModifiersState, keycode_text: String, special: bool) -> String {
-    let mut result = keycode_text;
-    let mut special = special;
-
-    if modifiers.shift() {
-        result = match result.as_ref() {
-            "1" => "!".to_string(),
-            "2" => "@".to_string(),
-            "3" => "#".to_string(),
-            "4" => "$".to_string(),
-            "5" => "%".to_string(),
-            "6" => "^".to_string(),
-            "7" => "&".to_string(),
-            "8" => "*".to_string(),
-            "9" => "(".to_string(),
-            "0" => ")".to_string(),
-            "'" => "\"".to_string(),
-            "Bslash" => {
-                special = false;
-                "|".to_string()
-            },
-            "," => {
-                special = true;
-                "lt".to_string()
-            },
-            "=" => "+".to_string(),
-            "`" => "~".to_string(),
-            "[" => "{".to_string(),
-            "-" => "_".to_string(),
-            "." => ">".to_string(),
-            "]" => "}".to_string(),
-            ";" => ":".to_string(),
-            "/" => "?".to_string(),
-            other => {
-                special = true;
-                format!("S-{}", other)
-            }
-        };
-    }
-    if modifiers.ctrl() {
-        special = true;
-        result = format!("C-{}", result);
-    }
-    if modifiers.alt() {
-        special = true;
-        result = format!("M-{}", result);
-    }
-    if modifiers.logo() {
-        special = true;
-        result = format!("D-{}", result);
-    }
-
-    if special {
-        result = format!("<{}>", result);
-    }
-
-    result
-}
-
-pub fn construct_keybinding_string(input: KeyboardInput) -> Option<String> {
-    match input {
-        KeyboardInput {
-            state: ElementState::Pressed,
-            virtual_keycode: Some(keycode),
-            modifiers,
-            ..
-        } => {
-            if let Some((keycode_text, special)) = parse_keycode(keycode) {
-                Some(append_modifiers(modifiers, keycode_text, special))
-            } else {
-                None
-            }
-        },
-        _ => None
-    }
-}
+use skulpin::winit::event::{KeyboardInput, ElementState, ModifiersState, VirtualKeyCode};
+
+fn parse_keycode(keycode: VirtualKeyCode) -> Option<(String, bool)> {
+    match keycode {
+        VirtualKeyCode::Key1 => Some(("1".to_string(), false)),
+        VirtualKeyCode::Key2 => Some(("2".to_string(), false)),
+        VirtualKeyCode::Key3 => Some(("3".to_string(), false)),
+        VirtualKeyCode::Key4 => Some(("4".to_string(), false)),
+        VirtualKeyCode::Key5 => Some(("5".to_string(), false)),
+        VirtualKeyCode::Key6 => Some(("6".to_string(), false)),
+        VirtualKeyCode::Key7 => Some(("7".to_string(), false)),
+        VirtualKeyCode::Key8 => Some(("8".to_string(), false)),
+        VirtualKeyCode::Key9 => Some(("9".to_string(), false)),
+        VirtualKeyCode::Key0 => Some(("0".to_string(), false)),
+        VirtualKeyCode::A => Some(("a".to_string(), false)),
+        VirtualKeyCode::B => Some(("b".to_string(), false)),
+        VirtualKeyCode::C => Some(("c".to_string(), false)),
+        VirtualKeyCode::D => Some(("d".to_string(), false)),
+        VirtualKeyCode::E => Some(("e".to_string(), false)),
+        VirtualKeyCode::F => Some(("f".to_string(), false)),
+        VirtualKeyCode::G => Some(("g".to_string(), false)),
+        VirtualKeyCode::H => Some(("h".to_string(), false)),
+        VirtualKeyCode::I => Some(("i".to_string(), false)),
+        VirtualKeyCode::J => Some(("j".to_string(), false)),
+        VirtualKeyCode::K => Some(("k".to_string(), false)),
+        VirtualKeyCode::L => Some(("l".to_string(), false)),
+        VirtualKeyCode::M => Some(("m".to_string(), false)),
+        VirtualKeyCode::N => Some(("n".to_string(), false)),
+        VirtualKeyCode::O => Some(("o".to_string(), false)),
+        VirtualKeyCode::P => Some(("p".to_string(), false)),
+        VirtualKeyCode::Q => Some(("q".to_string(), false)),
+        VirtualKeyCode::R => Some(("r".to_string(), false)),
+        VirtualKeyCode::S => Some(("s".to_string(), false)),
+        VirtualKeyCode::T => Some(("t".to_string(), false)),
+        VirtualKeyCode::U => Some(("u".to_string(), false)),
+        VirtualKeyCode::V => Some(("v".to_string(), false)),
+        VirtualKeyCode::W => Some(("w".to_string(), false)),
+        VirtualKeyCode::X => Some(("x".to_string(), false)),
+        VirtualKeyCode::Y => Some(("y".to_string(), false)),
+        VirtualKeyCode::Z => Some(("z".to_string(), false)),
+        VirtualKeyCode::Escape => Some(("ESC".to_string(), true)),
+        VirtualKeyCode::F1 => Some(("F1".to_string(), true)),
+        VirtualKeyCode::F2 => Some(("F2".to_string(), true)),
+        VirtualKeyCode::F3 => Some(("F3".to_string(), true)),
+        VirtualKeyCode::F4 => Some(("F4".to_string(), true)),
+        VirtualKeyCode::F5 => Some(("F5".to_string(), true)),
+        VirtualKeyCode::F6 => Some(("F6".to_string(), true)),
+        VirtualKeyCode::F7 => Some(("F7".to_string(), true)),
+        VirtualKeyCode::F8 => Some(("F8".to_string(), true)),
+        VirtualKeyCode::F9 => Some(("F9".to_string(), true)),
+        VirtualKeyCode::F10 => Some(("F10".to_string(), true)),
+        VirtualKeyCode::F11 => Some(("F11".to_string(), true)),
+        VirtualKeyCode::F12 => Some(("F12".to_string(), true)),
+        VirtualKeyCode::F13 => Some(("F13".to_string(), true)),
+        VirtualKeyCode::F14 => Some(("F14".to_string(), true)),
+        VirtualKeyCode::F15 => Some(("F15".to_string(), true)),
+        VirtualKeyCode::F16 => Some(("F16".to_string(), true)),
+        VirtualKeyCode::F17 => Some(("F17".to_string(), true)),
+        VirtualKeyCode::F18 => Some(("F18".to_string(), true)),
+        VirtualKeyCode::F19 => Some(("F19".to_string(), true)),
+        VirtualKeyCode::F20 => Some(("F20".to_string(), true)),
+        VirtualKeyCode::F21 => Some(("F21".to_string(), true)),
+        VirtualKeyCode::F22 => Some(("F22".to_string(), true)),
+        VirtualKeyCode::F23 => Some(("F23".to_string(), true)),
+        VirtualKeyCode::F24 => Some(("F24".to_string(), true)),
+        VirtualKeyCode::Insert => Some(("Insert".to_string(), true)),
+        VirtualKeyCode::Home => Some(("Home".to_string(), true)),
+        VirtualKeyCode::Delete => Some(("Delete".to_string(), true)),
+        VirtualKeyCode::End => Some(("End".to_string(), true)),
+        VirtualKeyCode::PageDown => Some(("PageDown".to_string(), true)),
+        VirtualKeyCode::PageUp => Some(("PageUp".to_string(), true)),
+        VirtualKeyCode::Left => Some(("Left".to_string(), true)),
+        VirtualKeyCode::Up => Some(("Up".to_string(), true)),
+        VirtualKeyCode::Right => Some(("Right".to_string(), true)),
+        VirtualKeyCode::Down => Some(("Down".to_string(), true)),
+        VirtualKeyCode::Back => Some(("BS".to_string(), true)),
+        VirtualKeyCode::Return => Some(("Enter".to_string(), true)),
+        VirtualKeyCode::Space => Some(("Space".to_string(), true)),
+        VirtualKeyCode::Caret => Some(("^".to_string(), false)),
+        VirtualKeyCode::Apostrophe => Some(("'".to_string(), false)),
+        VirtualKeyCode::Backslash => Some(("Bslash".to_string(), true)),
+        VirtualKeyCode::Colon => Some((":".to_string(), false)),
+        VirtualKeyCode::Comma => Some((",".to_string(), false)),
+        VirtualKeyCode::Equals => Some(("=".to_string(), false)),
+        VirtualKeyCode::Grave => Some(("`".to_string(), false)),
+        VirtualKeyCode::LBracket => Some(("[".to_string(), false)),
+        VirtualKeyCode::Minus => Some(("-".to_string(), false)),
+        VirtualKeyCode::Period => Some((".".to_string(), false)),
+        VirtualKeyCode::RBracket => Some(("]".to_string(), false)),
+        VirtualKeyCode::Semicolon => Some((";".to_string(), false)),
+        VirtualKeyCode::Slash => Some(("/".to_string(), false)),
+        VirtualKeyCode::Tab => Some(("Tab".to_string(), true)),
+        _ => None
+    }
+}
+
+fn append_modifiers(modifiers: ModifiersState, keycode_text: String, special: bool) -> String {
+    let mut result = keycode_text;
+    let mut special = special;
+
+    if modifiers.shift() {
+        result = match result.as_ref() {
+            "1" => "!".to_string(),
+            "2" => "@".to_string(),
+            "3" => "#".to_string(),
+            "4" => "$".to_string(),
+            "5" => "%".to_string(),
+            "6" => "^".to_string(),
+            "7" => "&".to_string(),
+            "8" => "*".to_string(),
+            "9" => "(".to_string(),
+            "0" => ")".to_string(),
+            "'" => "\"".to_string(),
+            "Bslash" => {
+                special = false;
+                "|".to_string()
+            },
+            "," => {
+                special = true;
+                "lt".to_string()
+            },
+            "=" => "+".to_string(),
+            "`" => "~".to_string(),
+            "[" => "{".to_string(),
+            "-" => "_".to_string(),
+            "." => ">".to_string(),
+            "]" => "}".to_string(),
+            ";" => ":".to_string(),
+            "/" => "?".to_string(),
+            other => {
+                special = true;
+                format!("S-{}", other)
+            }
+        };
+    }
+    if modifiers.ctrl() {
+        special = true;
+        result = format!("C-{}", result);
+    }
+    if modifiers.alt() {
+        special = true;
+        result = format!("M-{}", result);
+    }
+    if modifiers.logo() {
+        special = true;
+        result = format!("D-{}", result);
+    }
+
+    if special {
+        result = format!("<{}>", result);
+    }
+
+    result
+}
+
+pub fn construct_keybinding_string(input: KeyboardInput) -> Option<String> {
+    match input {
+        KeyboardInput {
+            state: ElementState::Pressed,
+            virtual_keycode: Some(keycode),
+            modifiers,
+            ..
+        } => {
+            if let Some((keycode_text, special)) = parse_keycode(keycode) {
+                Some(append_modifiers(modifiers, keycode_text, special))
+            } else {
+                None
+            }
+        },
+        _ => None
+    }
+}
diff --git a/src/bridge/mod.rs b/src/bridge/mod.rs
new file mode 100644
index 0000000..364f418
--- /dev/null
+++ b/src/bridge/mod.rs
@@ -0,0 +1,89 @@
+mod events;
+mod handler;
+mod keybindings;
+mod ui_commands;
+
+use std::sync::{Arc, Mutex};
+use std::process::Stdio;
+
+use rmpv::Value;
+use nvim_rs::{create::tokio as create, UiAttachOptions};
+use tokio::runtime::Runtime;
+use tokio::process::Command;
+use tokio::sync::mpsc::UnboundedReceiver;
+
+pub use events::*;
+pub use keybindings::*;
+pub use ui_commands::UiCommand;
+use crate::editor::Editor;
+use crate::error_handling::ResultPanicExplanation;
+use handler::NeovimHandler;
+
+#[cfg(target_os = "windows")]
+fn set_windows_creation_flags(cmd: &mut Command) {
+    cmd.creation_flags(0x08000000); // CREATE_NO_WINDOW
+}
+
+fn create_nvim_command() -> Command {
+    let mut cmd = Command::new("nvim");
+
+    cmd.arg("--embed")
+        .args(std::env::args().skip(1))
+        .stderr(Stdio::inherit());
+
+    #[cfg(target_os = "windows")]
+    set_windows_creation_flags(&mut cmd);
+
+    cmd
+}
+
+async fn start_process(editor: Arc<Mutex<Editor>>, mut receiver: UnboundedReceiver<UiCommand>, grid_dimensions: (u64, u64)) {
+    let (width, height) = grid_dimensions;
+    let (mut nvim, io_handler, _) = create::new_child_cmd(&mut create_nvim_command(), NeovimHandler(editor.clone())).await
+        .unwrap_or_explained_panic("Could not create nvim process", "Could not locate or start the neovim process");
+
+    tokio::spawn(async move {
+        match io_handler.await {
+            Err(join_error) => eprintln!("Error joining IO loop: '{}'", join_error),
+            Ok(Err(error)) => eprintln!("Error: '{}'", error),
+            Ok(Ok(())) => {}
+        };
+        std::process::exit(0);
+    });
+
+    nvim.set_var("neovide", Value::Boolean(true)).await
+        .unwrap_or_explained_panic("Could not communicate.", "Could not communicate with neovim process");
+    let mut options = UiAttachOptions::new();
+    options.set_linegrid_external(true);
+    options.set_rgb(true);
+    nvim.ui_attach(width as i64, height as i64, &options).await
+        .unwrap_or_explained_panic("Could not attach.", "Could not attach ui to neovim process");
+
+    let nvim = Arc::new(nvim);
+    loop {
+        let mut commands = Vec::new();
+        let mut resize_command = None;
+        while let Ok(ui_command) = receiver.try_recv() {
+            if let UiCommand::Resize { .. } = ui_command {
+                resize_command = Some(ui_command);
+            } else {
+                commands.push(ui_command);
+            }
+        }
+        if let Some(resize_command) = resize_command {
+            commands.push(resize_command);
+        }
+
+        for ui_command in commands.into_iter() {
+            ui_command.execute(&nvim).await;
+        }
+    }
+}
+
+pub fn start_nvim(editor: Arc<Mutex<Editor>>, receiver: UnboundedReceiver<UiCommand>, grid_dimensions: (u64, u64)) {
+    let rt = Runtime::new().unwrap();
+
+    rt.spawn(async move {
+        start_process(editor, receiver, grid_dimensions).await;
+    });
+}
diff --git a/src/ui_commands.rs b/src/bridge/ui_commands.rs
similarity index 97%
rename from src/ui_commands.rs
rename to src/bridge/ui_commands.rs
index 59aca8f..48fd49e 100644
--- a/src/ui_commands.rs
+++ b/src/bridge/ui_commands.rs
@@ -1,37 +1,37 @@
-use std::sync::Arc;
-
-use nvim_rs::Neovim;
-use nvim_rs::compat::tokio::Compat;
-use tokio::process::ChildStdin;
-
-#[derive(Debug, Clone)]
-pub enum UiCommand {
-    Resize { width: i64, height: i64 },
-    Keyboard(String),
-    MouseButton { action: String, position: (i64, i64) },
-    Scroll { direction: String, position: (i64, i64) },
-    Drag(i64, i64)
-}
-
-impl UiCommand {
-    pub async fn execute(self, nvim: &Neovim<Compat<ChildStdin>>) {
-        match self {
-            UiCommand::Resize { width, height } => 
-                nvim.ui_try_resize(width.max(10), height.max(3)).await
-                    .expect("Resize failed"),
-            UiCommand::Keyboard(input_command) => { 
-                nvim.input(&input_command).await
-                    .expect("Input failed"); 
-            },
-            UiCommand::MouseButton { action, position: (grid_x, grid_y) } => 
-                nvim.input_mouse("left", &action, "", 0, grid_x, grid_y).await
-                    .expect("Mouse Input Failed"),
-            UiCommand::Scroll { direction, position: (grid_x, grid_y) } => 
-                nvim.input_mouse("wheel", &direction, "", 0, grid_x, grid_y).await
-                    .expect("Mouse Scroll Failed"),
-            UiCommand::Drag(grid_x, grid_y) =>
-                nvim.input_mouse("left", "drag", "", 0, grid_x, grid_y).await
-                    .expect("Mouse Drag Failed")
-        }
-    }
-}
+use std::sync::Arc;
+
+use nvim_rs::Neovim;
+use nvim_rs::compat::tokio::Compat;
+use tokio::process::ChildStdin;
+
+#[derive(Debug, Clone)]
+pub enum UiCommand {
+    Resize { width: i64, height: i64 },
+    Keyboard(String),
+    MouseButton { action: String, position: (i64, i64) },
+    Scroll { direction: String, position: (i64, i64) },
+    Drag(i64, i64)
+}
+
+impl UiCommand {
+    pub async fn execute(self, nvim: &Neovim<Compat<ChildStdin>>) {
+        match self {
+            UiCommand::Resize { width, height } => 
+                nvim.ui_try_resize(width.max(10), height.max(3)).await
+                    .expect("Resize failed"),
+            UiCommand::Keyboard(input_command) => { 
+                nvim.input(&input_command).await
+                    .expect("Input failed"); 
+            },
+            UiCommand::MouseButton { action, position: (grid_x, grid_y) } => 
+                nvim.input_mouse("left", &action, "", 0, grid_x, grid_y).await
+                    .expect("Mouse Input Failed"),
+            UiCommand::Scroll { direction, position: (grid_x, grid_y) } => 
+                nvim.input_mouse("wheel", &direction, "", 0, grid_x, grid_y).await
+                    .expect("Mouse Scroll Failed"),
+            UiCommand::Drag(grid_x, grid_y) =>
+                nvim.input_mouse("left", "drag", "", 0, grid_x, grid_y).await
+                    .expect("Mouse Drag Failed")
+        }
+    }
+}
diff --git a/src/editor/command_line.rs b/src/editor/command_line.rs
index a609d6f..ebbbe64 100644
--- a/src/editor/command_line.rs
+++ b/src/editor/command_line.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::events::{RedrawEvent, StyledContent};
+use crate::bridge::{RedrawEvent, StyledContent};
 use crate::editor::{DrawCommand, Style};
 
 const COMMAND_SCALE: u16 = 2;
diff --git a/src/editor/mod.rs b/src/editor/mod.rs
index b4875b1..13c5074 100644
--- a/src/editor/mod.rs
+++ b/src/editor/mod.rs
@@ -1,16 +1,17 @@
+mod cursor;
+mod style;
+mod command_line;
+
 use std::collections::HashMap;
 use std::sync::Arc;
+
 use skulpin::skia_safe::colors;
 use skulpin::winit::window::Window;
 
-mod cursor;
-mod style;
-mod command_line;
-
 pub use cursor::{Cursor, CursorShape, CursorMode};
 pub use style::{Colors, Style};
 use command_line::CommandLine;
-use crate::events::{GridLineCell, GuiOption, RedrawEvent};
+use crate::bridge::{GridLineCell, GuiOption, RedrawEvent};
 
 pub type GridCell = Option<(char, Option<Style>)>;
 
diff --git a/src/main.rs b/src/main.rs
index f29baa5..d98c073 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,122 +1,30 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
+mod bridge;
 mod editor;
-mod events;
 mod window;
-mod keybindings;
 mod renderer;
 mod error_handling;
-mod ui_commands;
 
 #[macro_use] extern crate derive_new;
 #[macro_use] extern crate rust_embed;
 
 use std::sync::{Arc, Mutex};
-use std::process::Stdio;
 
-use async_trait::async_trait;
-use rmpv::Value;
-use nvim_rs::{create::tokio as create, Neovim, UiAttachOptions, Handler, compat::tokio::Compat};
-use tokio::process::{ChildStdin, Command};
-use tokio::task::spawn_blocking;
 use tokio::runtime::Runtime;
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender, UnboundedReceiver};
+use tokio::sync::mpsc::unbounded_channel;
 
 use window::ui_loop;
 use editor::Editor;
-use events::parse_neovim_event;
-use error_handling::ResultPanicExplanation;
-use ui_commands::UiCommand;
+use bridge::{start_nvim, UiCommand};
 
 const INITIAL_WIDTH: u64 = 100;
 const INITIAL_HEIGHT: u64 = 50;
 
-#[cfg(target_os = "windows")]
-fn set_windows_creation_flags(cmd: &mut Command) {
-    use std::os::windows::process::CommandExt;
-    cmd.creation_flags(0x08000000); // CREATE_NO_WINDOW
-}
-
-fn create_nvim_command() -> Command {
-    let mut cmd = Command::new("nvim");
-
-    cmd.arg("--embed")
-        .args(std::env::args().skip(1))
-        .stderr(Stdio::inherit());
-
-    #[cfg(target_os = "windows")]
-    set_windows_creation_flags(&mut cmd);
-
-    cmd
-}
-
-#[derive(Clone)]
-struct NeovimHandler(Arc<Mutex<Editor>>);
-
-#[async_trait]
-impl Handler for NeovimHandler {
-    type Writer = Compat<ChildStdin>;
-
-    async fn handle_notify(&self, event_name: String, arguments: Vec<Value>, _neovim: Neovim<Compat<ChildStdin>>) {
-        let parsed_events = parse_neovim_event(event_name, arguments)
-            .unwrap_or_explained_panic("Could not parse event", "Could not parse event from neovim");
-        for event in parsed_events {
-            let mut editor = self.0.lock().unwrap();
-            editor.handle_redraw_event(event);
-        }
-    }
-}
-
-async fn start_nvim(editor: Arc<Mutex<Editor>>, mut receiver: UnboundedReceiver<UiCommand>) {
-    let (mut nvim, io_handler, _) = create::new_child_cmd(&mut create_nvim_command(), NeovimHandler(editor.clone())).await
-        .unwrap_or_explained_panic("Could not create nvim process", "Could not locate or start the neovim process");
-
-    tokio::spawn(async move {
-        match io_handler.await {
-            Err(join_error) => eprintln!("Error joining IO loop: '{}'", join_error),
-            Ok(Err(error)) => eprintln!("Error: '{}'", error),
-            Ok(Ok(())) => {}
-        };
-        std::process::exit(0);
-    });
-
-    let mut options = UiAttachOptions::new();
-    options.set_linegrid_external(true);
-    options.set_rgb(true);
-    nvim.set_var("neovide", Value::Boolean(true)).await
-        .unwrap_or_explained_panic("Could not communicate.", "Could not communicate with neovim process");
-    nvim.ui_attach(INITIAL_WIDTH as i64, INITIAL_HEIGHT as i64, &options).await
-        .unwrap_or_explained_panic("Could not attach.", "Could not attach ui to neovim process");
-
-    let nvim = Arc::new(nvim);
-    loop {
-        let mut commands = Vec::new();
-        let mut resize_command = None;
-        while let Ok(ui_command) = receiver.try_recv() {
-            if let UiCommand::Resize { .. } = ui_command {
-                resize_command = Some(ui_command);
-            } else {
-                commands.push(ui_command);
-            }
-        }
-        if let Some(resize_command) = resize_command {
-            commands.push(resize_command);
-        }
-
-        for ui_command in commands.into_iter() {
-            ui_command.execute(&nvim).await;
-        }
-    }
-}
-
 fn main() {
-    let rt = Runtime::new().unwrap();
-
     let editor = Arc::new(Mutex::new(Editor::new(INITIAL_WIDTH, INITIAL_HEIGHT)));
     let (sender, receiver) = unbounded_channel::<UiCommand>();
     let editor_clone = editor.clone();
-    rt.spawn(async move {
-        start_nvim(editor_clone, receiver).await;
-    });
+    start_nvim(editor_clone, receiver, (INITIAL_WIDTH, INITIAL_HEIGHT));
     ui_loop(editor, sender, (INITIAL_WIDTH, INITIAL_HEIGHT));
 }
diff --git a/src/window.rs b/src/window.rs
index b3e75ce..68fe1c3 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -11,9 +11,9 @@ use skulpin::winit::window::{Icon, WindowBuilder};
 use tokio::sync::mpsc::UnboundedSender;
 
 use crate::editor::Editor;
-use crate::keybindings::construct_keybinding_string;
+use crate::bridge::construct_keybinding_string;
 use crate::renderer::Renderer;
-use crate::ui_commands::UiCommand;
+use crate::bridge::UiCommand;
 
 #[derive(RustEmbed)]
 #[folder = "assets/"]