docs/.obsidian/plugins/obsidian-excalidraw-plugin/manifest.json

@@ -0,0 +1,12 @@
+{
+  "id": "obsidian-excalidraw-plugin",
+  "name": "Excalidraw",
+  "version": "2.8.3",
+  "minAppVersion": "1.1.6",
+  "description": "An Obsidian plugin to edit and view Excalidraw drawings",
+  "author": "Zsolt Viczian",
+  "authorUrl": "https://www.zsolt.blog",
+  "fundingUrl": "https://ko-fi.com/zsolt",
+  "helpUrl": "https://github.com/zsviczian/obsidian-excalidraw-plugin#readme",
+  "isDesktopOnly": false
+}

docs/.obsidian/workspace.json

@@ -3,26 +3,6 @@
     "id": "20da7b1c0adc4114",
     "type": "split",
     "children": [
-      {
-        "id": "a20540b7c1ddbfca",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "e1fb15cab546d0b6",
-            "type": "leaf",
-            "state": {
-              "type": "markdown",
-              "state": {
-                "file": "Usage/Building The Kernel.md",
-                "mode": "source",
-                "source": false
-              },
-              "icon": "lucide-file",
-              "title": "Building The Kernel"
-            }
-          }
-        ]
-      },
       {
         "id": "6bf1f87bf81a3031",
         "type": "tabs",
@@ -34,7 +14,7 @@
               "type": "markdown",
               "state": {
                 "file": "Usage/Building The Kernel.md",
-                "mode": "preview",
+                "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
@@ -98,8 +78,7 @@
       }
     ],
     "direction": "horizontal",
-    "width": 200,
-    "collapsed": true
+    "width": 200
   },
   "right": {
     "id": "baa2a8e61b737fa6",
@@ -191,8 +170,14 @@
   },
   "active": "add883d295e04659",
   "lastOpenFiles": [
+    "structure/idk.canvas",
+    "structure/kernel.md",
+    "structure/libk.md",
+    "structure/libm.md",
+    "structure/libk",
+    "Usage/Building The Kernel.md",
+    "structure",
     "Usage",
-    "Welcome.md",
-    "Usage/Building The Kernel.md"
+    "Welcome.md"
   ]
 }

docs/structure/idk.canvas

@@ -0,0 +1,41 @@
+{
+	"nodes":[
+		{"id":"8391ed519ab6cb3d","type":"group","x":-920,"y":600,"width":1595,"height":360,"label":"Hardware Layer"},
+		{"id":"967decfbdbf166e2","type":"group","x":-920,"y":120,"width":1595,"height":320,"label":"Kernel Layer (kernelspace)"},
+		{"id":"efd3cf75db396678","type":"group","x":-920,"y":-280,"width":1595,"height":240,"label":"System Layer (userspace)"},
+		{"id":"d577e6c4fa3d7479","type":"group","x":-920,"y":-600,"width":1595,"height":140,"label":"User Layer (userspace)"},
+		{"id":"549099b4188ff073","type":"text","text":"Interrupt handling & initialisation","x":-204,"y":320,"width":250,"height":60,"color":"2"},
+		{"id":"d0c73e9e86edba62","type":"text","text":"Kernel #kernel","x":-220,"y":260,"width":281,"height":140,"color":"2"},
+		{"id":"4fdc8ae730503ad0","type":"text","text":"libk #kernel","x":-880,"y":260,"width":280,"height":140,"color":"2"},
+		{"id":"4839a4f4f0980254","type":"text","text":"System Libraries #userspace","x":-220,"y":-240,"width":281,"height":160,"color":"3"},
+		{"id":"ba48ee2ccc891a62","type":"text","text":"Scheduler","x":-880,"y":160,"width":280,"height":60,"color":"2"},
+		{"id":"3d31fc276e0ba4a0","type":"text","text":"UI Shell #userspace","x":-880,"y":-560,"width":280,"height":60,"color":"4"},
+		{"id":"6b5e17c10589a7b6","type":"text","text":"Generic Application #userspace","x":-219,"y":-560,"width":281,"height":60,"color":"4"},
+		{"id":"0a47f47a2c7b3609","type":"text","text":"CPU #hardware","x":-880,"y":640,"width":280,"height":280,"color":"1"},
+		{"id":"a7002e4427f0540d","type":"text","text":"lib_io","x":-200,"y":-160,"width":122,"height":60,"color":"3"},
+		{"id":"e09d0bccffd19ed9","type":"text","text":"lib_ui","x":-78,"y":-160,"width":118,"height":60,"color":"3"},
+		{"id":"cbfeda8989b260d8","type":"text","text":"Userspace Drivers #userspace","x":360,"y":-240,"width":281,"height":160,"color":"3"},
+		{"id":"3acced35498279a0","type":"text","text":"Hardware #hardware\n- Display\n- Hard drives\n- Keyboard\n- Mouse","x":360,"y":640,"width":281,"height":280,"color":"1"},
+		{"id":"31548bb91b4977eb","type":"text","text":"Syscall API","x":-219,"y":160,"width":281,"height":60,"color":"2"},
+		{"id":"110b7bee2ba99819","type":"text","text":"Drivers & low level kernel libraries","x":-860,"y":320,"width":240,"height":60,"color":"2"}
+	],
+	"edges":[
+		{"id":"6a8d6b7540c2898d","fromNode":"3d31fc276e0ba4a0","fromSide":"right","toNode":"4839a4f4f0980254","toSide":"left","color":"3"},
+		{"id":"57aedf427a150ff1","fromNode":"6b5e17c10589a7b6","fromSide":"bottom","toNode":"4839a4f4f0980254","toSide":"top","color":"3","label":"Applications are statically \nlinked to system libraries"},
+		{"id":"d292a19f88032809","fromNode":"4839a4f4f0980254","fromSide":"bottom","toNode":"31548bb91b4977eb","toSide":"top","color":"2","label":"system libraries make syscalls"},
+		{"id":"8b437f1c08e1caf2","fromNode":"ba48ee2ccc891a62","fromSide":"top","toNode":"3d31fc276e0ba4a0","toSide":"bottom","color":"4","label":"Scheduler Starts\nUI in userspace"},
+		{"id":"3e2c6f6d5dcd7613","fromNode":"4839a4f4f0980254","fromSide":"right","toNode":"cbfeda8989b260d8","toSide":"left","color":"3"},
+		{"id":"88f6e95c288c933d","fromNode":"31548bb91b4977eb","fromSide":"top","toNode":"4839a4f4f0980254","toSide":"bottom","color":"2"},
+		{"id":"156c8a89b537e219","fromNode":"cbfeda8989b260d8","fromSide":"left","toNode":"4839a4f4f0980254","toSide":"right","color":"3","label":"some libs talk to\nhardware through\nuserspace drivers"},
+		{"id":"0d04c5b0f76a5d9b","fromNode":"cbfeda8989b260d8","fromSide":"bottom","toNode":"3acced35498279a0","toSide":"top","fromEnd":"arrow","color":"1","label":"Userspace drivers can talk\ndirectly to hardware so\nin the case of a driver crash\nthe kernel is unaffected"},
+		{"id":"e9f1afb45bf17b77","fromNode":"4fdc8ae730503ad0","fromSide":"bottom","toNode":"3acced35498279a0","toSide":"left","fromEnd":"arrow","color":"1","label":"Libk handles most hardware\ninteraction, keeping the core kernel codebase as minimal\nas possible"},
+		{"id":"99414d640e519c8c","fromNode":"4fdc8ae730503ad0","fromSide":"right","toNode":"d0c73e9e86edba62","toSide":"left","fromEnd":"arrow","color":"2","label":"kernel static linked to libk\nmost kernel functionality\nisfound in libk"},
+		{"id":"85cd865c914dd125","fromNode":"549099b4188ff073","fromSide":"top","toNode":"d0c73e9e86edba62","toSide":"top","color":"2"},
+		{"id":"e882694ec774c0d6","fromNode":"4fdc8ae730503ad0","fromSide":"top","toNode":"ba48ee2ccc891a62","toSide":"bottom","color":"2"},
+		{"id":"c689b667be8cdfab","fromNode":"d0c73e9e86edba62","fromSide":"top","toNode":"31548bb91b4977eb","toSide":"bottom","color":"2"},
+		{"id":"0c9da0cce11e4bd1","fromNode":"ba48ee2ccc891a62","fromSide":"bottom","toNode":"4fdc8ae730503ad0","toSide":"top","color":"2"},
+		{"id":"c45efb0ad498f8a8","fromNode":"ba48ee2ccc891a62","fromSide":"right","toNode":"6b5e17c10589a7b6","toSide":"left","color":"4","label":"Scheduler\nstarts applications"},
+		{"id":"aee2cd6ef9682f0f","fromNode":"31548bb91b4977eb","fromSide":"left","toNode":"ba48ee2ccc891a62","toSide":"right","color":"2","label":"system libs can talk to\nthe scheduler to manage\nprocesses"},
+		{"id":"b1b2b96d8ac2b490","fromNode":"4fdc8ae730503ad0","fromSide":"bottom","toNode":"0a47f47a2c7b3609","toSide":"top","fromEnd":"arrow","color":"1"}
+	]
+}

docs/structure/libm.md

@@ -0,0 +1,16 @@
+- contains all proc macros for building the kernel
+
+## Current Features 
+### font importer:
+- a macro that takes a filename to a font file and turns it into a font.
+```rust 
+pub struct Font {
+	width: usize,
+	height: usize,
+	length: u16,
+	data: [[u8; 16]; 512],
+}
+
+pub static FONT_CP850_8X16: Font = 
+	Font::new(include_font!("./libk/resources/font/cp850-8x16.psf"));
+```

kernel/src/main.rs

@@ -3,10 +3,11 @@
 
 extern crate alloc;
 
+use alloc::vec;
 use libk::{
     drivers::{
         async_io::task::{Executor, Task},
-        io,
+        io::{self, framebuffer::colour::Colour},
     },
     prelude::*,
     util::shell::shell,
@@ -27,6 +28,15 @@ extern "C" fn kmain() -> ! {
     println!("Dimensions: {}x{} (px)", dimensions2.0, dimensions2.1);
     println!("Dimensions: {}x{} (chars)", dimensions.0, dimensions.1);
 
+    let vector = vec![0; 100];
+    println!("vec 100 works");
+    let vector2 = vec![0; 1000];
+    println!("vec 1000 works");
+    let vector3 = vec![0; 10000];
+    println!("vec 10000 works");
+    let vector4 = vec![vec![Colour::Black; 1000]; 1000];
+    println!("vec 100000 works");
+
     let mut executor = Executor::new();
     executor.spawn(Task::new(shell()));
     executor.run();

libk/README.md

@@ -12,7 +12,7 @@ libk is an attempt to move away from the godforsaken git submodules that plagued
 
 A lot of things must be improved and worked on, feel free to add extra TODOs below.
 
-[] Create a kernel logging abstraction similar to Linux. (this should probably just use the serial drivers)
+- [] Create a kernel logging abstraction similar to Linux. (this should probably just use the serial drivers)
 
 The rationale behind this is that we want some sort of debug log/tracing support so we aren't just printf debugging forever.
 

libk/src/drivers/io/ascii/mod.rs

@@ -72,7 +72,7 @@ impl Writer {
         }
 
         // Get the character data from the font array. -- each byte is a row of pixels
-        let data: &[u8] = &self.font.0[c as usize];
+        let data: &[u8] = self.font.glyph_for(c as u16);
 
         if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
             for (row, line) in data.iter().enumerate().take(16) {

libk/src/drivers/io/framebuffer/display.rs

@@ -61,9 +61,16 @@ impl FramebufferWriter {
         }
     }
 
-    pub fn render_frame(&self, buffer: &[Colour; 1280 * 800]) {
-        for (y, row) in buffer.chunks(1280).enumerate() {
+    pub fn render_frame(&self, buffer: &[&[Colour]]) {
+        // TODO: this should return errors
+        for (y, &row) in buffer.iter().enumerate() {
+            if y >= self.height() as usize {
+                break;
+            }
             for (x, pixel) in row.iter().enumerate() {
+                if x >= self.width() as usize {
+                    break;
+                }
                 self.write_pixel(x, y, *pixel);
             }
         }

libk/src/resources/font/mod.rs

@@ -2,12 +2,47 @@ use libm::include_font;
 
 pub mod ibm_vga_8x16;
 
-pub static FONT_SPLEEN_8X16: Font = Font(include_font!(
-    "./libk/resources/font/spleen-8x16.psf"
-));
+pub static FONT_SPLEEN_8X16: Font =
+    Font::new(include_font!("./libk/resources/font/spleen-8x16.psf"));
 
-pub static FONT_CP850_8X16: Font = Font(include_font!(
-    "./libk/resources/font/cp850-8x16.psf"
-));
+pub static FONT_CP850_8X16: Font = Font::new(include_font!("./libk/resources/font/cp850-8x16.psf"));
 
-pub struct Font(pub [[u8; 16]; 512]);
+// pub struct Font(pub [[u8; 16]; 512]);
+
+pub struct Font {
+    width: usize,
+    height: usize,
+    length: u16,
+    data: [[u8; 16]; 512],
+}
+
+impl Font {
+    pub const fn new(data: [[u8; 16]; 512]) -> Font {
+        Font {
+            width: 8,
+            height: 16,
+            length: data.len() as u16,
+            data,
+        }
+    }
+
+    pub const fn glyph_for(&self, c: u16) -> &[u8] {
+        if c > self.length {
+            return &self.data[0];
+        }
+
+        &self.data[c as usize]
+    }
+
+    pub const fn width(&self) -> usize {
+        self.width
+    }
+
+    pub const fn height(&self) -> usize {
+        self.height
+    }
+
+    pub const fn default() -> &'static Font {
+        &FONT_CP850_8X16
+    }
+}

libk/src/std/application.rs

@@ -1,8 +1,8 @@
 use crate::prelude::*;
 
-mod frame;
-mod render;
-mod window;
+pub mod frame;
+pub mod render;
+pub mod window;
 
 pub trait Application {
     type Output;

libk/src/std/application/frame.rs

@@ -1,19 +1,40 @@
+use crate::{drivers::io::framebuffer::colour::Colour, std::maths::geometry::Vec2};
+
 use super::{
     render::{ColouredChar, RenderError},
-    window::Window,
+    window::{self, Window},
 };
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 
 pub struct Frame<'f> {
-    data: Vec<Vec<ColouredChar>>,
+    data: Vec<Vec<Colour>>,
     window: &'f Window,
 }
 
-impl Frame<'_> {
+impl<'a> Frame<'a> {
+    pub fn new(window: &'a Window) -> Self {
+        Self {
+            data: vec![vec![Colour::Black; window.dimensions().x()]; window.dimensions().y()],
+            window,
+        }
+    }
+
     pub fn render(&self) -> Result<(), RenderError> {
-        let data: Vec<&[ColouredChar]> = self.data.iter().map(|v| v.as_slice()).collect::<Vec<_>>();
+        let data: Vec<&[Colour]> = self.data.iter().map(|v| v.as_slice()).collect::<Vec<_>>();
         self.window
             .render(data.as_slice())
             .map_err(|_| RenderError::Generic)
     }
+
+    pub fn write_pixel(&mut self, x: usize, y: usize, color: Colour) -> Result<(), RenderError> {
+        if x >= self.window.dimensions().x() || y >= self.window.dimensions().y() {
+            return Err(RenderError::Generic);
+        }
+        self.data[y][x] = color;
+        Ok(())
+    }
+
+    pub const fn dimensions(&self) -> Vec2<usize> {
+        self.window.dimensions()
+    }
 }

libk/src/std/application/window.rs

@@ -1,6 +1,12 @@
-use crate::{prelude::*, std::maths::geometry::Vec2};
+use limine::framebuffer;
 
-use super::render::{ColouredChar, RenderError};
+use crate::{
+    drivers::io::framebuffer::{colour::Colour, display::FRAMEBUFFER_WRITER},
+    prelude::*,
+    std::maths::geometry::Vec2,
+};
+
+use super::render::RenderError;
 
 pub struct Window {
     dimensions: Vec2<usize>,
@@ -21,8 +27,12 @@ impl Window {
         }
     }
 
-    pub fn render(&self, _data: &[&[ColouredChar]]) -> Result<(), RenderError> {
-        todo!();
+    pub fn render(&self, _data: &[&[Colour]]) -> Result<(), RenderError> {
+        // TODO: error handling!! the kernel should return an error in some cases
+        if let Some(fb) = FRAMEBUFFER_WRITER.lock().as_mut() {
+            fb.render_frame(_data);
+        }
+        Ok(())
     }
 
     pub const fn is_bordered(&self) -> bool {

libk/src/std/ascii.rs

@@ -0,0 +1,59 @@
+use alloc::vec::Vec;
+
+use crate::{drivers::io::framebuffer::colour::Colour, resources::font::Font};
+
+use super::{
+    application::{frame::Frame, render::RenderError},
+    maths::geometry::Vec2,
+};
+
+pub struct Writer<'a> {
+    font: &'a Font,
+}
+
+impl<'a> Writer<'a> {
+    pub const fn new(font: &'a Font) -> Self {
+        Self { font }
+    }
+
+    pub const fn set_font(&mut self, font: &'a Font) {
+        self.font = font;
+    }
+
+    pub const fn font_size(&self) -> Vec2<usize> {
+        Vec2::new(self.font.width(), self.font.height())
+    }
+
+    pub fn render_glyph(
+        &self,
+        frame: &mut Frame,
+        pos: Vec2<usize>,
+        c: u8,
+        scale: usize,
+    ) -> Result<(), RenderError> {
+        // get a reference to the character glyph from the font.
+        let data: &[u8] = self.font.glyph_for(c as u16);
+
+        if pos.x() + self.font.width() * scale > frame.dimensions().x()
+            || pos.y() + self.font.height() * scale > frame.dimensions().y()
+        {
+            return Err(RenderError::Generic);
+        }
+
+        for (row, line) in data.iter().enumerate().take(self.font.height()) {
+            for col in 0..self.font.width() {
+                let pixel_x: usize = pos.x() + col * scale;
+                let pixel_y: usize = pos.y() + row * scale;
+
+                if line & (0x80 >> col) != 0 {
+                    for i in 0..scale {
+                        for j in 0..scale {
+                            frame.write_pixel(pixel_x + i, pixel_y + j, Colour::White)?;
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}

libk/src/std/maths/geometry.rs

@@ -71,3 +71,9 @@ impl<T: Coordinate> DivAssign<T> for Vec2<T> {
         self.y /= rhs;
     }
 }
+
+impl<T: Coordinate> From<Vec2<T>> for (T, T) {
+    fn from(value: Vec2<T>) -> Self {
+        (value.x, value.y)
+    }
+}

libk/src/std/mod.rs

@@ -1,3 +1,4 @@
 pub mod application;
+pub mod ascii;
 pub mod io;
 pub mod maths;

libk/src/util/editor.rs

@@ -0,0 +1,174 @@
+use crate::drivers::io::keyboard::{KeyStroke, get_keystroke_async};
+use crate::prelude::*;
+use crate::resources::font::{FONT_CP850_8X16, FONT_SPLEEN_8X16, Font};
+use crate::std::application::frame::Frame;
+use crate::std::application::render::RenderError;
+use crate::std::application::window::Window;
+use crate::std::application::{Application, Error};
+use crate::std::ascii::Writer;
+use crate::std::maths::geometry::Vec2;
+use alloc::string::ToString;
+
+pub struct Editor {
+    cursor_line: usize,
+    cursor_col: usize,
+
+    mode: Mode,
+    buffer: String,
+    window: Window,
+}
+
+impl Default for Editor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a> Editor {
+    const PADDING: usize = 8;
+
+    pub const fn new() -> Self {
+        Self {
+            cursor_line: 0,
+            cursor_col: 0,
+
+            mode: Mode::Nor,
+            buffer: String::new(),
+            window: Window::new(),
+        }
+    }
+
+    fn render(&'a self) -> Result<Frame<'a>, RenderError> {
+        let mut frame = Frame::new(&self.window);
+        let writer = Writer::new(Font::default());
+
+        let (width, height) = writer.font_size().into();
+
+        let mut col = Self::PADDING;
+        let mut line = Self::PADDING;
+        let mut scale = 1;
+
+        for ch in self.buffer.chars() {
+            if ch == '\n' {
+                line += scale * height;
+                col = Self::PADDING;
+                scale = 1;
+                continue;
+            }
+
+            if width * scale + col > frame.dimensions().x() {
+                line += scale * height;
+                col = Self::PADDING;
+            }
+
+            writer.render_glyph(&mut frame, Vec2::new(col, line), ch as u8, scale)?;
+            col += scale * width;
+        }
+
+        Ok(frame)
+    }
+
+    fn get_lines(&self) -> Vec<&str> {
+        self.buffer.split('\n').collect::<Vec<&str>>();
+        todo!()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn move_cursor(&mut self, x: i32, y: i32) {
+        todo!()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn delete_char(&mut self) {
+        todo!()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn insert_char(&mut self, c: char) {
+        todo!()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn splitline(&mut self) {
+        todo!()
+    }
+}
+
+impl Application for Editor {
+    type Output = ();
+    async fn run(&mut self, _args: Vec<alloc::string::String>) -> Result<Self::Output, Error> {
+        self.window.set_dimensions(Vec2::new(1280, 800));
+        self.window.set_position(Vec2::new(0, 0));
+        self.window.open();
+
+        self.buffer = "Hello world, this is a test init. idk test \n ewntuiewi gjk gfdfg gndf ngdfgnmdfg ndfgmndfg gdfndfnkg njkdgjkndfjnkg ngnjfgnfgnfg fgn fn gfj gnfg jnfgjfngjk fgnjfgnjk jnkdgjnkdfg gfnd njkgdfgjn d fjnkgjkndfgjkndfgjn gndfjnk njkgdfng jnkfgdjknd jnfkgnjk".to_string();
+
+        loop {
+            if let Err(_err) = self.render().and_then(|frame| frame.render()) {
+                // TODO: Handle error
+                return Err(Error::ApplicationFailed("Rendering failed".to_string()));
+            }
+
+            let keystroke = get_keystroke_async().await;
+
+            match self.mode {
+                Mode::Nor => match keystroke {
+                    KeyStroke::Char('i') => self.mode = Mode::Ins,
+                    KeyStroke::Char('`') => return Ok(()),
+                    _ => {}
+                },
+                Mode::Ins => {
+                    match keystroke {
+                        KeyStroke::Char(c) => {
+                            match c {
+                                // escape
+                                '\x1B' => self.mode = Mode::Nor,
+                                // delete
+                                '\x7F' => self.delete_char(),
+                                // backspace
+                                '\x08' => {
+                                    self.move_cursor(-1, 0);
+                                    self.delete_char();
+                                }
+                                // enter
+                                '\n' => self.splitline(),
+                                _ => {
+                                    self.insert_char(c);
+                                    self.move_cursor(1, 0);
+                                }
+                            }
+                        }
+                        KeyStroke::Left => {
+                            self.move_cursor(-1, 0);
+                        }
+                        KeyStroke::Right => {
+                            self.move_cursor(1, 0);
+                        }
+                        KeyStroke::Up => {
+                            self.move_cursor(0, -1);
+                        }
+                        KeyStroke::Down => {
+                            self.move_cursor(0, 1);
+                        }
+                        KeyStroke::None => {}
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub enum Mode {
+    Nor,
+    Ins,
+}
+
+impl core::fmt::Display for Mode {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Nor => write!(f, "Normal"),
+            Self::Ins => write!(f, "Insert"),
+        }
+    }
+}

libk/src/util/mod.rs

@@ -1 +1,2 @@
+pub mod editor;
 pub mod shell;

libk/src/util/shell.rs

@@ -1,6 +1,11 @@
 // use x86_64::registers::rflags::read;
 
-use crate::{drivers::io::ascii::clear_screen, prelude::stdin::read_line, print, println};
+use alloc::vec::Vec;
+
+use crate::{
+    drivers::io::ascii::clear_screen, prelude::stdin::read_line, print, println,
+    std::application::Application, util::editor::Editor,
+};
 
 static FETCH: &str = "
         $$$$$$$$\\                                  $$\\                     
@@ -31,6 +36,10 @@ pub async fn shell() {
             "fetch" => {
                 println!("{}", FETCH);
             }
+            "editor" => {
+                let mut editor = Editor::new();
+                editor.run(Vec::new()).await.unwrap();
+            }
             "clear" => clear_screen(),
             _ => {
                 println!("Unknown command: {}", line);