diff --git a/ableos/src/kmain.rs b/ableos/src/kmain.rs
index 5f1b9312..d718d7e3 100644
--- a/ableos/src/kmain.rs
+++ b/ableos/src/kmain.rs
@@ -3,307 +3,307 @@
 use alloc::{format, vec::Vec};
 
 use crate::{
-    boot_conf::BootConfig,
-    capabilities::FileAccess,
-    file::{File, PathRep},
-    scheduler::SCHEDULER,
+   boot_conf::BootConfig,
+   capabilities::FileAccess,
+   file::{File, PathRep},
+   scheduler::SCHEDULER,
 };
 
 // use crate::scheduler;
 
 use {
-    crate::{
-        arch::{init, sloop},
-        boot_conf,
-        experiments::{
-            info::master,
-            systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
-        },
-        graphics::{VgaBuffer, SCREEN_BUFFER},
-        relib::network::socket::Socket,
-        relib::network::socket::{SimpleSock, SocketReturns},
-        vga_e::{self, num_to_vga16},
-    },
-    alloc::{
-        string::{String, ToString},
-        vec,
-    },
-    core::sync::atomic::{AtomicU64, Ordering::*},
-    lazy_static::lazy_static,
-    log::*,
-    picorand::PicoRandGenerate,
-    rkyv::{ser::serializers::AllocSerializer, Deserialize},
-    shadeable::pixel_format::from_vga_16,
-    y_compositor_protocol::Version,
+   crate::{
+      arch::{init, sloop},
+      boot_conf,
+      experiments::{
+         info::master,
+         systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
+      },
+      graphics::{VgaBuffer, SCREEN_BUFFER},
+      relib::network::socket::Socket,
+      relib::network::socket::{SimpleSock, SocketReturns},
+      vga_e::{self, num_to_vga16},
+   },
+   alloc::{
+      string::{String, ToString},
+      vec,
+   },
+   core::sync::atomic::{AtomicU64, Ordering::*},
+   lazy_static::lazy_static,
+   log::*,
+   picorand::PicoRandGenerate,
+   rkyv::{ser::serializers::AllocSerializer, Deserialize},
+   shadeable::pixel_format::from_vga_16,
+   y_compositor_protocol::Version,
 };
 
 #[no_mangle]
 #[allow(unconditional_recursion)]
 pub extern "C" fn stack_overflow() -> u8 {
-    stack_overflow();
-    // meme number
-    69 // NOTE: Any specific reason for this number aside from memes?
+   stack_overflow();
+   // meme number
+   69 // NOTE: Any specific reason for this number aside from memes?
 }
 
 lazy_static! {
-    pub static ref KEY_BUFFER: spin::Mutex<String> = spin::Mutex::new("".to_string());
-    pub static ref TICK: AtomicU64 = AtomicU64::new(0);
-    pub static ref BOOT_CONF: BootConfig = boot_conf::BootConfig::new();
+   pub static ref KEY_BUFFER: spin::Mutex<String> = spin::Mutex::new("".to_string());
+   pub static ref TICK: AtomicU64 = AtomicU64::new(0);
+   pub static ref BOOT_CONF: BootConfig = boot_conf::BootConfig::new();
 }
 
 /// The main entry point of the kernel
 #[no_mangle]
 pub fn kernel_main() -> ! {
-    init::init();
-    log::set_max_level(BOOT_CONF.log_level());
-    // info!("Initialized");
+   init::init();
+   log::set_max_level(BOOT_CONF.log_level());
+   // info!("Initialized");
 
-    // facepalm::start_facepalm();
+   // facepalm::start_facepalm();
 
-    graphics_pipe_startup();
+   graphics_pipe_startup();
 
-    if false {
-        let mut proc_1 = SimpleSock::new();
-        proc_1.register_protocol("ProcessSpawner".to_string());
+   if false {
+      let mut proc_1 = SimpleSock::new();
+      proc_1.register_protocol("ProcessSpawner".to_string());
 
-        let version = 0;
-        use rkyv::ser::Serializer;
-        let mut serializer = AllocSerializer::<0>::default();
-        serializer.serialize_value(&version).unwrap();
+      let version = 0;
+      use rkyv::ser::Serializer;
+      let mut serializer = AllocSerializer::<0>::default();
+      serializer.serialize_value(&version).unwrap();
 
-        let bytes = serializer.into_serializer().into_inner();
-        proc_1.write(bytes.into_vec());
-        unsafe {
-            let the_bytes = proc_1.read(3).unwrap();
-            let archived = rkyv::archived_root::<Version>(&the_bytes);
-            let deserialized: Version = archived.deserialize(&mut rkyv::Infallible).unwrap();
-            trace!("{:?}", deserialized);
-        }
-    }
+      let bytes = serializer.into_serializer().into_inner();
+      proc_1.write(bytes.into_vec());
+      unsafe {
+         let the_bytes = proc_1.read(3).unwrap();
+         let archived = rkyv::archived_root::<Version>(&the_bytes);
+         let deserialized: Version = archived.deserialize(&mut rkyv::Infallible).unwrap();
+         trace!("{:?}", deserialized);
+      }
+   }
 
-    use crate::scheduler::Priority;
-    let mut scheduler = SCHEDULER.lock();
+   use crate::scheduler::Priority;
+   let mut scheduler = SCHEDULER.lock();
 
-    use Priority::*;
+   use Priority::*;
 
-    let mut xyz = scheduler.new_process(High);
-    xyz.capabilities.files = FileAccess::Some(vec![PathRep {
-        location: FileLocations::Home,
-        file_name: "test".to_string(),
-    }]);
+   let mut xyz = scheduler.new_process(High);
+   xyz.capabilities.files = FileAccess::Some(vec![PathRep {
+      location: FileLocations::Home,
+      file_name: "test".to_string(),
+   }]);
 
-    scheduler.add_process(xyz);
-    for x in &scheduler.list {
-        trace!("{:?}", x);
-    }
-    drop(scheduler);
+   scheduler.add_process(xyz);
+   for x in &scheduler.list {
+      trace!("{:?}", x);
+   }
+   drop(scheduler);
 
-    use crate::proto_filetable::contain::FILE_TABLE;
-    use crate::proto_filetable::file::FileLocations;
+   use crate::proto_filetable::contain::FILE_TABLE;
+   use crate::proto_filetable::file::FileLocations;
 
-    let mut file_table = FILE_TABLE.lock();
-    let mut new_file = File::new(FileLocations::Bin, "test".to_string(), "txt".to_string());
-    new_file.write_bytes(b"Hello, world!");
+   let mut file_table = FILE_TABLE.lock();
+   let mut new_file = File::new(FileLocations::Bin, "test".to_string(), "txt".to_string());
+   new_file.write_bytes(b"Hello, world!");
 
-    file_table.add_file("test", new_file);
+   file_table.add_file("test", new_file);
 
-    let file = file_table.get_file("test");
+   let file = file_table.get_file("test");
 
-    match file {
-        Some(file) => {
-            let file_bytes = &file.data_pointer;
-            let file_string = String::from_utf8(file_bytes.to_vec()).unwrap();
-            info!("{}", file_string);
-        }
-        None => {
-            info!("File not found");
-        }
-    }
+   match file {
+      Some(file) => {
+         let file_bytes = &file.data_pointer;
+         let file_string = String::from_utf8(file_bytes.to_vec()).unwrap();
+         info!("{}", file_string);
+      }
+      None => {
+         info!("File not found");
+      }
+   }
 
-    use crate::wasm::WasmProgram;
-    let ret = WasmProgram::new_from_bytes(&[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]);
-    trace!("Binary Valid: {:?}", ret.validate_header());
+   use crate::wasm::WasmProgram;
+   let ret = WasmProgram::new_from_bytes(&[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]);
+   trace!("Binary Valid: {:?}", ret.validate_header());
 
-    if BOOT_CONF.run_tests {
-        // quick and dirty testing framework
-        screen_writer_test();
-        socket_test();
-        graphics_pipe_test();
-        socket_startup_rng();
-        socket_test_rng();
-    }
+   // quick and dirty testing framework
+   //    if BOOT_CONF.run_tests {
+   screen_writer_test();
+   socket_test();
+   graphics_pipe_test();
+   socket_startup_rng();
+   socket_test_rng();
+   //    }
 
-    if BOOT_CONF.run_demos {
-        graphics_api_demo();
-    }
+   if BOOT_CONF.run_demos {
+      graphics_api_demo();
+   }
 
-    if BOOT_CONF.run_shader_tests {
-        shader_tests();
-    }
+   if BOOT_CONF.run_shader_tests {
+      shader_tests();
+   }
 
-    sloop()
+   sloop()
 }
 
 /// called by arch specific timers to tick up all kernel related functions
 pub fn tick() {
-    let mut data = TICK.load(Relaxed);
-    data += 1;
+   let mut data = TICK.load(Relaxed);
+   data += 1;
 
-    crate::kernel_state::KERNEL_STATE.lock().update_state();
+   crate::kernel_state::KERNEL_STATE.lock().update_state();
 
-    let mut scheduler = SCHEDULER.lock();
-    scheduler.bump_exec();
+   let mut scheduler = SCHEDULER.lock();
+   scheduler.bump_exec();
 
-    TICK.store(data, Relaxed)
+   TICK.store(data, Relaxed)
 }
 /// called every time a key is pressed to add it to the randomness pool
 pub fn key_entropy(key: u8) {}
 
 pub fn cpu_socket_startup() {
-    let mut cpu_info_socket = SimpleSock::new();
-    cpu_info_socket.register_protocol("CPU_INFO".to_string());
+   let mut cpu_info_socket = SimpleSock::new();
+   cpu_info_socket.register_protocol("CPU_INFO".to_string());
 
-    let x = master().unwrap();
-    let _xyz = x.brand_string().unwrap();
+   let x = master().unwrap();
+   let _xyz = x.brand_string().unwrap();
 }
 
 pub fn log_version_data() {
-    info!("{} v{}", RELEASE_TYPE, KERNEL_VERSION);
-    info!(
-        "Brand String: {:?}",
-        master().unwrap().brand_string().unwrap()
-    );
+   info!("{} v{}", RELEASE_TYPE, KERNEL_VERSION);
+   info!(
+      "Brand String: {:?}",
+      master().unwrap().brand_string().unwrap()
+   );
 }
 
 pub fn socket_test() {
-    let mut xyz = SimpleSock::new();
+   let mut xyz = SimpleSock::new();
 
-    xyz.peek();
+   xyz.peek();
 
-    xyz.write(vec![0, 1, 2, 3]);
+   xyz.write(vec![0, 1, 2, 3]);
 
-    let x = "simple 🧦".to_string().into_bytes();
-    xyz.write(x);
+   let x = "simple 🧦".to_string().into_bytes();
+   xyz.write(x);
 
-    info!("{:?}", &xyz.read(4).unwrap());
+   info!("{:?}", &xyz.read(4).unwrap());
 
-    match &xyz.peek() {
-        SocketReturns::ReadOk(strr) => {
-            let out = String::from_utf8_lossy(strr);
+   match &xyz.peek() {
+      SocketReturns::ReadOk(strr) => {
+         let out = String::from_utf8_lossy(strr);
 
-            info!("{}", out);
-        }
-        SocketReturns::ReadIndexOutOfBounds => todo!(),
-        SocketReturns::WriteOk => todo!(),
-    }
+         info!("{}", out);
+      }
+      SocketReturns::ReadIndexOutOfBounds => todo!(),
+      SocketReturns::WriteOk => todo!(),
+   }
 }
 
 pub fn socket_test_rng() {
-    let mut test_sock = SimpleSock::grab_socket("RNGProvider".to_string()).unwrap();
-    info!(
-        "Recieving {} from protocol {}",
-        test_sock.read(1).unwrap()[0],
-        test_sock.protocol().unwrap()
-    );
+   let mut test_sock = SimpleSock::grab_socket("RNGProvider".to_string()).unwrap();
+   info!(
+      "Recieving {} from protocol {}",
+      test_sock.read(1).unwrap()[0],
+      test_sock.protocol().unwrap()
+   );
 }
 
 pub fn socket_startup_rng() {
-    use picorand::{WyRand, RNG};
-    let mut random_socket = SimpleSock::new();
+   use picorand::{WyRand, RNG};
+   let mut random_socket = SimpleSock::new();
 
-    random_socket.register_protocol("RNGProvider".to_string());
-    let bruh = TICK.load(core::sync::atomic::Ordering::Relaxed);
+   random_socket.register_protocol("RNGProvider".to_string());
+   let bruh = TICK.load(core::sync::atomic::Ordering::Relaxed);
 
-    let mut rng = RNG::<WyRand, u8>::new(bruh);
+   let mut rng = RNG::<WyRand, u8>::new(bruh);
 
-    for _ in 0..512 {
-        let x = rng.generate();
-        random_socket.write(vec![x]);
-    }
+   for _ in 0..512 {
+      let x = rng.generate();
+      random_socket.write(vec![x]);
+   }
 }
 
 pub fn screen_writer_test() {
-    let mut sock_print_id = SimpleSock::new();
+   let mut sock_print_id = SimpleSock::new();
 
-    sock_print_id.register_protocol("Screen Printer".to_string());
-    // sock_print_id.write(format!("a原 b画 cフ dァ eイ fル 集").into());
-    // sock_print_id.write(format!("⋮").into());
+   sock_print_id.register_protocol("Screen Printer".to_string());
+   // sock_print_id.write(format!("a原 b画 cフ dァ eイ fル 集").into());
+   // sock_print_id.write(format!("⋮").into());
 
-    sock_print_id.write(format!("λ³ Half Life 3 booting up  ㎣").into());
-    // sock_print_id.write(format!("Happy birthday 🎉").into());
-    // sock_print_id.write(format!("I look forward to ur ai stuff :^>").into());
-    // sock_print_id.write(format!("1....2....3....4....5....6....7....8....9").into());
+   sock_print_id.write(format!("λ³ Half Life 3 booting up  ㎣").into());
+   // sock_print_id.write(format!("Happy birthday 🎉").into());
+   // sock_print_id.write(format!("I look forward to ur ai stuff :^>").into());
+   // sock_print_id.write(format!("1....2....3....4....5....6....7....8....9").into());
 
-    for current in (*String::from_utf8_lossy(&sock_print_id.peek().unwrap())).chars() {
-        vga_e::draw_char(0, 0, current, 0);
-    }
+   for current in (*String::from_utf8_lossy(&sock_print_id.peek().unwrap())).chars() {
+      vga_e::draw_char(0, 0, current, 0);
+   }
 }
 
 pub fn vga_boot_screen() {
-    let mut abcde = SCREEN_BUFFER.lock();
+   let mut abcde = SCREEN_BUFFER.lock();
 
-    for y in 0..480 {
-        for x in 0..640 {
-            let segment_x = x * 4 / 640;
-            let segment_y = y * 4 / 480;
-            let segment = segment_x + segment_y * 4;
+   for y in 0..480 {
+      for x in 0..640 {
+         let segment_x = x * 4 / 640;
+         let segment_y = y * 4 / 480;
+         let segment = segment_x + segment_y * 4;
 
-            abcde.set_pixel(x, y, from_vga_16(num_to_vga16(segment as u8)));
-        }
-    }
+         abcde.set_pixel(x, y, from_vga_16(num_to_vga16(segment as u8)));
+      }
+   }
 }
 
 pub fn graphics_pipe_test() {
-    let mut graphics_pipe = SimpleSock::grab_socket("YCompositor".to_string()).unwrap();
+   let mut graphics_pipe = SimpleSock::grab_socket("YCompositor".to_string()).unwrap();
 
-    let version = Version {
-        major: 13,
-        minor: 123,
-        patch: 0,
-    };
-    use rkyv::ser::Serializer;
-    let mut serializer = AllocSerializer::<0>::default();
-    serializer.serialize_value(&version).unwrap();
-    // let bytes = serializer.into_serializer().into_inner();
+   let version = Version {
+      major: 13,
+      minor: 123,
+      patch: 0,
+   };
+   use rkyv::ser::Serializer;
+   let mut serializer = AllocSerializer::<0>::default();
+   serializer.serialize_value(&version).unwrap();
+   // let bytes = serializer.into_serializer().into_inner();
 
-    // info!("{:?}", bytes);
-    let bytes = serializer.into_serializer().into_inner();
-    graphics_pipe.write(bytes.into_vec());
-    unsafe {
-        let the_bytes = graphics_pipe.read(3).unwrap();
-        let archived = rkyv::archived_root::<Version>(&the_bytes);
-        let deserialized: Version = archived.deserialize(&mut rkyv::Infallible).unwrap();
-        trace!("{:?}", deserialized);
-    }
+   // info!("{:?}", bytes);
+   let bytes = serializer.into_serializer().into_inner();
+   graphics_pipe.write(bytes.into_vec());
+   unsafe {
+      let the_bytes = graphics_pipe.read(3).unwrap();
+      let archived = rkyv::archived_root::<Version>(&the_bytes);
+      let deserialized: Version = archived.deserialize(&mut rkyv::Infallible).unwrap();
+      trace!("{:?}", deserialized);
+   }
 }
 
 pub fn graphics_pipe_startup() {
-    let mut graphics_pipe = SimpleSock::new();
+   let mut graphics_pipe = SimpleSock::new();
 
-    graphics_pipe.register_protocol("YCompositor".to_string());
+   graphics_pipe.register_protocol("YCompositor".to_string());
 }
 
 pub fn graphics_api_demo() {
-    let mut abcde = SCREEN_BUFFER.lock();
-    abcde.force_redraw();
+   let mut abcde = SCREEN_BUFFER.lock();
+   abcde.force_redraw();
 
-    abcde.draw_filled_circle(100, 100, 300, 0x0000ff00);
-    abcde.draw_unfilled_rect(100, 100, 400, 200, 0xff000000);
-    abcde.draw_filled_rect(300, 300, 400, 400, 0xff000000);
-    abcde.draw_line(100, 100, 400, 200, 0xff000000);
-    abcde.copy_to_buffer();
+   abcde.draw_filled_circle(100, 100, 300, 0x0000ff00);
+   abcde.draw_unfilled_rect(100, 100, 400, 200, 0xff000000);
+   abcde.draw_filled_rect(300, 300, 400, 400, 0xff000000);
+   abcde.draw_line(100, 100, 400, 200, 0xff000000);
+   abcde.copy_to_buffer();
 }
 
 pub fn shader_tests() {
-    let mut graphics = SCREEN_BUFFER.lock();
+   let mut graphics = SCREEN_BUFFER.lock();
 
-    graphics.clear();
-    graphics.force_redraw();
-    graphics.draw_filled_rect(25, 25, 50, 50, 0xff000000);
-    graphics.set_pixel(50, 50, 0xffffff00);
-    graphics.shade();
+   graphics.clear();
+   graphics.force_redraw();
+   graphics.draw_filled_rect(25, 25, 50, 50, 0xff000000);
+   graphics.set_pixel(50, 50, 0xffffff00);
+   graphics.shade();
 
-    graphics.copy_to_buffer();
+   graphics.copy_to_buffer();
 
-    // drop(graphics)
+   // drop(graphics)
 }
diff --git a/ableos/src/vga_e.rs b/ableos/src/vga_e.rs
index f151490d..2c6a1ff3 100644
--- a/ableos/src/vga_e.rs
+++ b/ableos/src/vga_e.rs
@@ -69,7 +69,7 @@ pub fn draw_char(mut x: u32, mut y: u32, character: char, color: Rgba64) {
          );
 
          // elf: I don't know if GLYPH_HEIGHT is in the right units here. I'm just guessing.
-         if x as usize > SCREEN_BUFFER.lock().size.x {
+         if x as usize > mode.size.x {
             x = 0;
             y += (GLYPH_HEIGHT * FONT_SCALE) as u32;
          }