Merge remote-tracking branch 'origin' into unified

someone broke a mod.rs so i fixed it.
Merging with origin/unified
2025-03-06 01:18:43 +00:00 · 2025-03-05 21:10:36 +00:00 · 2025-03-05 21:04:58 +00:00 · 2025-03-05 20:49:21 +00:00 · 2025-03-05 20:44:09 +00:00 · 2025-03-05 03:24:26 +00:00
96 changed files with 3496 additions and 1459 deletions
@@ -1,5 +1,5 @@
 [build]
-target = "x86_64-kernel"
+target = "x86_64-kernel.json"
 target-dir = "build/target"

 [unstable]
@@ -4,6 +4,9 @@
    <content url="file://$MODULE_DIR$">
      <sourceFolder url="file://$MODULE_DIR$/kernel/src" isTestSource="false" />
      <sourceFolder url="file://$MODULE_DIR$/lib_example/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/libk/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/libm/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/kernel_fonts/src" isTestSource="false" />
      <excludeFolder url="file://$MODULE_DIR$/target" />
    </content>
    <orderEntry type="inheritedJdk" />
@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>
@@ -1,9 +1,10 @@
 {
    "rust-analyzer.cargo.allTargets": false,
-    "rust-analyzer.cargo.target": "x86_64-kernel",
+    "rust-analyzer.cargo.target": "x86_64-kernel.json",
    "[rust]": {
        "editor.defaultFormatter": "rust-lang.rust-analyzer",
        "editor.formatOnSave": true
    },
    "rust-analyzer.check.command": "clippy",
+    "rust-analyzer.cargo.buildScripts.enable": true
 }
@@ -64,13 +64,65 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"

+[[package]]
+name = "darling"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "elf"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4445909572dbd556c457c849c4ca58623d84b27c8fff1e74b0b4227d8b90d17b"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
 [[package]]
 name = "foundry_os"
 version = "0.1.0"
 dependencies = [
 "cc",
- "libk",
+ "crossbeam",
+ "elf",
+ "futures-util",
+ "gimli",
+ "libm",
 "limine",
+ "linked_list_allocator",
 "pc-keyboard",
 "pic8259",
 "spin",
@@ -102,16 +154,25 @@ dependencies = [
 ]

 [[package]]
-name = "libk"
+name = "gimli"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "libm"
 version = "0.1.0"
 dependencies = [
- "crossbeam",
- "futures-util",
- "limine",
- "linked_list_allocator",
- "pc-keyboard",
- "spin",
- "x86_64",
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]

 [[package]]
@@ -169,6 +230,24 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"

+[[package]]
+name = "proc-macro2"
+version = "1.0.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+dependencies = [
+ "proc-macro2",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.19"
@@ -205,6 +284,29 @@ dependencies = [
 "lock_api",
 ]

+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00e2473a93778eb0bad35909dff6a10d28e63f792f16ed15e404fca9d5eeedbe"
+
 [[package]]
 name = "volatile"
 version = "0.4.6"
@@ -1,5 +1,5 @@
 [workspace]
-members = ["kernel", "libk"]
+members = ["kernel", "libm"]
 resolver = "2"

 [workspace.package]
@@ -1,24 +1,52 @@
 # FoundryOS

-## Cloning and building
-
-Here are some simple steps to get started:
-
+## Cloning
 ```sh
 git clone https://git.zxq5.dev/OsDev/FoundryOS.git
+```
+
+## Build dependencies
+
+* latest rust nightly release
+* all necessary rust components installed
+* xorriso: creates ISO images to be booted from.
+* (Optional / Recommended) qemu: to run the kernel. (this may be packaged as qemu-desktop)
+* (Optional) GDB: for debugging the kernel.
+
+```sh
+rustup update
+rustup override set nightly
+rustup component add rust-src
+rustup component add llvm-tools-preview
+```
+
+## Building & Running in qemu
+```sh
 cargo run
 ```

-## Running in GDB:
+## Running in GDB
 ```sh
 USE_GDB=1 cargo run
 ```

-### Build dependencies
+## Build errors

-* libisoburn: creates ISO images to be booted from.
-* qemu: to run the kernel.
+If you see a qemu error like this:

-Optionally,
+```
+qemu-system-x86_64: -drive if=pflash,format=raw,readonly=on,file=<...>/OVMF_CODE.fd: Could not open '<...>/OVMF_CODE.fd': No such file or directory
+```

-* GDB: for debugging the kernel.
+Simply delete the ./build directory and try to rebuild the program. Using the runner script or `cargo run` will download the required files for you, this is because the script only checks for the presence of one file and not the VARS file.
+
+Alternatively, you may disable using a UEFI firmware with qemu like so:
+```sh
+USE_LEGACY_BIOS=1 cargo run
+```
+
+## Debugging
+
+See [debugging](docs/Debugging/DEBUGGING.md) for some help with this, including commands to help with disassembly.
+
+If you have any other issues, feel free to create an issue or a PR.
@@ -1,5 +1,5 @@
 # Timeout in seconds that Limine will use before automatically booting.
-timeout: 1
+timeout: 0

 # The entry name that will be displayed in the boot menu.
 /foundry-os
@@ -0,0 +1,17 @@
+[0;32m[1m Running kernel in debug mode.
+[0;34m[1minfo[0m: Creating build directory structure
+[0;34m[1minfo[0m: Copying files to ISO root
+[0;32m[1m  Copying[0m: /home/fantasypvp/Projects/OSdev/FoundryOS/build/target/x86_64-kernel/debug/kernel to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/kernel
+[0;32m[1m  Copying[0m: /home/fantasypvp/Projects/OSdev/FoundryOS/config/limine.conf to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/limine/limine.conf
+[0;32m[1m  Copying[0m: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/limine-bios-cd.bin to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/limine/
+[0;32m[1m  Copying[0m: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/limine-uefi-cd.bin to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/limine/
+[0;32m[1m  Copying[0m: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/limine-bios.sys to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/boot/limine/
+[0;32m[1m  Copying[0m: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/BOOTX64.EFI to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/EFI/BOOT/
+[0;32m[1m  Copying[0m: /home/fantasypvp/Projects/OSdev/FoundryOS/build/limine/BOOTIA32.EFI to /home/fantasypvp/Projects/OSdev/FoundryOS/build/iso_root/EFI/BOOT/
+[0;32m[1mBuilding[0m: bootable ISO image
+[0;34m[1minfo[0m: Installing Limine bootloader
+[0;34m[1minfo[0m: KVM acceleration enabled
+[0;34m[1minfo[0m: Running OS in QEMU...
+[2J[01;01H[=3h[2J[01;01H[2J[01;01H[=3h[2J[01;01H[2J[01;01H[=3h[2J[01;01HBdsDxe: loading Boot0001 "UEFI QEMU DVD-ROM QM00005 " from PciRoot(0x0)/Pci(0x1F,0x2)/Sata(0x2,0xFFFF,0x0)
+BdsDxe: starting Boot0001 "UEFI QEMU DVD-ROM QM00005 " from PciRoot(0x0)/Pci(0x1F,0x2)/Sata(0x2,0xFFFF,0x0)
+[2J[01;01H[01;01H[2J[01;01H[01;01Hmap worked!got apic base
@@ -1 +1,3 @@
-{}
+{
+  "cssTheme": "Dark Moss"
+}
@@ -0,0 +1 @@
+[]
@@ -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
+}
@@ -4,41 +4,21 @@
    "type": "split",
    "children": [
      {
-        "id": "a20540b7c1ddbfca",
+        "id": "c178a2dff57ae0aa",
        "type": "tabs",
        "children": [
          {
-            "id": "e1fb15cab546d0b6",
+            "id": "6d395e6a4c72e1c8",
            "type": "leaf",
            "state": {
              "type": "markdown",
              "state": {
-                "file": "Usage/Building The Kernel.md",
+                "file": "Planning & To-Dos.md",
                "mode": "source",
                "source": false
              },
              "icon": "lucide-file",
-              "title": "Building The Kernel"
-            }
-          }
-        ]
-      },
-      {
-        "id": "6bf1f87bf81a3031",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "add883d295e04659",
-            "type": "leaf",
-            "state": {
-              "type": "markdown",
-              "state": {
-                "file": "Usage/Building The Kernel.md",
-                "mode": "preview",
-                "source": false
-              },
-              "icon": "lucide-file",
-              "title": "Building The Kernel"
+              "title": "Planning & To-Dos"
            }
          }
        ]
@@ -73,7 +53,7 @@
            "state": {
              "type": "search",
              "state": {
-                "query": "tag:#usage",
+                "query": "",
                "matchingCase": false,
                "explainSearch": false,
                "collapseAll": false,
@@ -98,8 +78,7 @@
      }
    ],
    "direction": "horizontal",
-    "width": 200,
-    "collapsed": true
+    "width": 307.5
  },
  "right": {
    "id": "baa2a8e61b737fa6",
@@ -177,7 +156,8 @@
      }
    ],
    "direction": "horizontal",
-    "width": 300
+    "width": 300,
+    "collapsed": true
  },
  "left-ribbon": {
    "hiddenItems": {
@@ -185,14 +165,21 @@
      "graph:Open graph view": false,
      "canvas:Create new canvas": false,
      "daily-notes:Open today's daily note": false,
-      "templates:Insert template": false,
-      "command-palette:Open command palette": false
+      "command-palette:Open command palette": false,
+      "templates:Insert template": false
    }
  },
-  "active": "e1fb15cab546d0b6",
+  "active": "6d395e6a4c72e1c8",
  "lastOpenFiles": [
+    "Usage/Building The Kernel.md",
+    "Planning & To-Dos.md",
+    "structure/idk.canvas",
+    "structure/kernel.md",
+    "structure/libk.md",
+    "structure/libm.md",
+    "structure/libk",
+    "structure",
    "Usage",
-    "Welcome.md",
-    "Usage/Building The Kernel.md"
+    "Welcome.md"
  ]
 }
@@ -0,0 +1,16 @@
+# Debugging the Kernel
+
+Here we will add some helpful tips on debugging the kernel.
+
+## Disassembling a public function
+
+To disassemble a public function, first we need a symbol in the public symbol table, so start by making the function fully public (including any parent modules). Do this as though you are trying to make a public function for a library crate (this includes the `kernel` crate). Simply mark the function and any parent modules as public, up until the point of [lib.rs (kernel link)](../../kernel/src/lib.rs).
+
+Then, we need to find the specific demangled symbol to disassemble, because the default objdump output can be very verbose.
+
+```sh
+# Change as required, I pipe to less and /SEARCH FOR FUNCTION HERE.
+nm --demangle ./build/target/x86_64-kernel/debug/kernel | less
+# Now just paste the symbol where it says YOUR_SYMBOL_HERE and profit. Use -Mintel for Intel assembly syntax.
+objdump -Matt --source --line-numbers --visualize-jumps ./build/target/x86_64-kernel/debug/kernel --demangle=rust --disassemble="YOUR_SYMBOL_HERE"
+```
@@ -0,0 +1,135 @@
+> [!todo] Testing
+> - [ ] setup custom test frameworks (Use CrystalOS-V2 as a reference)
+> 	- [ ] write a sub-crate for tests
+> 	- [ ] implement several unit tests on things that we are likely to break often
+> - [ ] setup Git CI/CD pipeline with testing
+> 	- [ ] figure out how to run QEMU in the test environment
+> 	- [ ] write a script to run tests
+> 	- [ ] a release should only be published if all tests pass
+
+> [!todo] Memory
+> - [ ] make sure page tables are correct. we're still getting the annoying page fault errors for the APIC
+> - [ ] page allocator
+>   - [ ] e
+
+> [!todo] Allocator
+> - [x] learn about several allocator designs and decide on the optimal one
+> - [x] implementation
+> 	- [x] implement an allocate method
+> 	- [x] implement a deallocate method
+> 	- [x] set the global allocator
+> - [ ] testing
+> 	- [ ] write unit tests
+> 		- [ ] many allocations
+> 		- [ ] large allocations
+> 		- [ ] allocating more memory than is available
+> 	- [ ] pass unit tests
+
+> [!todo] Threading
+> - [ ] implement thread switching functionality
+> 	- [ ] switch stacks
+> - [ ] implement multi-threading
+> 	- [ ] figure out how to turn on another core
+> - [ ] Scheduler
+> 	- [ ] which task goes on which thread?
+> 		- [ ] round robin / time slicing algorithm
+> 	- [ ] switch tasks on a given core
+> 		- [ ] push registers
+> 		- [ ] switch stacks
+> 		- [ ] ensure the scheduler knows where to find the stack for each thread
+> 	- [ ] move a given task to a new core
+> 	- [ ] differentiate between kernel threads and user threads
+> - [ ] create syscall to create a new thread
+
+> [!todo] Filesystem 
+> - [ ] AHCI Implementation
+> 	- [ ] figure out what hard drives are attached
+> 	- [ ] read data
+> 	- [ ] write data
+> - [ ] FAT32 Implementation
+> 	- [ ] parse FAT header
+> 	- [ ] figure out where files are / what files are what
+> 	- [ ] parse file metadata / figure out type of file
+> 	- [ ] reading the entirety of a file into memory
+> - [ ] *(extension)* ext2 Implementation
+> - [ ] Syscall API
+> 	- [ ] provide a user program with file read / write access given a filename
+> 		- [ ] translate a filename into a disk location of data & the size of the data
+> 		- [ ] provide an interface to read from a file or write to a file
+
+> [!todo] APIC
+> - [ ] Enable APIC
+> 	- [x] Get apic location  from MSR
+> 	- [x] Enable APIC bit flag
+> 	- [x] Disable Legacy PIC
+> 	- [ ] Map physical APIC address to virtual memory
+> 
+>> [!error]
+>> Page fault exception occurs when APIC is activated
+>
+>- [ ] Setup Interrupt handlers to handle interrupts generated by the APIC
+>	- [ ] Timer Interrupts
+>	- [ ] Keyboard Interrupts
+
+> [!todo] Userspace (req: Threading, Filesystem)
+> - [ ] Load program into memory from disk
+> 	- [ ] requires:
+> 		- [ ] Program Loader
+> 			- [ ] Parse ELF File
+> 			- [ ] Load file into memory
+> 		- [ ] Filesystem
+> 		- [ ] Scheduler (to start and manage the process)
+> - [ ] Start a user process
+> 	- [ ] switch stacks
+> 	- [ ] jump to user code
+
+>[!todo] User Interface 
+>- This will be a library so that  programs in userspace can provide a user interface rather than relying on text commands from a basic terminal
+>- features required:
+>	- [ ] Rendering frames to a display buffer
+>		- [ ] requires: Frame rendering Syscall
+>	- [ ] I/O
+>		- [ ] syncio
+>			- [ ] keystrokes
+>		- [ ] asyncio
+>			- [ ] keystrokes
+>		- [ ] requires: I/O Syscalls
+>	- [ ] Window struct
+>		- [ ] stores it's size and location
+>		- [ ] handles rendering pixels to the screen
+>	- [ ] Widgets
+>		- [ ] textbox / label
+>		- [ ] single line text input
+>			- [ ] how do we capture keyboard inputs?
+>		- [ ] multiline text input
+>			- [ ] how do we capture keyboard inputs?
+>		- [ ] button
+>		- [ ] dialog
+>		- [ ] box widget
+>			- [ ] figure out how to nest other widgets inside it
+>```rust
+>pub struct Window {
+>	position;
+>	dimensions;
+>}
+>
+>impl Window {
+>	fn display(&self, frame: &Frame) -> Result<(), RenderError>;
+>}
+>
+>pub struct Frame<'a> {
+>	window: &'a Window,
+>	data: <"... a suitable type to store pixels">
+>}
+>
+>impl<'a> Frame<'a> {
+>	pub fn display(&self) -> Result<(), RenderError> {
+>		self.window.display(self)
+>	}
+>}
+>
+> pub trait Widget {
+> 	fn render(&self) -> Frame;
+> }
+>```
+
@@ -1,4 +1,4 @@
-# Usage 
+#usage 
 ### Requirements
 - Latest rust nightly release
 > rustup update
@@ -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"}
+	]
+}
@@ -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"));
+```
@@ -6,11 +6,21 @@ authors.workspace = true

 [dependencies]
 limine = "0.3.1"
-libk = { path = "../libk" }
 x86_64 = "0.15.2"
 spin = "0.9.8"
 pic8259 = "0.11.0"
 pc-keyboard = "0.8.0"
+libm = { path = "../libm" }
+crossbeam = { version = "0.8.4", default-features = false, features = [
+    "alloc",
+    "crossbeam-queue",
+] }
+futures-util = { version = "0.3.31", default-features = false, features = [
+    "alloc",
+] }
+linked_list_allocator = { version = "0.10.5", features = ["use_spin"] }
+gimli = { version = "0.31.1", default-features = false, features = ["read"] }
+elf = { version = "0.7.4", default-features = false, features = ["nightly"] }

 [build-dependencies]
 cc = "1.2.14"
@@ -62,9 +62,8 @@ SECTIONS
        *(COMMON)
    } :data

-    /* Discard .note.* and .eh_frame* since they may cause issues on some hosts. */
+    /* Discard .note.* and ~~.eh_frame*~~ since they may cause issues on some hosts. */
    /DISCARD/ : {
-        *(.eh_frame*)
        *(.note .note.*)
    }
 }
@@ -0,0 +1,100 @@
+#![expect(unused)]
+
+use core::arch::x86_64::__cpuid;
+
+use crate::arch::x86_64::memory::mapping::PHYSICAL_MEMORY_OFFSET;
+use crate::{debugln, serial_print, serial_println};
+use x86_64::{
+    PhysAddr, VirtAddr,
+    structures::paging::{Mapper, Page, PageTableFlags, PhysFrame, Size4KiB},
+};
+use x86_64::structures::paging::Translate;
+use crate::arch::x86_64::cpu::msr::*;
+use crate::arch::x86_64::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
+
+const IA32_APIC_BASE_MSR: u32 = 0x1b;
+const IA32_APIC_BASE_MSR_BSP: u64 = 0x100;
+const IA32_APIC_BASE_MSR_ENABLE: u64 = 0x800;
+const IA32_APIC_BASE_MSR_DISABLE: u64 = !IA32_APIC_BASE_MSR_ENABLE;
+
+const CPUID_FEAT_EDX_APIC: u64 = 1 << 9; // the cpuid instruction will return this flag if it supports APIC
+
+// const APIC_VIRTUAL_ADDRESS: Lazy<VirtAddr> = Lazy::new(|| {
+//     let apic_base = get_apic_base();
+//     let virt_addr = unsafe { phys_to_virt(apic_base) };
+
+//     virt_addr
+// });
+
+fn set_apic_base_enable(apic: PhysAddr) {
+    let rax = (apic.as_u64() & 0xfffff0000) | IA32_APIC_BASE_MSR_ENABLE;
+    debugln!("apic {:?}", PhysAddr::new(rax));
+    cpu_set_msr(IA32_APIC_BASE_MSR, rax);
+}
+
+#[allow(dead_code)]
+fn set_apic_base_disable(apic: PhysAddr) {
+    let rax = (apic.as_u64() & 0xfffff0000) & IA32_APIC_BASE_MSR_DISABLE;
+    cpu_set_msr(IA32_APIC_BASE_MSR, rax);
+}
+
+fn get_apic_base() -> PhysAddr {
+    let mut value: u64 = 0;
+    cpu_get_msr(IA32_APIC_BASE_MSR, &mut value);
+
+    debugln!("apic base {:#x}", value);
+
+    PhysAddr::new(value & 0xfffff0000)
+}
+
+fn write_apic_register(apic_base: &PhysAddr, reg: u64, value: u32) {
+    let apic_base = apic_base.as_u64();
+    let reg_addr = (apic_base & 0xFFFFF0000) + reg;
+
+    let virt_addr = unsafe { phys_to_virt(PhysAddr::new(reg_addr)) };
+
+    let phys_check = OFFSET_PAGE_TABLE.get().unwrap().lock().translate(virt_addr);
+    debugln!("{:?}", phys_check);
+
+    unsafe { *(virt_addr.as_u64() as *mut u32) = value };
+}
+
+fn read_apic_register(apic_base: &PhysAddr, reg: u64) -> u32 {
+    let apic_base = apic_base.as_u64();
+    let reg_addr = (apic_base & 0xFFFFF0000) + reg;
+    let virt_addr = unsafe { phys_to_virt(PhysAddr::new(reg_addr)) };
+    unsafe { *(virt_addr.as_u64() as *const u32) }
+}
+
+pub fn check_apic() -> bool {
+    let res = unsafe { __cpuid(1) };
+    res.edx as u64 & CPUID_FEAT_EDX_APIC != 0
+}
+
+#[inline(always)]
+unsafe fn phys_to_virt(phys: PhysAddr) -> VirtAddr {
+    let phys = phys.as_u64();
+    phys.checked_add(*PHYSICAL_MEMORY_OFFSET)
+        .map_or_else(|| panic!(" overflow"), VirtAddr::new)
+}
+
+pub fn enable_apic() {
+    let apic_base_physical_addr = get_apic_base();
+    set_apic_base_enable(apic_base_physical_addr);
+
+    debugln!("{:?}", apic_base_physical_addr);
+    enable_timer();
+
+    write_apic_register(
+        &apic_base_physical_addr,
+        0xF0,
+        read_apic_register(&apic_base_physical_addr, 0xF0) | 0x1FF
+    );
+
+}
+
+pub fn enable_timer() {
+    let apic_base = get_apic_base();
+    let current = read_apic_register(&apic_base, 0x320);
+    write_apic_register(&get_apic_base(), 0x320, (current & 0xFFFFFF00) | 0x20);
+}
@@ -0,0 +1,3 @@
+pub mod apic;
+mod msr;
+pub mod pic;
@@ -0,0 +1,25 @@
+#![expect(unused)]
+use core::arch::x86_64::__cpuid;
+use spin::Lazy;
+use x86_64::registers::model_specific::Msr;
+
+const CPUID_FLAG_MSR: u32 = 1 << 5;
+static EDX: Lazy<u32> = Lazy::new(|| unsafe { __cpuid(1).edx });
+
+pub fn cpu_has_msr() -> bool {
+    *EDX & CPUID_FLAG_MSR != 0
+}
+
+pub fn cpu_get_msr(msr: u32, value: &mut u64) {
+    let msr = Msr::new(msr);
+    unsafe {
+        *value = msr.read();
+    }
+}
+
+pub fn cpu_set_msr(msr: u32, value: u64) {
+    let mut msr = Msr::new(msr);
+    unsafe {
+        msr.write(value);
+    }
+}
@@ -0,0 +1,162 @@
+#![allow(clippy::missing_safety_doc)]
+
+use x86_64::instructions::port::Port;
+
+const CMD_INIT: u8 = 0x11;
+const CMD_END_OF_INT: u8 = 0x20;
+const MODE_8086: u8 = 0x01;
+
+struct Pic {
+    offset: u8,
+    data: Port<u8>,
+    command: Port<u8>,
+}
+
+impl Pic {
+    /// Are we in charge of handling the specified interrupt?
+    /// (Each PIC handles 8 interrupts.)
+    const fn handles_interrupt(&self, interrupt_id: u8) -> bool {
+        self.offset <= interrupt_id && interrupt_id < self.offset + 8
+    }
+
+    /// Notify us that an interrupt has been handled and that we're ready
+    /// for more.
+    unsafe fn end_of_interrupt(&mut self) {
+        unsafe { self.command.write(CMD_END_OF_INT) };
+    }
+
+    /// Reads the interrupt mask of this PIC.
+    unsafe fn read_mask(&mut self) -> u8 {
+        unsafe { self.data.read() }
+    }
+
+    /// Writes the interrupt mask of this PIC.
+    unsafe fn write_mask(&mut self, mask: u8) {
+        unsafe { self.data.write(mask) }
+    }
+}
+
+/// A pair of chained PICs.  This is the standard setup on x86.
+pub struct ChainedPics {
+    pics: [Pic; 2],
+}
+
+impl ChainedPics {
+    /// Construct a new `ChainedPics` given the base offsets of the two PICs.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it requires you to pass valid offsets.
+    /// If you pass offsets that are out of range, or if you pass offsets that
+    /// conflict with one another, the resulting object will be useless and
+    /// will likely cause problems for your system.
+    pub const unsafe fn new(offset1: u8, offset2: u8) -> Self {
+        Self {
+            pics: [
+                Pic {
+                    offset: offset1,
+                    command: Port::new(0x20),
+                    data: Port::new(0x21),
+                },
+                Pic {
+                    offset: offset2,
+                    command: Port::new(0xA0),
+                    data: Port::new(0xA1),
+                },
+            ],
+        }
+    }
+
+    /// .
+    ///
+    /// # Safety
+    ///
+    /// .
+    pub const unsafe fn new_contiguous(primary_offset: u8) -> Self {
+        unsafe { Self::new(primary_offset, primary_offset + 8) }
+    }
+
+    /// Returns a new instance of [`ChainedPics`].
+    ///
+    /// # Safety
+    ///
+    /// this is unsafe because it required writing to CPU I/O ports.
+    pub unsafe fn initialize(&mut self) {
+        unsafe {
+            let mut wait_port: Port<u8> = Port::new(0x80);
+            let mut wait = || wait_port.write(0);
+
+            // Save our original interrupt masks, because I'm too lazy to
+            // figure out reasonable values. We'll restore these when we're
+            // done.
+            let saved_masks = self.read_masks();
+
+            // Tell each PIC that we're going to send it a three-byte
+            // initialization sequence on its data port.
+            self.pics[0].command.write(CMD_INIT);
+            wait();
+            self.pics[1].command.write(CMD_INIT);
+            wait();
+
+            // Byte 1: Set up our base offsets.
+            self.pics[0].data.write(self.pics[0].offset);
+            wait();
+            self.pics[1].data.write(self.pics[1].offset);
+            wait();
+
+            // Byte 2: Configure chaining between PIC1 and PIC2.
+            self.pics[0].data.write(4);
+            wait();
+            self.pics[1].data.write(2);
+            wait();
+
+            // Byte 3: Set our mode.
+            self.pics[0].data.write(MODE_8086);
+            wait();
+            self.pics[1].data.write(MODE_8086);
+            wait();
+
+            // Restore our saved masks.
+            self.write_masks(saved_masks[0], saved_masks[1])
+        }
+    }
+
+    /// Reads the interrupt masks of both PICs.
+    pub unsafe fn read_masks(&mut self) -> [u8; 2] {
+        unsafe { [self.pics[0].read_mask(), self.pics[1].read_mask()] }
+    }
+
+    /// Writes the interrupt masks of both PICs.
+    pub unsafe fn write_masks(&mut self, mask1: u8, mask2: u8) {
+        unsafe {
+            self.pics[0].write_mask(mask1);
+            self.pics[1].write_mask(mask2);
+        }
+    }
+
+    /// Disables both PICs by masking all interrupts.
+    pub unsafe fn disable(&mut self) {
+        unsafe { self.write_masks(u8::MAX, u8::MAX) }
+    }
+
+    /// Do we handle this interrupt?
+    pub fn handles_interrupt(&self, interrupt_id: u8) -> bool {
+        self.pics.iter().any(|p| p.handles_interrupt(interrupt_id))
+    }
+
+    /// Figure out which (if any) PICs in our chain need to know about this
+    /// interrupt.  This is tricky, because all interrupts from `pics[1]`
+    /// get chained through `pics[0]`.
+    pub unsafe fn notify_end_of_interrupt(&mut self, interrupt_id: u8) {
+        if self.handles_interrupt(interrupt_id) {
+            if self.pics[1].handles_interrupt(interrupt_id) {
+                unsafe {
+                    self.pics[1].end_of_interrupt();
+                }
+            }
+            unsafe {
+                self.pics[0].end_of_interrupt();
+            }
+        }
+    }
+}
@@ -2,16 +2,17 @@ use core::fmt;
 use spin::{Lazy, Mutex};
 use x86_64::instructions::interrupts;

-pub use super::framebuffer::screensize_px;
-use super::framebuffer::{Colour, FRAMEBUFFER_WRITER};
+use crate::arch::x86_64::drivers::framebuffer::{
+    colour::Colour, display::FRAMEBUFFER_WRITER,
+};

-mod font;
-use font::FONT;
+use crate::resources::font::{FONT_SPLEEN_8X16, Font};

 static FONT_WIDTH: u32 = 8;
 static FONT_HEIGHT: u32 = 16;

-pub static WRITER: Lazy<Mutex<Writer>> = Lazy::new(|| Mutex::new(Writer::new()));
+pub static WRITER: Lazy<Mutex<Writer>> =
+    Lazy::new(|| Mutex::new(Writer::new()));

 pub fn screensize_chars() -> (u32, u32) {
    let writer = WRITER.lock();
@@ -19,6 +20,7 @@ pub fn screensize_chars() -> (u32, u32) {
 }

 pub struct Writer {
+    font: &'static Font,
    /// Measured in chars not pixels.
    screen_width: u32,
    /// Measured in chars not pixels.
@@ -30,9 +32,6 @@ pub struct Writer {

    fg_color: Colour,
    bg_color: Colour,
-
-    offset1: usize,
-    offset2: usize,
 }

 impl Default for Writer {
@@ -48,45 +47,64 @@ impl Writer {
                panic!("Framebuffer writer not initialized.");
            },
            |writer| Self {
+                font: &FONT_SPLEEN_8X16,
                screen_width: writer.width() / 8,
                screen_height: writer.height() / 16,
                text_line: 0,
                text_col: 0,
                fg_color: Colour::White,
                bg_color: Colour::Black,
-                offset1: 16,
-                offset2: 0,
            },
        )
    }

-    pub fn write_glyph(&mut self, c: u16) {
-        if c as u8 == b'\n' {
+    pub const fn set_font(&mut self, font: &'static Font) {
+        self.font = font;
+    }
+
+    /// This is sent when the user types a backspace.
+    const BACKSPACE: u8 = 8;
+
+    pub fn write_glyph(&mut self, c: u8) {
+        if c == b'\n' {
            self.newline();
            return;
+        } else if c == Self::BACKSPACE {
+            self.backspace();
+            return;
        }

-        // get the character data from the font array. -- each byte is a row of pixels
-        let data: &[u8] = &FONT[c as usize * 16..(c as usize + 1) * 16];
+        // Get the character data from the font array. -- each byte is a row of
+        // pixels
+        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) {
                for col in 0..8 {
                    let pixel_x: u32 = self.text_col * FONT_WIDTH + col;
-                    let pixel_y: u32 = self.text_line * FONT_HEIGHT + row as u32;
+                    let pixel_y: u32 =
+                        self.text_line * FONT_HEIGHT + row as u32;

                    if line & (0x80 >> col) != 0 {
-                        // write the foreground color
-                        writer.write_pixel(pixel_x as usize, pixel_y as usize, self.fg_color);
+                        // Write the foreground color
+                        writer.write_pixel(
+                            pixel_x as usize,
+                            pixel_y as usize,
+                            self.fg_color,
+                        );
                    } else {
-                        // write the background color
-                        writer.write_pixel(pixel_x as usize, pixel_y as usize, self.bg_color);
+                        // Write the background color
+                        writer.write_pixel(
+                            pixel_x as usize,
+                            pixel_y as usize,
+                            self.bg_color,
+                        );
                    }
                }
            }
        }

-        // go to next position
+        // Go to next position
        if self.text_col + 1 >= self.screen_width {
            self.newline();
        } else {
@@ -94,11 +112,6 @@ impl Writer {
        }
    }

-    pub const fn set_offset(&mut self, offset1: usize, offset2: usize) {
-        self.offset1 = offset1;
-        self.offset2 = offset2;
-    }
-
    pub const fn dimensions(&self) -> (u32, u32) {
        (self.screen_width, self.screen_height)
    }
@@ -117,9 +130,20 @@ impl Writer {
        }
    }

+    /// Handles the backspace character. TODO: Implement VT-100 style terminal
+    /// control codes alongside a shell. Not simple.
+    pub fn backspace(&mut self) {
+        if self.text_col > 0 {
+            self.text_col -= 1;
+            // Blank out the previous char.
+            self.write_glyph(b' ');
+            self.text_col -= 1;
+        }
+    }
+
    pub fn write_string(&mut self, s: &str) {
        for c in s.chars() {
-            self.write_glyph(c as u16);
+            self.write_glyph(c as u8);
        }
    }

@@ -134,7 +158,7 @@ impl Writer {
    }
 }

-impl core::fmt::Write for Writer {
+impl fmt::Write for Writer {
    fn write_str(&mut self, s: &str) -> core::fmt::Result {
        self.write_string(s);
        Ok(())
@@ -153,19 +177,19 @@ fn write(args: fmt::Arguments, fg: Colour, bg: Colour) {
 }

 pub fn _print(args: fmt::Arguments) {
-    x86_64::instructions::interrupts::without_interrupts(|| {
+    interrupts::without_interrupts(|| {
        write(args, Colour::White, Colour::Black);
    })
 }

 pub fn _print_err(args: fmt::Arguments) {
-    x86_64::instructions::interrupts::without_interrupts(|| {
+    interrupts::without_interrupts(|| {
        write(args, Colour::Red, Colour::Black);
    })
 }

 pub fn _print_log(args: fmt::Arguments) {
-    x86_64::instructions::interrupts::without_interrupts(|| {
+    interrupts::without_interrupts(|| {
        write(args, Colour::Yellow, Colour::Black);
    })
 }
@@ -182,6 +206,14 @@ pub fn clear_screen() {
    });
 }

+pub fn reset_cursor() {
+    interrupts::without_interrupts(|| {
+        let mut writer = WRITER.lock();
+        writer.text_line = 0;
+        writer.text_col = 0;
+    });
+}
+
 #[macro_export]
 macro_rules! println_log {
 	() => ($crate::print_log!("\n"));
@@ -190,7 +222,7 @@ macro_rules! println_log {

 #[macro_export]
 macro_rules! print_log {
-	($($arg:tt)*) => ($crate::io::ascii::_print_log(format_args!($($arg)*)));
+	($($arg:tt)*) => ($crate::prelude::_print_log(format_args!($($arg)*)));
 }

 #[macro_export]
@@ -201,16 +233,16 @@ macro_rules! println {

 #[macro_export]
 macro_rules! print {
-	($($arg:tt)*) => ($crate::io::ascii::_print(format_args!($($arg)*)));
+	($($arg:tt)*) => ($crate::prelude::_print(format_args!($($arg)*)));
 }

 #[macro_export]
-macro_rules! printlnerr {
+macro_rules! eprintln {
    () => ($crate::printerr!("\n"));
-    ($($arg:tt)*) => ($crate::printerr!("{}\n", format_args!($($arg)*)));
+    ($($arg:tt)*) => ($crate::eprint!("{}\n", format_args!($($arg)*)));
 }

 #[macro_export]
-macro_rules! printerr {
-    ($($arg:tt)*) => ($crate::_print_err(format_args!($($arg)*)));
+macro_rules! eprint {
+    ($($arg:tt)*) => ($crate::prelude::_print_err(format_args!($($arg)*)));
 }
@@ -19,9 +19,14 @@ impl From<Colour> for u32 {
    fn from(val: Colour) -> Self {
        match val {
            Colour::ARGB(a, r, g, b) => {
-                (a as u32) << 24 | (r as u32) << 16 | (g as u32) << 8 | (b as u32)
+                (a as u32) << 24
+                    | (r as u32) << 16
+                    | (g as u32) << 8
+                    | (b as u32)
+            }
+            Colour::RGB(r, g, b) => {
+                ((r as u32) << 16) | (g as u32) << 8 | (b as u32)
            }
-            Colour::RGB(r, g, b) => ((r as u32) << 16) | (g as u32) << 8 | (b as u32),
            Colour::HexARGB(hex) => hex,
            Colour::Black => 0xFF000000,
            Colour::Blue => 0xFF0000FF,
@@ -38,7 +43,9 @@ impl From<Colour> for u32 {
 impl core::fmt::Display for Colour {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
-            Self::ARGB(r, g, b, a) => write!(f, "RGBA(#{:x}{:x}{:x}{:x})", r, g, b, a),
+            Self::ARGB(r, g, b, a) => {
+                write!(f, "RGBA(#{:x}{:x}{:x}{:x})", r, g, b, a)
+            }
            Self::RGB(r, g, b) => write!(f, "RGB(#{:x}{:x}{:x})", r, g, b),
            Self::HexARGB(hex) => write!(f, "Hex(#{:x})", hex),
            Self::Black => write!(f, "Black"),
@@ -4,21 +4,21 @@ use limine::request::FramebufferRequest;
 #[unsafe(link_section = ".requests")]
 static FRAMEBUFFER_REQUEST: FramebufferRequest = FramebufferRequest::new();

-mod colour;
-
-pub use colour::Colour;
+use super::colour::Colour;
 use core::panic;

 use limine::framebuffer::Framebuffer;
 use spin::{Lazy, Mutex};

-pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> = Lazy::new(|| {
+pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> =
+    Lazy::new(|| {
        Mutex::new(FRAMEBUFFER_REQUEST.get_response().map_or_else(
            || {
                panic!("Framebuffer request failed");
            },
            |framebuffer_response| {
-            let framebuffer = framebuffer_response.framebuffers().next().unwrap();
+                let framebuffer =
+                    framebuffer_response.framebuffers().next().unwrap();
                Some(FramebufferWriter::new(framebuffer))
            },
        ))
@@ -30,7 +30,8 @@ pub static FRAMEBUFFER_WRITER: Lazy<Mutex<Option<FramebufferWriter>>> = Lazy::ne
 ///
 /// It also avoids the requirement for lifetimes.
 ///
-/// Note this does not implement Writer as these functions only handle drawing pixels.
+/// Note this does not implement Writer as these functions only handle drawing
+/// pixels.
 pub struct FramebufferWriter {
    pitch: u64,
    bpp: u16,
@@ -63,9 +64,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);
            }
        }
@@ -0,0 +1,2 @@
+pub mod colour;
+pub mod display;
@@ -0,0 +1,209 @@
+use core::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use crate::println;
+use crossbeam::queue::ArrayQueue;
+use futures_util::{Stream, StreamExt, task::AtomicWaker};
+use pc_keyboard::{
+    DecodedKey, HandleControl, KeyCode, Keyboard, ScancodeSet1,
+    layouts::Uk105Key,
+};
+use spin::{Lazy, Mutex, Once};
+
+static KBD_QUEUE: Once<ArrayQueue<u8>> = Once::new();
+static WAKER: AtomicWaker = AtomicWaker::new();
+
+pub static KEYBOARD: Lazy<Mutex<Keyboard<Uk105Key, ScancodeSet1>>> =
+    Lazy::new(|| {
+        Mutex::new(Keyboard::new(
+            ScancodeSet1::new(),
+            // TODO: Expose an API to change the default KB layout.
+            Uk105Key,
+            HandleControl::Ignore,
+        ))
+    });
+pub static SCANCODE_STREAM: Lazy<Mutex<ScancodeStream>> =
+    Lazy::new(|| Mutex::new(ScancodeStream::new()));
+
+pub fn add_scancode(scancode: u8) {
+    if let Some(queue) = KBD_QUEUE.get() {
+        if queue.push(scancode).is_err() {
+            println!("WARNING: scancode queue full; dropping keyboard input");
+        } else {
+            WAKER.wake();
+        }
+    } else {
+        println!("WARNING: scancode queue not initialized");
+    }
+}
+
+pub struct ScancodeStream {
+    _private: (),
+}
+
+impl ScancodeStream {
+    pub fn new() -> Self {
+        KBD_QUEUE.call_once(|| ArrayQueue::new(5));
+        Self { _private: () }
+    }
+
+    pub fn try_next(&mut self) -> Option<u8> {
+        KBD_QUEUE.get().and_then(|queue| queue.pop())
+    }
+}
+
+impl Default for ScancodeStream {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Stream for ScancodeStream {
+    type Item = u8;
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        let queue = KBD_QUEUE.get().unwrap();
+
+        if let Some(scancode) = queue.pop() {
+            return Poll::Ready(Some(scancode));
+        }
+
+        WAKER.register(cx.waker());
+        WAKER.register(cx.waker());
+
+        queue.pop().map_or(Poll::Pending, |scancode| {
+            WAKER.take();
+            Poll::Ready(Some(scancode))
+        })
+    }
+}
+
+pub async fn get_keystroke_async() -> KeyStroke {
+    loop {
+        if let Some(scancode) = SCANCODE_STREAM.lock().next().await {
+            if let Ok(keystroke) = KeyStroke::try_from(scancode) {
+                return keystroke;
+            }
+        }
+    }
+}
+
+pub fn get_keystroke_optional() -> Option<KeyStroke> {
+    if let Some(scancode) = SCANCODE_STREAM.lock().try_next() {
+        if let Ok(keystroke) = KeyStroke::try_from(scancode) {
+            return Some(keystroke);
+        }
+    }
+    None
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum KeyStroke {
+    Char(char),
+    Ctrl,
+    RCtrl,
+    Alt,
+    RAlt,
+    Shift,
+    RShift,
+    Meta,
+    RMeta,
+    Backspace,
+    Left,
+    Right,
+    Up,
+    Down,
+    None,
+    Enter,
+    Escape,
+    Del,
+}
+
+impl KeyStroke {
+    pub const fn from_keycode(key: KeyCode) -> Self {
+        match key {
+            KeyCode::LControl => Self::Ctrl,
+            KeyCode::RControl => Self::RCtrl,
+            KeyCode::LAlt => Self::Alt,
+            KeyCode::RAlt2 => Self::RAlt,
+            KeyCode::LShift => Self::Shift,
+            KeyCode::RShift => Self::RShift,
+            KeyCode::LWin => Self::Meta,
+            KeyCode::RWin => Self::RMeta,
+            KeyCode::Backspace => Self::Backspace,
+            KeyCode::ArrowLeft => Self::Left,
+            KeyCode::ArrowRight => Self::Right,
+            KeyCode::ArrowUp => Self::Up,
+            KeyCode::ArrowDown => Self::Down,
+            KeyCode::Return => Self::Enter,
+            KeyCode::Escape => Self::Escape,
+            KeyCode::Delete => Self::Del,
+            _ => Self::None,
+        }
+    }
+}
+
+impl TryFrom<u8> for KeyStroke {
+    type Error = ();
+
+    fn try_from(code: u8) -> Result<Self, Self::Error> {
+        let mut keyboard = KEYBOARD.lock();
+
+        let key = match keyboard.add_byte(code) {
+            Ok(Some(event)) => match keyboard.process_keyevent(event) {
+                Some(key) => key,
+                _ => return Err(()),
+            },
+            _ => return Err(()),
+        };
+
+        match key {
+            DecodedKey::Unicode(ch) => Ok(Self::Char(ch)),
+            DecodedKey::RawKey(key) => match Self::from_keycode(key) {
+                Self::None => Err(()),
+                key => Ok(key),
+            },
+        }
+    }
+}
+
+impl TryInto<char> for KeyStroke {
+    type Error = ();
+
+    fn try_into(self) -> Result<char, Self::Error> {
+        match self {
+            Self::Char(c) => Ok(c),
+            _ => Err(()),
+        }
+    }
+}
+
+impl core::fmt::Display for KeyStroke {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Char(c) => write!(f, "{}", c),
+            Self::Ctrl => write!(f, "CTRL"),
+            Self::RCtrl => write!(f, "RCtrl"),
+            Self::Alt => write!(f, "ALT"),
+            Self::RAlt => write!(f, "RAlt"),
+            Self::Shift => write!(f, "SHIFT"),
+            Self::RShift => write!(f, "RShift"),
+            Self::Meta => write!(f, "META"),
+            Self::RMeta => write!(f, "RMeta"),
+            Self::Backspace => write!(f, "BACKSPACE"),
+            Self::Left => write!(f, "LEFT"),
+            Self::Right => write!(f, "RIGHT"),
+            Self::Up => write!(f, "UP"),
+            Self::Down => write!(f, "DOWN"),
+            Self::Enter => write!(f, "ENTER"),
+            Self::Escape => write!(f, "ESCAPE"),
+            Self::None => write!(f, "NONE"),
+            Self::Del => write!(f, "DEL"),
+        }
+    }
+}
@@ -0,0 +1,5 @@
+pub mod ascii;
+pub mod framebuffer;
+pub mod keyboard;
+pub mod port;
+pub mod serial;
@@ -5,17 +5,17 @@ use core::{
 use spin::{Lazy, Mutex};

 #[macro_export]
-macro_rules! serial_println {
-    () => ($crate::serial_print!("\n"));
-    ($($arg:tt)*) => ($crate::io::serial_print!("{}\n", format_args!($($arg)*)));
+macro_rules! serial_print {
+    ($($arg:tt)*) => ($crate::_serial_write(format_args!($($arg)*)));
 }

 #[macro_export]
-macro_rules! serial_print {
-    ($($arg:tt)*) => ($crate::io::serial::_serial_write(format_args!($($arg)*)));
+macro_rules! serial_println {
+    () => ($crate::serial_print!("\n"));
+    ($($arg:tt)*) => (serial_print!("{}\n", format_args!($($arg)*)));
 }

-use super::port::{inb, outb};
+use crate::arch::x86_64::drivers::port::{inb, outb};

 use x86_64::instructions::interrupts;

@@ -1,11 +1,11 @@
 use x86_64::{
+    VirtAddr,
    instructions::tables::load_tss,
-    registers::segmentation::{Segment, CS, DS, ES, SS},
+    registers::segmentation::{CS, DS, ES, SS, Segment},
    structures::{
        gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector},
        tss::TaskStateSegment,
    },
-    VirtAddr,
 };

 use spin::Lazy;
@@ -1,11 +1,14 @@
-use libk::prelude::*;
+use crate::{debug, serial_print};
+use pic8259::ChainedPics;
 use x86_64::registers::control::Cr2;
 use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
-
-use pic8259::ChainedPics;
-use spin::{Lazy, Mutex};
+use x86_64::structures::paging::mapper::MapperFlushAll;
+use x86_64::structures::paging::{FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB};

 use super::gdt;
+use crate::arch::x86_64::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
+use crate::{println_log, serial_println};
+use spin::{Lazy, Mutex};

 static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
    let mut idt = InterruptDescriptorTable::new();
@@ -40,7 +43,7 @@ pub enum InterruptIndex {
 }

 impl InterruptIndex {
-    fn as_u8(self) -> u8 {
+    const fn as_u8(self) -> u8 {
        self as u8
    }

@@ -51,12 +54,21 @@ impl InterruptIndex {

 pub fn init_idt() {
    IDT.load();
+}
+
+pub fn enable_pic() {
    unsafe {
        PICS.lock().initialize();
        PICS.lock().write_masks(0xfc, 0xff);
    }
 }

+pub fn disable_pic() {
+    unsafe {
+        PICS.lock().disable();
+    }
+}
+
 extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
    serial_println!("Exception: Breakpoint\n{:#?}", stack_frame);
    println_log!("Exception: Breakpoint\n{:#?}", stack_frame);
@@ -79,7 +91,7 @@ extern "x86-interrupt" fn double_fault_handler(
 }

 extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
-    use pc_keyboard::{layouts, HandleControl, Keyboard, ScancodeSet1};
+    use pc_keyboard::{HandleControl, Keyboard, ScancodeSet1, layouts};
    // use pc_keyboard::DecodedKey;
    use spin::Mutex;
    use x86_64::instructions::port::Port;
@@ -96,7 +108,7 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
    let mut port = Port::new(0x60);

    let scancode: u8 = unsafe { port.read() };
-    libk::io::keyboard::add_scancode(scancode);
+    crate::arch::x86_64::drivers::keyboard::add_scancode(scancode);

    unsafe {
        PICS.lock()
@@ -105,6 +117,7 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
 }

 extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
+    debug!("Timer Interrupt");
    unsafe {
        PICS.lock()
            .notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
@@ -112,13 +125,32 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFr
 }

 extern "x86-interrupt" fn page_fault_handler(
-    stack_frame: InterruptStackFrame,
-    error_code: PageFaultErrorCode,
+    _stack_frame: InterruptStackFrame,
+    _error_code: PageFaultErrorCode,
 ) {
    serial_println!("Exception: Page Fault");
    serial_println!("Accessed Address: {:?}", Cr2::read());
-    serial_println!("Error Code: {:?}", error_code);
-    serial_println!("{:#?}", stack_frame);
+    serial_println!("Error Code: {:?}", _error_code);
+    serial_println!("{:#?}", _stack_frame);

-    crate::hcf();
+    if let Some(frame_allocator) = FRAME_ALLOCATOR.get() {
+        let mut f = frame_allocator.lock();
+
+        let frame = f.allocate_frame().unwrap();
+        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+        let page: Page<Size4KiB> =
+            Page::containing_address(Cr2::read().unwrap());
+
+        unsafe {
+            let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
+
+            match mapper.map_to(page, frame, flags, &mut *f) {
+                Ok(_) => {}
+                Err(why) => panic!("failed to map page: {:?}", why),
+            }
+        }
+        MapperFlushAll::new().flush_all();
+    } else {
+        panic!("failed to get frame allocator");
+    }
 }
@@ -1,141 +0,0 @@
-// use lib_alloc::allocator::FoundryAllocator;
-use limine::{memory_map::EntryType, response::MemoryMapResponse};
-use x86_64::{
-    PhysAddr,
-    VirtAddr,
-    // addr,
-    registers::control::Cr3,
-    structures::paging::{
-        // page_table::FrameError,
-        FrameAllocator,
-        OffsetPageTable,
-        PageTable,
-        PhysFrame,
-        Size4KiB,
-    },
-};
-
-/// Returns a mutable reference to the current level 4 page table.
-///
-/// # Safety
-///
-/// The caller must ensure that the level 4 page table is not modified
-/// simultaneously. The caller must also ensure that the physical memory offset
-/// is correct, to ensure that the correct virtual address is constructed.
-unsafe fn active_l4_table(physical_memory_offset: VirtAddr) -> &'static mut PageTable {
-    let (level_4_frame, _) = Cr3::read();
-
-    let phys_addr = level_4_frame.start_address();
-    let virt = phys_addr.as_u64() + physical_memory_offset.as_u64();
-    unsafe { &mut *(virt as *mut PageTable) }
-}
-
-/// Initializes the `OffsetPageTable` for the current CPU architecture.
-///
-/// # Safety
-///
-/// This function must be called only once and should be called before any
-/// memory operations are performed that rely on virtual memory management.
-/// The provided `physical_memory_offset` must be accurate to ensure correct
-/// translation of physical addresses.
-///
-/// # Parameters
-///
-/// - `physical_memory_offset`: The offset to convert physical addresses to
-///   virtual addresses in the higher-half direct map.
-///
-/// # Returns
-///
-/// Returns an `OffsetPageTable` that allows for manipulation of the page
-/// tables for the current CPU architecture.
-pub unsafe fn init(physical_memory_offset: VirtAddr) -> OffsetPageTable<'static> {
-    unsafe {
-        let l4_table = active_l4_table(physical_memory_offset);
-        OffsetPageTable::new(l4_table, physical_memory_offset)
-    }
-}
-
-pub(crate) struct FoundryOSFrameAllocator {
-    memory_map: &'static MemoryMapResponse,
-    next: usize,
-}
-
-impl FoundryOSFrameAllocator {
-    /// Creates a new `FoundryOSFrameAllocator` from a memory map.
-    ///
-    /// This function takes a reference to a `MemoryMapResponse` and initializes a
-    /// `FoundryOSFrameAllocator` with it. The `next` field is set to 0, indicating that
-    /// the first frame to be allocated is the first frame in the memory map.
-    pub unsafe fn init(memory_map: &'static MemoryMapResponse) -> FoundryOSFrameAllocator {
-        FoundryOSFrameAllocator {
-            memory_map,
-            next: 0,
-        }
-    }
-
-    /// An iterator over all usable frames in the memory map.
-    ///
-    /// Yields one `PhysFrame` for each available 4KiB frame in the memory map.
-    ///
-    /// This function is used to allocate frames for the pagemap.
-    fn usable_frames(&self) -> impl Iterator<Item = PhysFrame> + use<> {
-        let regions = self.memory_map.entries().iter();
-        let usable_regions = regions.filter(|region| region.entry_type == EntryType::USABLE);
-
-        let addr_ranges = usable_regions.map(|region| region.base..region.base + region.length);
-
-        let frame_addresses = addr_ranges.flat_map(|r| r.step_by(4096));
-
-        frame_addresses.map(|addr| PhysFrame::from_start_address(PhysAddr::new(addr)).unwrap())
-    }
-}
-
-unsafe impl FrameAllocator<Size4KiB> for FoundryOSFrameAllocator {
-    /// Allocates a frame from the list of usable frames.
-    ///
-    /// This function returns the next available `PhysFrame` from the memory map,
-    /// if one exists. Once a frame is allocated, the internal counter is incremented
-    /// to point to the next frame for future allocations.
-    ///
-    /// # Returns
-    ///
-    /// - `Some(PhysFrame)`: If a usable frame is available.
-    /// - `None`: If there are no more usable frames to allocate.
-    fn allocate_frame(&mut self) -> Option<PhysFrame> {
-        let frame = self.usable_frames().nth(self.next);
-        self.next += 1;
-        frame
-    }
-}
-
-// pub unsafe fn translate_addr(addr: VirtAddr, physical_memory_offset: VirtAddr) -> Option<PhysAddr> {
-//     translate_addr_inner(addr, physical_memory_offset)
-// }
-
-// fn translate_addr_inner(addr: VirtAddr, physical_memory_offset: VirtAddr) -> Option<PhysAddr> {
-//     let (l4_table_frame, _) = Cr3::read();
-
-//     let table_indexes = [
-//         addr.p4_index(),
-//         addr.p3_index(),
-//         addr.p2_index(),
-//         addr.p1_index(),
-//     ];
-//     let mut frame = l4_table_frame;
-
-//     for &i in &table_indexes {
-//         let virt = physical_memory_offset + frame.start_address().as_u64();
-//         let table_ptr: *const PageTable = virt.as_ptr();
-//         let table = unsafe { &*table_ptr };
-
-//         let entry = &table[i];
-
-//         frame = match entry.frame() {
-//             Ok(frame) => frame,
-//             Err(FrameError::FrameNotPresent) => return None,
-//             Err(FrameError::HugeFrame) => panic!("huge frames are not supported!"),
-//         };
-//     }
-
-//     Some(frame.start_address() + u64::from(addr.page_offset()))
-// }
@@ -0,0 +1,306 @@
+use crate::{debugln, serial_print};
+use core::alloc::{GlobalAlloc, Layout};
+use core::ptr;
+use spin::{Mutex, MutexGuard};
+use x86_64::structures::paging::{Size4KiB, mapper::MapToError, PageTableFlags};
+use x86_64::VirtAddr;
+use crate::arch::x86_64::memory::{FRAME_ALLOCATOR, HEAP_SIZE, HEAP_VIRTUAL_SPACE};
+use crate::arch::x86_64::memory::allocation::page_alloc::FoundryOSFrameAllocator;
+use crate::arch::x86_64::memory::units::MemoryUnits;
+use crate::serial_println;
+
+/// We are currently using a linked list heap allocator which uses our underlying page allocator.
+#[global_allocator]
+/// This is now Rust's global allocator, so we can use stuff requiring heap allocations.
+static ALLOCATOR: Locked<FoundryAllocator> = Locked::new(FoundryAllocator::new());
+
+
+/// Initializes the heap.
+///
+/// This function must be called once, before any functions that
+/// require a heap are called. It sets up the heap by allocating
+/// the necessary frames from the page allocator. The heap is
+/// then ready for use.
+///
+/// # Safety
+///
+/// This function must be called only once, and must be called before any types
+/// are constructed that require dynamic memory allocation.
+///
+/// # Parameters
+///
+/// None
+///
+/// # Returns
+///
+/// Returns a `Result` containing a `MapToError` if the heap
+/// could not be initialized, or `Ok` if the heap was
+/// initialized successfully.
+pub unsafe fn init_heap() -> Result<(), MapToError<Size4KiB>> {
+    unsafe {
+        // code to allocate frames is now done in the page fault interrupt handler!
+        ALLOCATOR.lock().init(HEAP_VIRTUAL_SPACE, HEAP_SIZE);
+        Ok(())
+    }
+}
+
+pub struct Locked<T> {
+    inner: Mutex<T>,
+}
+
+impl<T> Locked<T> {
+    pub const fn new(inner: T) -> Self {
+        Self {
+            inner: Mutex::new(inner),
+        }
+    }
+
+    pub fn lock(&self) -> MutexGuard<T> {
+        self.inner.lock()
+    }
+}
+
+const BLOCK_SIZES: &[usize] = &[8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096];
+
+struct ListNode {
+    next: Option<&'static mut ListNode>,
+}
+
+pub struct FoundryAllocator {
+    list_heads: [Option<&'static mut ListNode>; BLOCK_SIZES.len()],
+    fallback: Locked<FoundryFallbackAllocator>,
+}
+
+impl Default for FoundryAllocator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl FoundryAllocator {
+    pub const fn new() -> Self {
+        const EMPTY: Option<&'static mut ListNode> = None;
+        Self {
+            list_heads: [EMPTY; BLOCK_SIZES.len()],
+            fallback: Locked::new(FoundryFallbackAllocator::new()),
+        }
+    }
+    /// Initializes the fallback allocator with the given heap start address and size.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it does not check whether the given heap start address and size are valid.
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
+        debugln!("      => Start: {:?}", VirtAddr::new(heap_start as u64));
+        debugln!("      => Size: {}", MemoryUnits::from_bytes(heap_size));
+        
+        unsafe {
+            self.fallback.lock().init(heap_start, heap_size);
+        }
+    }
+
+    unsafe fn fallback_alloc(&mut self, layout: Layout) -> *mut u8 {
+        unsafe { self.fallback.alloc(layout) }
+    }
+
+    fn block_size(&self, layout: &Layout) -> Option<usize> {
+        let required_block_size = layout.size().max(layout.align());
+        BLOCK_SIZES.iter().position(|&s| s >= required_block_size)
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<FoundryAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut allocator = self.lock();
+
+        match allocator.block_size(&layout) {
+            Some(index) => {
+                match allocator.list_heads[index].take() {
+                    Some(node) => {
+                        allocator.list_heads[index] = node.next.take();
+                        let ptr = node as *mut ListNode as *mut u8;
+                        ensure_mapped(VirtAddr::new(ptr as u64));
+                        ptr
+                    }
+                    None => {
+                        // no block exists in list => allocate new block
+                        let block_size = BLOCK_SIZES[index];
+                        // only works if all block sizes are a power of 2
+                        let block_align = block_size;
+                        let layout = Layout::from_size_align(block_size, block_align).unwrap();
+                        unsafe { allocator.fallback_alloc(layout) }
+                    }
+                }
+            }
+            None => unsafe { allocator.fallback_alloc(layout) },
+        }
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let mut allocator = self.lock();
+        match allocator.block_size(&layout) {
+            Some(idx) => {
+                let new_node = ListNode {
+                    next: allocator.list_heads[idx].take(),
+                };
+
+                let new_ptr = ptr as *mut ListNode;
+                unsafe { new_ptr.write(new_node) };
+                allocator.list_heads[idx] = Some(unsafe { &mut *new_ptr });
+            }
+            None => {
+                unsafe { allocator.fallback.dealloc(ptr, layout) };
+            }
+        }
+    }
+}
+
+struct FallbackListNode {
+    size: usize,
+    next: Option<&'static mut FallbackListNode>,
+}
+
+impl FallbackListNode {
+    const fn new(size: usize) -> Self {
+        Self { size, next: None }
+    }
+
+    fn start_addr(&self) -> usize {
+        self as *const Self as usize
+    }
+
+    fn end_addr(&self) -> usize {
+        self.start_addr() + self.size
+    }
+}
+
+pub struct FoundryFallbackAllocator {
+    head: FallbackListNode,
+}
+
+impl Default for FoundryFallbackAllocator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl FoundryFallbackAllocator {
+    pub const fn new() -> Self {
+        Self {
+            head: FallbackListNode::new(0),
+        }
+    }
+
+    /// Initializes the allocator with a given heap start address and size.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it does not check whether the given heap start address and size are valid.
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
+        unsafe { self.add_region(heap_start, heap_size) };
+    }
+
+    unsafe fn add_region(&mut self, addr: usize, size: usize) {
+        unsafe {
+            let mut node = FallbackListNode::new(size);
+            node.next = self.head.next.take();
+
+            let virt_addr = VirtAddr::new(addr as u64);
+            ensure_mapped(virt_addr);
+
+            let node_ptr = addr as *mut FallbackListNode;
+            node_ptr.write(node);
+            self.head.next = Some(&mut *node_ptr);
+        }
+    }
+
+    fn find_region(
+        &mut self,
+        size: usize,
+        align: usize,
+    ) -> Option<(&'static mut FallbackListNode, usize)> {
+        let mut current = &mut self.head;
+        // look for a large enough memory region in linked list
+        while let Some(ref mut region) = current.next {
+            if let Ok(alloc_start) = Self::alloc_from_region(region, size, align) {
+                // region suitable for allocation -> remove node from list
+                let next = region.next.take();
+                let ret = Some((current.next.take().unwrap(), alloc_start));
+                current.next = next;
+                return ret;
+            } else {
+                // region not suitable -> continue with next region
+                current = current.next.as_mut().unwrap();
+            }
+        }
+        None
+    }
+    const fn align_up(addr: usize, align: usize) -> usize {
+        (addr + align - 1) & !(align - 1)
+    }
+
+    fn size_align(layout: Layout) -> (usize, usize) {
+        let layout = layout
+            .align_to(align_of::<ListNode>())
+            .expect("adjusting alignment failed")
+            .pad_to_align();
+        let size = layout.size().max(size_of::<ListNode>());
+        (size, layout.align())
+    }
+
+    fn alloc_from_region(
+        region: &FallbackListNode,
+        size: usize,
+        align: usize,
+    ) -> Result<usize, ()> {
+        let alloc_start = Self::align_up(region.start_addr(), align);
+        let alloc_end = alloc_start.checked_add(size).ok_or(())?;
+
+        if alloc_end > region.end_addr() {
+            return Err(());
+        }
+
+        let excess_size = region.end_addr() - alloc_end;
+        if excess_size > 0 && excess_size < size_of::<ListNode>() {
+            return Err(());
+        }
+
+        Ok(alloc_start)
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<FoundryFallbackAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut allocator = self.lock();
+        // perform layout adjustments
+        let (size, align) = FoundryFallbackAllocator::size_align(layout);
+
+        if let Some((region, alloc_start)) = allocator.find_region(size, align) {
+            let alloc_end = alloc_start.checked_add(size).expect("overflow");
+            let excess_size = region.end_addr() - alloc_end;
+            if excess_size > 0 {
+                unsafe { allocator.add_region(alloc_end, excess_size) };
+            }
+            let ptr = alloc_start as *mut u8;
+            ensure_mapped(VirtAddr::new(ptr as u64));
+            ptr
+        } else {
+            ptr::null_mut()
+        }
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let mut allocator = self.lock();
+        
+        // perform layout adjustments
+        let (size, _) = FoundryFallbackAllocator::size_align(layout);
+        unsafe { allocator.add_region(ptr as usize, size) }
+    }
+}
+
+fn ensure_mapped(virt_addr: VirtAddr) {
+    if ! FoundryOSFrameAllocator::is_mapped(virt_addr) {
+        let mut foundry_alloc = FRAME_ALLOCATOR.get().unwrap().lock();
+        foundry_alloc.allocate_page(virt_addr, PageTableFlags::PRESENT | PageTableFlags::WRITABLE).unwrap();
+    }
+}
@@ -0,0 +1,3 @@
+pub mod heap_alloc;
+pub(crate) mod page_alloc;
+pub mod stack_alloc;
@@ -0,0 +1,89 @@
+use x86_64::structures::paging::{FrameAllocator, Mapper, Page, PageTableFlags, PhysFrame, Size4KiB, Translate};
+use limine::response::MemoryMapResponse;
+use spin::Mutex;
+use limine::memory_map::EntryType;
+use x86_64::{PhysAddr, VirtAddr};
+use x86_64::structures::paging::mapper::{MapToError, TranslateResult};
+use crate::arch::x86_64::memory::{FRAME_ALLOCATOR, OFFSET_PAGE_TABLE};
+
+pub struct FoundryOSFrameAllocator {
+    memory_map: &'static MemoryMapResponse,
+    next: usize,
+}
+
+impl FoundryOSFrameAllocator {
+    /// Creates a new `FoundryOSFrameAllocator` from a memory map.
+    ///
+    /// This function takes a reference to a `MemoryMapResponse` and initializes
+    /// a `FoundryOSFrameAllocator` with it. The `next` field is set to 0,
+    /// indicating that the first frame to be allocated is the first frame
+    /// in the memory map.
+    pub fn init(memory_map: &'static MemoryMapResponse) {
+        FRAME_ALLOCATOR.call_once(|| {
+            Mutex::new(Self {
+                memory_map,
+                next: 0,
+            })
+        });
+    }
+
+    pub fn count_usable_frames(&self) -> u64 {
+        self.usable_frames().count() as u64
+    }
+
+    pub fn available_memory(&self) -> u64 {
+        self.memory_map
+            .entries()
+            .iter()
+            .map(|region| region.base..region.base + region.length)
+            .flat_map(|r| r.step_by(4096)).count() as u64 * 4096
+    }
+
+    /// An iterator over all usable frames in the memory map.
+    ///
+    /// Yields one `PhysFrame` for each available 4KiB frame in the memory map.
+    ///
+    /// This function is used to allocate frames for the page map.
+    fn usable_frames(&self) -> impl Iterator<Item = PhysFrame> + use<> {
+        let regions = self.memory_map.entries().iter();
+        let usable_regions = regions.filter(|region| region.entry_type == EntryType::USABLE);
+        let addr_ranges = usable_regions.map(|region| region.base..region.base + region.length);
+        let frame_addresses = addr_ranges.flat_map(|r| r.step_by(4096));
+        frame_addresses.map(|addr| PhysFrame::from_start_address(PhysAddr::new(addr)).unwrap())
+    }
+
+    pub(crate) fn is_mapped(virt_addr: VirtAddr) -> bool {
+        let mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
+        matches!(mapper.translate(virt_addr), TranslateResult::Mapped { .. })
+    }
+
+    pub(crate) fn allocate_page(&mut self, start_addr: VirtAddr, flags: PageTableFlags) -> Result<(), MapToError<Size4KiB>> {
+        let page = Page::containing_address(start_addr);
+        let frame = self.allocate_frame().ok_or(MapToError::<Size4KiB>::FrameAllocationFailed)?;
+        let mut mapper = OFFSET_PAGE_TABLE.get().unwrap().lock();
+
+        unsafe {
+            mapper.map_to(page, frame, flags, self)?
+        }.flush();
+
+        Ok(())
+    }
+}
+
+unsafe impl FrameAllocator<Size4KiB> for FoundryOSFrameAllocator {
+    /// Allocates a frame from the list of usable frames.
+    ///
+    /// This function returns the next available `PhysFrame` from the memory
+    /// map, if one exists. Once a frame is allocated, the internal counter
+    /// is incremented to point to the next frame for future allocations.
+    ///
+    /// # Returns
+    ///
+    /// - `Some(PhysFrame)`: If a usable frame is available.
+    /// - `None`: If there are no more usable frames to allocate.
+    fn allocate_frame(&mut self) -> Option<PhysFrame> {
+        let frame = self.usable_frames().nth(self.next);
+        self.next += 1;
+        frame
+    }
+}
@@ -0,0 +1,86 @@
+use crate::arch::x86_64::memory::STACK_VIRTUAL_SPACE;
+use x86_64::VirtAddr;
+use x86_64::structures::paging::{
+    FrameAllocator, Mapper, Page, Size4KiB, mapper,
+};
+
+fn reserve_stack_memory(size_in_pages: u64) -> Page {
+    use core::sync::atomic::{AtomicU64, Ordering};
+    static STACK_ALLOC_NEXT: AtomicU64 =
+        AtomicU64::new(STACK_VIRTUAL_SPACE as u64);
+    let start_addr =
+        VirtAddr::new(STACK_ALLOC_NEXT.fetch_add(
+            size_in_pages * Page::<Size4KiB>::SIZE,
+            Ordering::Relaxed,
+        ));
+    Page::from_start_address(start_addr)
+        .expect("`STACK_ALLOC_NEXT` not page aligned")
+}
+
+/// Allocates a stack in the virtual address space, mapped to physical pages.
+///
+/// This function allocates a stack in the virtual address space, mapped to
+/// physical pages. The stack is allocated as a sequence of pages, with the
+/// first page allocated as a guard page. The stack is then mapped to the
+/// allocated physical frame.
+///
+/// The function takes the size of the stack in pages, a mutable reference to a
+/// mapper, and a mutable reference to a frame allocator. It returns a `Result`
+/// containing a `StackBounds` struct, which contains the start and end virtual
+/// addresses of the allocated stack.
+///
+/// # Safety
+///
+/// This function is unsafe because it maps physical frames to virtual addresses
+/// without any protection. This can lead to bugs if the physical frames are not
+/// correctly allocated, or if the virtual addresses are not correctly aligned.
+///
+/// # Panics
+///
+/// This function will panic if the allocation of the physical frame fails.
+pub unsafe fn alloc_stack(
+    size_in_pages: u64,
+    mapper: &mut impl Mapper<Size4KiB>,
+    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+) -> Result<StackBounds, mapper::MapToError<Size4KiB>> {
+    unsafe {
+        use x86_64::structures::paging::PageTableFlags as Flags;
+
+        let guard_page = reserve_stack_memory(size_in_pages + 1);
+        let stack_start = guard_page + 1;
+        let stack_end = stack_start + size_in_pages;
+
+        for page in Page::range(stack_start, stack_end) {
+            let frame = frame_allocator
+                .allocate_frame()
+                .ok_or(mapper::MapToError::FrameAllocationFailed)?;
+            let flags = Flags::PRESENT | Flags::WRITABLE;
+            mapper.map_to(page, frame, flags, frame_allocator)?.flush();
+        }
+
+        Ok(StackBounds {
+            start: stack_start.start_address(),
+            end: stack_end.start_address(),
+        })
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct StackBounds {
+    start: VirtAddr,
+    end: VirtAddr,
+}
+
+impl StackBounds {
+    pub const fn new(start: VirtAddr, end: VirtAddr) -> Self {
+        Self { start, end }
+    }
+
+    pub const fn start(&self) -> VirtAddr {
+        self.start
+    }
+
+    pub const fn end(&self) -> VirtAddr {
+        self.end
+    }
+}
@@ -14,6 +14,11 @@ static MEMORY_MAP_REQUEST: MemoryMapRequest = MemoryMapRequest::new();
 #[unsafe(link_section = ".requests")]
 static HIGHER_HALF_DIRECT_MAP_REQUEST: HhdmRequest = HhdmRequest::new();

+#[used]
+#[unsafe(link_section = ".requests")]
+pub static KERNEL_ADDRESS_REQUEST: KernelAddressRequest =
+    KernelAddressRequest::new();
+
 /// ```rs
 /// let virt_addr = phys_addr + offset;
 /// let phys_addr = virt_addr - offset; // (given VA is in the HHDM). Do not use for executable code.
@@ -25,10 +30,6 @@ pub static PHYSICAL_MEMORY_OFFSET: Lazy<u64> = Lazy::new(|| {
        .offset()
 });

-#[used]
-#[unsafe(link_section = ".requests")]
-static KERNEL_ADDRESS_REQUEST: KernelAddressRequest = KernelAddressRequest::new();
-
 /// Converts virtual addresses in the kernel to a physical address like this:
 /// ```rs
 /// let phys_addr = virt_addr - virtual_base + physical_base;
@@ -48,9 +49,8 @@ pub static _KERNEL_PHYSICAL_MEMORY_OFFSET: Lazy<(u64, u64)> = Lazy::new(|| {
 ///
 /// Panics if the memory map was not found in MEMORY_MAP_REQUEST.
 pub fn get_memory_map() -> &'static MemoryMapResponse {
-    if let Some(memory_map) = MEMORY_MAP_REQUEST.get_response() {
-        memory_map
-    } else {
-        unreachable!("Could not fetch memory map from Limine.")
-    }
+    MEMORY_MAP_REQUEST.get_response().map_or_else(
+        || unreachable!("Could not fetch memory map from Limine."),
+        |memory_map| memory_map,
+    )
 }
@@ -0,0 +1,62 @@
+pub mod allocation;
+pub mod mapping;
+pub mod units;
+
+use allocation::page_alloc::FoundryOSFrameAllocator;
+use spin::{Mutex, Once};
+use units::MemoryUnits::*;
+use x86_64::{
+    VirtAddr,
+    registers::control::Cr3,
+    structures::paging::{OffsetPageTable, PageTable},
+};
+
+pub const STACK_VIRTUAL_SPACE: usize = 0x5555_5555_0000; // start address of the memory space where we store allocated stacks
+pub const HEAP_VIRTUAL_SPACE: usize = 0x4444_4444_0000; // start address of heap allocated memory
+pub const HEAP_SIZE: usize = MiB(1).to_bytes();
+
+pub static FRAME_ALLOCATOR: Once<Mutex<FoundryOSFrameAllocator>> = Once::new();
+pub static OFFSET_PAGE_TABLE: Once<Mutex<OffsetPageTable>> = Once::new();
+/// Returns a mutable reference to the current level 4 page table.
+///
+/// # Safety
+///
+/// The caller must ensure that the level 4 page table is not modified
+/// simultaneously. The caller must also ensure that the physical memory offset
+/// is correct, to ensure that the correct virtual address is constructed.
+unsafe fn active_l4_table(
+    physical_memory_offset: VirtAddr,
+) -> &'static mut PageTable {
+    let (level_4_frame, _) = Cr3::read();
+
+    let phys_addr = level_4_frame.start_address();
+    let virt = phys_addr.as_u64() + physical_memory_offset.as_u64();
+    unsafe { &mut *(virt as *mut PageTable) }
+}
+
+/// Initializes the `OffsetPageTable` for the current CPU architecture.
+///
+/// # Safety
+///
+/// This function must be called only once and should be called before any
+/// memory operations are performed that rely on virtual memory management.
+/// The provided `physical_memory_offset` must be accurate to ensure correct
+/// translation of physical addresses.
+///
+/// # Parameters
+///
+/// - `physical_memory_offset`: The offset to convert physical addresses to
+///   virtual addresses in the higher-half direct map.
+///
+/// # Returns
+///
+/// Returns an `OffsetPageTable` that allows for manipulation of the page
+/// tables for the current CPU architecture.
+pub fn init_page_table(physical_memory_offset: VirtAddr) {
+    unsafe {
+        let l4_table = active_l4_table(physical_memory_offset);
+        let offset_table =
+            OffsetPageTable::new(l4_table, physical_memory_offset);
+        OFFSET_PAGE_TABLE.call_once(|| Mutex::new(offset_table));
+    }
+}
@@ -0,0 +1,49 @@
+pub enum MemoryUnits {
+    B(usize),
+    KiB(usize),
+    MiB(usize),
+    GiB(usize),
+}
+
+impl MemoryUnits {
+    pub const fn to_bytes(&self) -> usize {
+        match self {
+            Self::B(b) => *b,
+            Self::KiB(kib) => *kib * 1024,
+            Self::MiB(mib) => *mib * 1024 * 1024,
+            Self::GiB(gib) => *gib * 1024 * 1024 * 1024,
+        }
+    }
+
+    pub const fn from_bytes(bytes: usize) -> Self {
+        if bytes < 1024 {
+            Self::B(bytes)
+        } else if bytes < 1024 * 1024 {
+            Self::KiB(bytes / 1024)
+        } else if bytes < 1024 * 1024 * 1024 {
+            Self::MiB(bytes / (1024 * 1024))
+        } else {
+            Self::GiB(bytes / (1024 * 1024 * 1024))
+        }
+    }
+
+    pub const fn convert(&mut self) {
+        match self {
+            Self::B(b) if *b > 1024 => *self = Self::KiB(*b / 1024),
+            Self::KiB(kib) if *kib > 1024 => *self = Self::MiB(*kib / 1024),
+            Self::MiB(mib) if *mib > 1024 => *self = Self::GiB(*mib / 1024),
+            _ => (),
+        }
+    }
+}
+
+impl core::fmt::Display for MemoryUnits {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::B(b) => write!(f, "{} B", b),
+            Self::KiB(kib) => write!(f, "{} KiB", kib),
+            Self::MiB(mib) => write!(f, "{} MiB", mib),
+            Self::GiB(gib) => write!(f, "{} GiB", gib),
+        }
+    }
+}
@@ -1,7 +1,6 @@
+pub mod cpu;
+pub mod drivers;
 pub mod gdt;
-
 pub mod interrupts;
-
 pub mod memory;
-
-pub(crate) mod memmap;
+pub mod processing;
@@ -1,12 +1,20 @@
-extern crate alloc;
-use alloc::{boxed::Box, collections::BTreeMap, sync::Arc, task::Wake};
+//! Allows creation of asynchronous IO bound tasks.
+//!
+//! Written by @zxq5 for the most part with code from
+//! [here](https://github.com/phil-opp/blog_os/).
+
+use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
+use alloc::sync::Arc;
+use alloc::task::Wake;
 use core::{
    future::Future,
    pin::Pin,
-    sync::atomic::{AtomicU64, Ordering},
+    sync::atomic::AtomicU64,
    task::{Context, Poll, Waker},
 };
 use crossbeam::queue::ArrayQueue;
+use x86_64::instructions::interrupts::{self, enable_and_hlt};

 pub struct Task {
    id: TaskId,
@@ -26,18 +34,22 @@ impl Task {
    }
 }

+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+struct TaskId(u64);
+
+impl TaskId {
+    fn new() -> Self {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        Self(NEXT.fetch_add(1, core::sync::atomic::Ordering::Relaxed))
+    }
+}
+
 pub struct Executor {
    tasks: BTreeMap<TaskId, Task>,
    task_queue: Arc<ArrayQueue<TaskId>>,
    waker_cache: BTreeMap<TaskId, Waker>,
 }

-impl Default for Executor {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Executor {
    pub fn new() -> Self {
        Self {
@@ -50,12 +62,13 @@ impl Executor {
    pub fn spawn(&mut self, task: Task) {
        let task_id = task.id;
        if self.tasks.insert(task.id, task).is_some() {
-            panic!("a task with this id has already been allocated");
+            panic!("task with same id already in tasks");
        }
-        self.task_queue.push(task_id).expect("task queue is full");
+        self.task_queue.push(task_id).expect("queue full");
    }

    fn run_ready_tasks(&mut self) {
+        // destructure `self` to avoid borrow checker errors
        let Self {
            tasks,
            task_queue,
@@ -65,14 +78,15 @@ impl Executor {
        while let Some(task_id) = task_queue.pop() {
            let task = match tasks.get_mut(&task_id) {
                Some(task) => task,
-                None => continue,
+                None => continue, // task no longer exists
            };
-            let waker = waker_cache
-                .entry(task_id)
-                .or_insert_with(|| TaskWaker::waker(task_id, task_queue.clone()));
+            let waker = waker_cache.entry(task_id).or_insert_with(|| {
+                TaskWaker::new_waker(task_id, task_queue.clone())
+            });
            let mut context = Context::from_waker(waker);
            match task.poll(&mut context) {
                Poll::Ready(()) => {
+                    // task done -> remove it and its cached waker
                    tasks.remove(&task_id);
                    waker_cache.remove(&task_id);
                }
@@ -81,14 +95,14 @@ impl Executor {
        }
    }

-    pub fn try_run(&mut self) {
+    pub fn run(&mut self) -> ! {
+        loop {
            self.run_ready_tasks();
            self.sleep_if_idle();
        }
+    }

    fn sleep_if_idle(&self) {
-        use x86_64::instructions::interrupts::{self, enable_and_hlt};
-
        interrupts::disable();
        if self.task_queue.is_empty() {
            enable_and_hlt();
@@ -98,24 +112,31 @@ impl Executor {
    }
 }

+impl Default for Executor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 struct TaskWaker {
    task_id: TaskId,
    task_queue: Arc<ArrayQueue<TaskId>>,
 }

 impl TaskWaker {
-    fn waker(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
+    fn wake_task(&self) {
+        self.task_queue.push(self.task_id).expect("task_queue full");
+    }
+
+    fn new_waker(
+        task_id: TaskId,
+        task_queue: Arc<ArrayQueue<TaskId>>,
+    ) -> Waker {
        Waker::from(Arc::new(Self {
            task_id,
            task_queue,
        }))
    }
-
-    fn wake_task(&self) {
-        self.task_queue
-            .push(self.task_id)
-            .expect("task queue is full!");
-    }
 }

 impl Wake for TaskWaker {
@@ -127,13 +148,3 @@ impl Wake for TaskWaker {
        self.wake_task();
    }
 }
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-struct TaskId(u64);
-
-impl TaskId {
-    fn new() -> Self {
-        static NEXT: AtomicU64 = AtomicU64::new(0);
-        Self(NEXT.fetch_add(1, Ordering::Relaxed))
-    }
-}
@@ -0,0 +1,4 @@
+#![expect(unused)]
+pub mod async_io;
+mod taskrunner;
+pub mod threading;
@@ -0,0 +1,12 @@
+use alloc::boxed::Box;
+
+pub struct Task {
+    pid: usize,
+    task: Box<dyn Fn() + Send + 'static>,
+}
+
+impl Task {
+    // pub const fn new() {}
+
+    pub const fn run() {}
+}
@@ -0,0 +1,116 @@
+mod switch;
+mod deprecated;
+
+use core::arch::asm;
+
+#[repr(C)]
+pub struct Thread {
+    id: usize,
+    /// This shall be default before the program is interrupted, otherwise it will store
+    /// CPU registers etc to be restored on context switch.
+    ctx: ThreadContext,
+}
+
+/// CPU state to be saved on context switches.
+#[repr(C)]
+#[derive(Default)]
+pub struct ThreadContext {
+    /// Accumulator register.
+    rax: u64,
+    /// Base register.
+    rbx: u64,
+    /// Counter register.
+    rcx: u64,
+    /// Data register.
+    rdx: u64,
+    /// Source index register.
+    rsi: u64,
+    /// Destination index register.
+    rdi: u64,
+    /// Base pointer register.
+    rbp: u64,
+    /// Stack pointer register.
+    rsp: u64,
+    /// An extended register.
+    r8: u64,
+    /// An extended register.
+    r9: u64,
+    /// An extended register.
+    r10: u64,
+    /// An extended register.
+    r11: u64,
+    /// An extended register.
+    r12: u64,
+    /// An extended register.
+    r13: u64,
+    /// An extended register.
+    r14: u64,
+    /// An extended register.
+    r15: u64,
+    /// The instruction pointer.
+    rip: u64,
+    /// RFLAGS register.
+    rflags: u64,
+}
+
+impl ThreadContext {
+    /// Saves the current registers of the CPU before a context switch
+    /// to be restored later.
+    ///
+    /// # Notes
+    ///
+    /// This function should ONLY be called in interrupt handlers such
+    /// as that of the timer. This will then save registers as required
+    ///
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because of the usage of inline ASM.
+    #[inline(always)]
+    pub unsafe fn save_registers() -> Self {
+        let mut context = Self::default();
+        unsafe {
+            asm!(
+                "mov {0}, rax",
+                "mov {1}, rbx",
+                "mov {2}, rcx",
+                "mov {3}, rdx",
+                "mov {4}, rsi",
+                "mov {5}, rdi",
+                "mov {6}, rbp",
+                "mov {7}, rsp",
+                "mov {8}, r8",
+                "mov {9}, r9",
+                "mov {10}, r10",
+                "mov {11}, r11",
+                "mov {12}, r12",
+                "mov {13}, r13",
+                "mov {14}, r14",
+                "mov {15}, r15",
+                "lea {16}, [rip]",
+                "pushf",
+                "pop {17}",
+                out(reg) context.rax,
+                out(reg) context.rbx,
+                out(reg) context.rcx,
+                out(reg) context.rdx,
+                out(reg) context.rsi,
+                out(reg) context.rdi,
+                out(reg) context.rbp,
+                out(reg) context.rsp,
+                out(reg) context.r8,
+                out(reg) context.r9,
+                out(reg) context.r10,
+                out(reg) context.r11,
+                out(reg) context.r12,
+                out(reg) context.r13,
+                out(reg) context.r14,
+                out(reg) context.r15,
+                out(reg) context.rip,
+                out(reg) context.rflags,
+            );
+        }
+
+        context
+    }
+}
@@ -0,0 +1,26 @@
+use crate::arch::x86_64::memory::allocation::stack_alloc::StackBounds;
+use x86_64::VirtAddr;
+
+mod switch;
+
+#[derive(Debug)]
+pub struct Thread {
+    id: ThreadId,
+    stack_ptr: Option<VirtAddr>,
+    stack_bounds: Option<StackBounds>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ThreadId(u64);
+
+impl ThreadId {
+    pub const fn as_u64(&self) -> u64 {
+        self.0
+    }
+
+    fn new() -> Self {
+        use core::sync::atomic::{AtomicU64, Ordering};
+        static NEXT_THREAD_ID: AtomicU64 = AtomicU64::new(1);
+        Self(NEXT_THREAD_ID.fetch_add(1, Ordering::Relaxed))
+    }
+}
@@ -0,0 +1,13 @@
+.intel_syntax noprefix
+
+switch_thread:
+    pushfq
+
+    mov rax, rsp
+    mov rsp, rdi
+
+    mov rdi, rax
+    call add_paused_thread
+
+    popfq
+    ret
@@ -0,0 +1 @@
+
@@ -1,23 +1,56 @@
 #![no_std]
 #![feature(abi_x86_interrupt)]
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc
+)]

 extern crate alloc;
-
+use crate::{arch::x86_64::memory::init_page_table, prelude::*};
+use arch::x86_64::memory::allocation::heap_alloc::init_heap;
+use arch::x86_64::memory::mapping;
 use core::arch::asm;
 use limine::BaseRevision;
-
-use libk::alloc::init_heap;
-use libk::prelude::*;
-
+use std::unwind;
+use std::unwind::eh_info::ELF;
 use x86_64::VirtAddr;
+use arch::x86_64::memory::allocation::page_alloc::FoundryOSFrameAllocator;
+use crate::arch::x86_64::cpu::apic::enable_apic;
+use crate::arch::x86_64::drivers::ascii::screensize_chars;
+use crate::arch::x86_64::drivers::framebuffer::display::screensize_px;
+use crate::arch::x86_64::memory::FRAME_ALLOCATOR;
+use crate::arch::x86_64::memory::units::MemoryUnits;

-mod arch;
+pub mod arch;
+mod panic;
+pub mod resources;
+#[allow(unused)] // We aren't using much of this right now.
+pub mod std;
+pub mod util;
+
+pub mod prelude {
+    pub use crate::{
+        eprint, eprintln, print, print_log, println, println_log, serial_print,
+        serial_println,
+        debug, debugln,
+        std::io::{_print, _print_log, _serial_write, _print_err},
+        std::debug::_debug,
+    };
+}

 /// Sets the base revision to the latest revision supported by the crate.
 /// See specification for further info.
-/// Be sure to mark all limine requests with #[used], otherwise they may be removed by the compiler.
+/// Be sure to mark all limine requests with #[used], otherwise they may be
+/// removed by the compiler.
 #[used]
-// The .requests section allows limine to find the requests faster and more safely.
+// The .requests section allows limine to find the requests faster and more
+// safely.
 #[unsafe(link_section = ".requests")]
 static BASE_REVISION: BaseRevision = BaseRevision::new();

@@ -33,53 +66,84 @@ pub fn hcf() -> ! {
        unsafe {
            #[cfg(target_arch = "x86_64")]
            asm!("hlt");
-            #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-            asm!("wfi");
-            #[cfg(target_arch = "loongarch64")]
-            asm!("idle 0");
        }
    }
 }

 pub fn boot() -> Result<(), &'static str> {
    if !BASE_REVISION.is_supported() {
-        return Err("base revision not supported");
+        return Err("Base revision not supported");
    }

-    use arch::x86_64::{gdt, interrupts, memmap, memory};
+    use arch::x86_64::{gdt, interrupts};

-    let memory_map = memmap::get_memory_map();
+    let memory_map = mapping::get_memory_map();

    print_log!("    Initialising Serial... ");
-    libk::io::serial::init()?;
-    println_log!("[Success]");
+    let res = arch::x86_64::drivers::serial::init();
+    serial_print!("    Initialising Serial... ");
+    if res.is_err() {
+        debugln!("[Not Detected]")
+    } else {
+        debugln!("[Success]");
+    }

-    print_log!("    Setting Up Global Descriptor Table... ");
+    debugln!("    Display...");
+    let dimensions = screensize_chars();
+    let dimensions2 = screensize_px();
+    debugln!("      => (px)    : {}x{} ", dimensions2.0, dimensions2.1);
+    debugln!("      => (chars) : {}x{} ", dimensions.0, dimensions.1);
+    debugln!("    [Success]");
+
+    debug!("    Setting Up Global Descriptor Table... ");
    gdt::init();
-    println_log!("[Success]");
+    debugln!("[Success]");

-    print_log!("    Setting Up Interrupt Descriptor Table... ");
+    debug!("    Setting Up Interrupt Descriptor Table... ");
    interrupts::init_idt();
-    println_log!("[Success]");
+    debugln!("[Success]");

-    print_log!("    Setting Up Page Table... ");
-    let mut frame_allocator = unsafe { memory::FoundryOSFrameAllocator::init(memory_map) };
-    println_log!("[Success]");
+    debugln!("    Initialising Memory Subsystem... ");
+    let physical_memory_offset = VirtAddr::new(*mapping::PHYSICAL_MEMORY_OFFSET);
+    init_page_table(physical_memory_offset);
+    FoundryOSFrameAllocator::init(memory_map);
+    let available_bytes = FRAME_ALLOCATOR.get().unwrap().lock().available_memory();
+    debugln!("      => Available Memory: {}", MemoryUnits::from_bytes(available_bytes as usize));

-    print_log!("    Initialising Memory Subsystem... ");
-    let physical_memory_offset = VirtAddr::new(*memmap::PHYSICAL_MEMORY_OFFSET);
-    let mut l4_table = unsafe { memory::init(physical_memory_offset) };
-    println_log!("[Success]");
+    debugln!("[Success]");

-    print_log!("    Initialising Heap... ");
-    if init_heap(&mut l4_table, &mut frame_allocator).is_err() {
+    debugln!("    Initialising Heap... ");
+    if unsafe { init_heap() }.is_err() {
        return Err("Failed to initialise heap: error");
    }
-    println_log!("[Success]");
+    debugln!("    [Success]");

-    print_log!("    Enabling Interrupts... ");
+    // debug!("    Enabling PICs... ");
+    // interrupts::enable_pic();
+    // debugln!("[Success]");
+
+    debug!("    Disabling PICs... ");
+    interrupts::disable_pic();
+    debugln!("[Success]");
+
+    debug!("    Initialising APIC... ");
+    enable_apic();
+    debugln!("[Success]");
+
+    debug!("    Enabling Interrupts... ");
    x86_64::instructions::interrupts::enable();
-    println_log!("[Success]");
+    debugln!("[Success]");
+
+    debug!("    Setting up stack unwinder, panic handler... ");
+    // Setup stack traces and proper panic handler. TODO: Handle panics
+    // differently if not initialised.
+    let eh_frame_ptr = ELF
+        .get_section_addr(".eh_frame_hdr")
+        .expect("Could not get `.eh_frame_hdr` address.");
+
+    let _eh_info =
+        unsafe { unwind::eh_info::EhInfo::from_hdr_ptr(eh_frame_ptr) };
+    debugln!("[Success]");

    Ok(())
 }
@@ -2,12 +2,11 @@
 #![no_main]

 extern crate alloc;
-
-use libk::{
-    io,
-    prelude::*,
-    scheduling::task::{Executor, Task},
-};
+use foundry_os::arch::x86_64::drivers::ascii::screensize_chars;
+use foundry_os::arch::x86_64::drivers::framebuffer::display::screensize_px;
+use foundry_os::arch::x86_64::processing::async_io::task::{Executor, Task};
+use foundry_os::util::shell::shell;
+use foundry_os::{println, println_log};

 #[unsafe(no_mangle)]
 extern "C" fn kmain() -> ! {
@@ -18,36 +17,13 @@ extern "C" fn kmain() -> ! {

    println_log!(" [ Kernel Initialised Successfully ] ");
    
-    let dimensions = io::ascii::screensize_chars();
-    let dimensions2 = io::ascii::screensize_px();
-
-    println!("Dimensions: {}x{} (px)", dimensions2.0, dimensions2.1);
-    println!("Dimensions: {}x{} (chars)", dimensions.0, dimensions.1);
-
-    println!(
-        "
-        $$$$$$$$\\                                  $$\\                     
-        $$  _____|                                 $$ |                    
-        $$ |    $$$$$$\\  $$\\   $$\\ $$$$$$$\\   $$$$$$$ | $$$$$$\\  $$\\   $$\\ 
-        $$$$$\\ $$  __$$\\ $$ |  $$ |$$  __$$\\ $$  __$$ |$$  __$$\\ $$ |  $$ |
-        $$  __|$$ /  $$ |$$ |  $$ |$$ |  $$ |$$ /  $$ |$$ |  \\__|$$ |  $$ |
-        $$ |   $$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |      $$ |  $$ |
-        $$ |   \\$$$$$$  |\\$$$$$$  |$$ |  $$ |\\$$$$$$$ |$$ |      \\$$$$$$$ |
-        \\__|    \\______/  \\______/ \\__|  \\__| \\_______|\\__|       \\____$$ |
-             $$$$$$\\   $$$$$$\\        $$\\    $$\\   $$\\           $$\\   $$ |
-            $$  __$$\\ $$  __$$\\       $$ |   $$ |$$$$ |          \\$$$$$$  |
-            $$ /  $$ |$$ /  \\__|      $$ |   $$ |\\_$$ |           \\______/ 
-            $$ |  $$ |\\$$$$$$\\        \\$$\\  $$  |  $$ |                  
-            $$ |  $$ | \\____$$\\        \\$$\\$$  /   $$ |                  
-            $$ |  $$ |$$\\   $$ |        \\$$$  /    $$ |                  
-             $$$$$$  |\\$$$$$$  |         \\$  /   $$$$$$\\                 
-             \\______/  \\______/           \\_/    \\______|                              
-    "
-    );
+    // println!("TESTING :: Allocation");
+    // let somevec = vec![0; 1_000_000];
+    // println!("{:?}", somevec);
+    // println!("{}", somevec.len());
+    // println!("PASSED!");

    let mut executor = Executor::new();
-    executor.spawn(Task::new(io::keyboard::print_keypresses()));
-    executor.try_run();
-
-    loop {}
+    executor.spawn(Task::new(shell()));
+    executor.run()
 }
@@ -0,0 +1,75 @@
+// //! Stack-unwinding code for the Kernel. This is a modified version of https://github.com/nbdd0121/unwinding/blob/trunk/src/panic_handler.rs
+// //! which does not support environment variables for obvious reasons, however we
+// //! may implement a cmdline similar to Linux in the near future.
+
+// #![expect(
+//     clippy::empty_loop,
+//     reason = "We don't yet have working power management. This is OK for now."
+// )]
+// use crate::prelude::*;
+// use alloc::boxed::Box;
+// use core::any::Any;
+// use core::cell::Cell;
+// use core::ffi::c_void;
+// use core::panic::{Location, PanicInfo};
+// use unwinding::abi::*;
+// use unwinding::panic::begin_panic;
+
+// #[thread_local]
+// static PANIC_COUNT: Cell<usize> = Cell::new(0);
+
+// #[link(name = "c")]
+// unsafe extern "C" {}
+
+// fn stack_trace() {
+//     struct CallbackData {
+//         counter: usize,
+//     }
+
+//     extern "C" fn callback(
+//         unwind_ctx: &UnwindContext<'_>,
+//         arg: *mut c_void,
+//     ) -> UnwindReasonCode {
+//         let data = unsafe { &mut *(arg as *mut CallbackData) };
+//         data.counter += 1;
+//         eprintln!(
+//             "{:4}:{:#19x} - <unknown>",
+//             data.counter,
+//             _Unwind_GetIP(unwind_ctx)
+//         );
+//         UnwindReasonCode::NO_REASON
+//     }
+//     let mut data = CallbackData { counter: 0 };
+//     _Unwind_Backtrace(callback, &mut data as *mut _ as _);
+// }
+
+// fn do_panic(msg: Box<dyn Any + Send>) -> ! {
+//     if PANIC_COUNT.get() >= 1 {
+//         stack_trace();
+//         eprintln!("Thread panicked while processing panic. aborting.");
+//         loop {}
+//     }
+
+//     PANIC_COUNT.set(1);
+//     stack_trace();
+
+//     let code = begin_panic(Box::new(msg));
+//     eprintln!("Failed to initiate panic: error {}", code.0);
+
+//     loop {}
+// }
+
+// #[panic_handler]
+// fn panic(info: &PanicInfo<'_>) -> ! {
+//     eprintln!("{}", info);
+
+//     struct NoPayload;
+//     do_panic(Box::new(NoPayload))
+// }
+
+// #[track_caller]
+// #[expect(unused, reason = "May still be used in the future.")]
+// pub fn panic_any<M: 'static + Any + Send>(msg: M) -> ! {
+//     eprintln!("Panicked at {}", Location::caller());
+//     do_panic(Box::new(msg))
+// }
@@ -0,0 +1,48 @@
+use libm::include_font;
+pub const FONT_SPLEEN_8X16: Font =
+    Font::new(include_font!("../../../resources/font/spleen-8x16.psf"));
+
+pub const FONT_CP850_8X16: Font =
+    Font::new(include_font!("../../../resources/font/cp850-8x16.psf"));
+
+// 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]) -> Self {
+        Self {
+            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
+    }
+}
+
+impl Default for Font {
+    fn default() -> Self {
+        FONT_CP850_8X16
+    }
+}
@@ -0,0 +1 @@
+pub mod font;
@@ -0,0 +1,22 @@
+use alloc::string::String;
+use alloc::vec::Vec;
+
+pub mod frame;
+pub mod render;
+pub mod window;
+
+pub trait Application {
+    type Output;
+
+    fn run(
+        &mut self,
+        args: Vec<String>,
+    ) -> impl Future<Output = Result<Self::Output, Error>> + Send;
+}
+
+#[derive(Debug)]
+pub enum Error {
+    UnknownCommand(String),
+    ApplicationFailed(String),
+    KernelError(String),
+}
@@ -0,0 +1,48 @@
+use super::{render::RenderError, window::Window};
+use crate::arch::x86_64::drivers::framebuffer::colour::Colour;
+use crate::std::maths::geometry::Vec2;
+use alloc::{vec, vec::Vec};
+
+pub struct Frame<'f> {
+    data: Vec<Vec<Colour>>,
+    window: &'f Window,
+}
+
+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<&[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()
+    }
+}
@@ -0,0 +1,22 @@
+use crate::arch::x86_64::drivers::framebuffer::colour::Colour;
+use core::fmt::Display;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RenderError {
+    Generic,
+}
+
+impl Display for RenderError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Generic => write!(f, "Generic render error"),
+        }
+    }
+}
+
+impl core::error::Error for RenderError {}
+
+pub struct ColouredChar {
+    ch: u8,
+    colour: Colour,
+}
@@ -0,0 +1,93 @@
+use super::render::RenderError;
+use crate::arch::x86_64::drivers::framebuffer::colour::Colour;
+use crate::arch::x86_64::drivers::framebuffer::display::FRAMEBUFFER_WRITER;
+use crate::std::maths::geometry::Vec2;
+use alloc::string::String;
+
+pub struct Window {
+    dimensions: Vec2<usize>,
+    position: Vec2<usize>,
+    bordered: bool,
+    opened: bool,
+    title: String,
+}
+
+impl Window {
+    pub const fn new() -> Self {
+        Self {
+            dimensions: Vec2::new(0, 0),
+            position: Vec2::new(0, 0),
+            bordered: true,
+            opened: false,
+            title: String::new(),
+        }
+    }
+
+    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 {
+        self.bordered
+    }
+
+    pub const fn is_open(&self) -> bool {
+        self.opened
+    }
+
+    pub const fn open(&mut self) {
+        self.opened = true;
+    }
+
+    pub const fn close(&mut self) {
+        self.opened = false;
+    }
+
+    // some basic getters and setters for utility.
+    pub fn title(&'static self) -> &'static str {
+        self.title.as_str()
+    }
+
+    pub const fn dimensions(&self) -> Vec2<usize> {
+        self.dimensions
+    }
+
+    pub const fn position(&self) -> Vec2<usize> {
+        self.position
+    }
+
+    pub fn set_title(&mut self, title: String) {
+        self.title = title;
+    }
+
+    pub fn move_window(&mut self, offset: Vec2<usize>) {
+        self.position += offset;
+    }
+
+    pub const fn set_position(&mut self, position: Vec2<usize>) {
+        self.position = position;
+    }
+
+    pub const fn set_dimensions(&mut self, dimensions: Vec2<usize>) {
+        self.dimensions = dimensions;
+    }
+}
+
+impl Default for Window {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        if self.opened {
+            self.close();
+        }
+    }
+}
@@ -0,0 +1,61 @@
+use super::{
+    application::{frame::Frame, render::RenderError},
+    maths::geometry::Vec2,
+};
+use crate::arch::x86_64::drivers::framebuffer::colour::Colour;
+use crate::resources::font::Font;
+
+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(())
+    }
+}
@@ -0,0 +1,22 @@
+use core::fmt;
+use x86_64::instructions::interrupts;
+use crate::prelude::{_print_log, _serial_write};
+
+#[macro_export]
+macro_rules! debugln {
+	() => ($crate::print_log!("\n"));
+	($($arg:tt)*) => ($crate::debug!("{}\n", format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! debug {
+	($($arg:tt)*) => ($crate::prelude::_debug(format_args!($($arg)*)));
+}
+
+pub fn _debug(args: fmt::Arguments) {
+    interrupts::without_interrupts(|| {
+        _print_log(args);
+        _serial_write(args);
+    });
+}
+
@@ -0,0 +1,114 @@
+//! Basic ELF parsing functionality using the `elf` crate.
+//!
+//! This may be extended in the future to support loading programs, however we
+//! currently use this for getting the sizes of sections in our kernel ELF at
+//! runtime.
+//!
+//! This is used for implementing stacktraces in std::unwind.
+//!
+//! # TODO
+//!
+//! * Add support for loading binary programs (this should probably be written
+//!   in a different module)
+
+use alloc::format;
+use elf::{
+    ElfBytes, ParseError,
+    endian::LittleEndian,
+    parse::{ParseAt, ParsingTable},
+    section::{SectionHeader, SectionHeaderTable},
+    string_table::StringTable,
+};
+use limine::request::KernelFileRequest;
+
+use crate::prelude::*;
+
+#[cfg(target_arch = "x86_64")]
+/// The length of the ELF header in bytes.
+pub const ELF_HEADER_LEN: usize = 64;
+
+/// Information about our own ELF file to make ELF parsing easier, such as the
+/// length of the file and a pointer to the contents.
+#[used]
+pub static KERNEL_FILE_REQUEST: KernelFileRequest = KernelFileRequest::new();
+
+/// A list of errors that may occur when parsing ELF files.
+#[derive(Debug)]
+pub enum ElfError {
+    /// Returned if a section did not exist in [ElfReader::get_section_size].
+    SectionNotExists,
+    /// Parse errors returned by the `elf` crate.
+    OtherParseError(elf::ParseError),
+}
+
+impl From<elf::ParseError> for ElfError {
+    fn from(err: elf::ParseError) -> Self {
+        Self::OtherParseError(err)
+    }
+}
+
+pub struct ElfReader {
+    /// Structure returned by the `elf` crate having parsed the ELF header.
+    elf: ElfBytes<'static, LittleEndian>,
+}
+
+impl ElfReader {
+    /// Parses the ELF file for the kernel, this uses data from Limine's Kernel
+    /// File Request to get a slice over the whole executable file.
+    ///
+    /// # Safety
+    ///
+    /// Assumes a properly formed ELF file, and that Limine returns a correct
+    /// pointer to the start of the file as well as a valid length in bytes.
+    ///
+    /// Both of these should be satisfied, but this function is marked unsafe
+    /// just in case, because we are derefererencing arbitrary pointers.
+    pub unsafe fn new() -> Result<Self, ElfError> {
+        let response = KERNEL_FILE_REQUEST
+            .get_response()
+            .expect("Didn't get the kernel file from Limine. That's odd.");
+
+        // We fetch these from Limine and use them to parse our own ELF file.
+        let file = response.file();
+        let file_start_ptr = file.addr();
+        let file_size = file.size() as usize;
+
+        // Safety: This slice should contain the whole bytes of the ELF file.
+        let elf_hdr_slice =
+            unsafe { core::slice::from_raw_parts(file_start_ptr, file_size) };
+
+        let elf: ElfBytes<'static, LittleEndian> =
+            elf::ElfBytes::minimal_parse(elf_hdr_slice)?;
+
+        Ok(Self { elf })
+    }
+
+    /// Gets the section size of `section_name` in bytes.
+    pub fn get_section_size(
+        &self,
+        section_name: &'static str,
+    ) -> Result<u64, ElfError> {
+        Ok(self.get_section_header(section_name)?.sh_size)
+    }
+
+    /// Gets the start address of the section `section_name` in memory.
+    pub fn get_section_addr(
+        &self,
+        section_name: &'static str,
+    ) -> Result<*const u8, ElfError> {
+        Ok(self.get_section_header(section_name)?.sh_addr as *const u8)
+    }
+
+    /// Gets the section header of `section_name`.
+    pub fn get_section_header(
+        &self,
+        section_name: &'static str,
+    ) -> Result<SectionHeader, ElfError> {
+        let section_hdr = self
+            .elf
+            .section_header_by_name(section_name)
+            .map_err(|_e| ElfError::SectionNotExists)?;
+
+        section_hdr.ok_or(ElfError::SectionNotExists)
+    }
+}
@@ -0,0 +1,6 @@
+pub use crate::arch::x86_64::drivers::{
+    ascii::{_print, _print_err, _print_log},
+    serial::_serial_write,
+};
+
+pub mod stdin;
@@ -0,0 +1,75 @@
+use crate::arch::x86_64::drivers::{
+    ascii::WRITER,
+    keyboard::{KeyStroke, get_keystroke_async, get_keystroke_optional},
+};
+use alloc::string::String;
+
+/// Reads a line of input from standard input asynchronously, returning a
+/// `String` containing the input line. Does not include the newline
+/// character at the end of the line.
+///
+/// If the user presses the abort key (usually Ctrl+C), the returned string
+/// will be empty.
+pub async fn read_line() -> String {
+    let mut writer = WRITER.lock();
+
+    let mut buff = String::new();
+    loop {
+        match get_keystroke_async().await {
+            KeyStroke::Char(c) => match c {
+                '\n' => {
+                    writer.write_glyph(c as u8);
+                    return buff;
+                }
+                '\r' => {
+                    writer.write_glyph(c as u8);
+                    return buff;
+                }
+                '\x08' => {
+                    if !buff.is_empty() {
+                        buff.pop();
+                        writer.backspace();
+                    }
+                }
+
+                c => {
+                    writer.write_glyph(c as u8);
+                    buff.push(c)
+                }
+            },
+            KeyStroke::Enter => {
+                writer.write_glyph(b'\n');
+                return buff;
+            }
+            KeyStroke::Backspace => {
+                if !buff.is_empty() {
+                    buff.pop();
+                    writer.backspace();
+                }
+            }
+            _ => continue,
+        }
+    }
+}
+
+/// Reads a character from standard input and blocks the current task until
+/// a character is available.
+///
+/// # Note
+///
+/// This function is not yet implemented.
+pub async fn async_keystroke() -> KeyStroke {
+    get_keystroke_async().await
+}
+
+/// Attempt to read a character from standard input without blocking the
+/// current task.
+///
+/// If no character is available, returns `None`.
+///
+/// # Note
+///
+/// This function is not yet implemented.
+pub fn keystroke() -> Option<KeyStroke> {
+    get_keystroke_optional()
+}
@@ -0,0 +1,79 @@
+use core::ops::{AddAssign, DivAssign, MulAssign, SubAssign};
+
+pub trait Coordinate:
+    Copy + Clone + PartialEq + AddAssign + MulAssign + SubAssign + DivAssign
+{
+}
+
+impl Coordinate for usize {}
+impl Coordinate for isize {}
+impl Coordinate for u8 {}
+impl Coordinate for i8 {}
+impl Coordinate for u16 {}
+impl Coordinate for i16 {}
+impl Coordinate for u32 {}
+impl Coordinate for i32 {}
+impl Coordinate for u64 {}
+impl Coordinate for i64 {}
+impl Coordinate for u128 {}
+impl Coordinate for i128 {}
+impl Coordinate for f32 {}
+impl Coordinate for f64 {}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Debug)]
+pub struct Vec2<T: Coordinate> {
+    x: T,
+    y: T,
+}
+
+impl<T: Coordinate> Vec2<T> {
+    pub const fn new(x: T, y: T) -> Self {
+        Self { x, y }
+    }
+
+    pub fn into<S: Coordinate + From<T>>(&self) -> Vec2<S> {
+        Vec2::new(self.x.into(), self.y.into())
+    }
+
+    pub const fn x(&self) -> T {
+        self.x
+    }
+
+    pub const fn y(&self) -> T {
+        self.y
+    }
+}
+
+impl<T: Coordinate> AddAssign for Vec2<T> {
+    fn add_assign(&mut self, rhs: Self) {
+        self.x += rhs.x;
+        self.y += rhs.y;
+    }
+}
+
+impl<T: Coordinate> SubAssign for Vec2<T> {
+    fn sub_assign(&mut self, rhs: Self) {
+        self.x -= rhs.x;
+        self.y -= rhs.y;
+    }
+}
+
+impl<T: Coordinate> MulAssign<T> for Vec2<T> {
+    fn mul_assign(&mut self, rhs: T) {
+        self.x *= rhs;
+        self.y *= rhs;
+    }
+}
+
+impl<T: Coordinate> DivAssign<T> for Vec2<T> {
+    fn div_assign(&mut self, rhs: T) {
+        self.x /= rhs;
+        self.y /= rhs;
+    }
+}
+
+impl<T: Coordinate> From<Vec2<T>> for (T, T) {
+    fn from(value: Vec2<T>) -> Self {
+        (value.x, value.y)
+    }
+}
@@ -0,0 +1 @@
+pub mod geometry;
@@ -0,0 +1,7 @@
+pub mod application;
+pub mod ascii;
+pub mod elf;
+pub mod io;
+pub mod maths;
+pub mod unwind;
+pub mod debug;
@@ -0,0 +1,135 @@
+//! Contains a [EhInfo] struct that contains the parsed DWARF exception header
+//! data from the ELF .eh_frame and .eh_frame_hdr sections.
+
+use alloc::{boxed::Box, slice};
+use gimli::{
+    BaseAddresses, EhFrame, EhFrameHdr, EhHdrTable, EndianSlice, LittleEndian,
+    ParsedEhFrameHdr,
+};
+use spin::Lazy;
+
+use crate::{println_log, std::elf::ElfReader};
+
+/// Contains useful data parsed from the ELF file in question. In the kernel
+/// this will be our own process.
+///
+/// We use this to implement stack traces and potential unwinding.
+///
+/// # Sources
+///
+/// This code is reproduced from [lesenchal.fr](https://lesenechal.fr/en/linux/unwinding-the-stack-the-hard-way#h5.1-parsing-eh_frame-and-eh_frame_hdr-with-gimli)
+/// and will later be extended as required.
+pub struct EhInfo {
+    /// A set of base addresses used for relative addressing.
+    base_addrs: BaseAddresses,
+    /// The parsed `.eh_frame_hdr` section.
+    hdr: &'static ParsedEhFrameHdr<EndianSlice<'static, LittleEndian>>,
+    /// The lookup table in the parsed `.eh_frame_hdr` section.
+    /// This is a binary search table, it is optional but should be present as
+    /// we are linking with LLD(?) \[needs citation].
+    hdr_table: EhHdrTable<'static, EndianSlice<'static, LittleEndian>>,
+    /// The parsed `.eh_frame` containing the CFIs (call frame information).
+    eh_frame: EhFrame<EndianSlice<'static, LittleEndian>>,
+}
+
+/// Stores the [ElfReader] struct for this ELF file.
+pub static ELF: Lazy<ElfReader> =
+    Lazy::new(|| unsafe { ElfReader::new().unwrap() });
+
+impl EhInfo {
+    /// Gets the `.eh_frame_hdr` size in bytes.
+    ///
+    /// # Panics
+    ///
+    /// If we can't get the size of `.eh_frame_hdr`.
+    pub fn eh_frame_hdr_size() -> usize {
+        ELF.get_section_size(".eh_frame_hdr")
+            .expect("Cannot get size of `.eh_frame_hdr`.") as usize
+    }
+
+    /// Gets the `.eh_frame` size in bytes.
+    ///
+    /// # Panics
+    ///
+    /// If we can't get the size of `.eh_frame`.
+    pub fn eh_frame_size() -> usize {
+        ELF.get_section_size(".eh_frame")
+            .expect("Cannot get size of `.eh_frame`.") as usize
+    }
+
+    /// Constructs a [EhInfo] from the base address. This is defined for a
+    /// symbol in the linker script so we can initialise stack traces and -- in
+    /// the future -- unwinding.
+    ///
+    /// # Safety
+    ///
+    /// Assumes the `.eh_frame_hdr` pointer to be valid, as well as the sizes of
+    /// the containing sections. These sizes are computed using [ElfReader].
+    ///
+    /// # Panics
+    ///
+    /// This function panics if Gimli throws parsing errors -- for example due
+    /// to a malformed or corrupted binary, or because this is called in
+    /// release-mode, or on a stripped binary.
+    ///
+    /// # TODOs
+    ///
+    /// * Support external System.map files which list symbols and contain
+    ///   debugging information.
+    pub unsafe fn from_hdr_ptr(eh_frame_hdr: *const u8) -> Self {
+        let mut base_addrs = BaseAddresses::default();
+        // We add the `.eh_frame_hdr` pointer to the set of base addresses which
+        // are used by Gimli for later parsing. This may be used to compute a
+        // pointer to `.eh_frame`.
+        base_addrs = base_addrs.set_eh_frame_hdr(eh_frame_hdr as u64);
+
+        // Leaking the Box gives us a reference with `'static` lifetime to use
+        // in Self.
+        let hdr = Box::leak(Box::new(
+            // We need to construct a slice as input for `EhFrameHdr::new`.
+            // This is sound if data pointer and length are known to be
+            // correct.
+            EhFrameHdr::new(
+                unsafe {
+                    core::slice::from_raw_parts(
+                        eh_frame_hdr,
+                        Self::eh_frame_hdr_size(),
+                    )
+                },
+                LittleEndian,
+            ) // Parse the header using the base address we provided (virtual
+            // memory). Address size is how many bytes make an
+            // address (64 bits).
+            .parse(&base_addrs, 8)
+            .expect(
+                "Could not parse `.eh_frame_hdr`. The ELF must be malformed.",
+            ),
+        ));
+
+        // Create a pointer to the `.eh_frame` ready to parse it.
+        let eh_frame = match hdr.eh_frame_ptr() {
+            gimli::Pointer::Direct(addr) => addr as *mut u8,
+            _ => unimplemented!(),
+        };
+
+        // Add the `.eh_frame` address for addresses relative to this section.
+        base_addrs = base_addrs.set_eh_frame(eh_frame as u64);
+
+        // Finally parse the `.eh_frame` section of our ELF.
+        let eh_frame = EhFrame::new(
+            unsafe {
+                core::slice::from_raw_parts(eh_frame, Self::eh_frame_size())
+            },
+            LittleEndian,
+        );
+
+        Self {
+            base_addrs,
+            hdr,
+            hdr_table: hdr.table().expect(
+                "The CFI binary search table was not present in this binary, oh dear.",
+            ),
+            eh_frame,
+        }
+    }
+}
@@ -0,0 +1 @@
+pub mod eh_info;
@@ -0,0 +1,248 @@
+use crate::arch::x86_64::drivers::keyboard::{KeyStroke, get_keystroke_async};
+use crate::resources::font::Font;
+use crate::serial_print;
+use crate::serial_println;
+use crate::std::application::{
+    Application, Error, frame::Frame, render::RenderError, window::Window,
+};
+use crate::std::ascii::Writer;
+use crate::std::maths::geometry::Vec2;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+
+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 font = Font::default();
+        let writer = Writer::new(&font);
+
+        let (width, height) = writer.font_size().into();
+
+        let mut col = 0;
+        let mut line = 0;
+        let mut scale = 1;
+
+        for ch in self.buffer.chars() {
+            if ch == '\n' {
+                line += scale;
+                col = 0;
+                scale = 1;
+                continue;
+            }
+
+            if width * (col + 1) > frame.dimensions().x() - 2 * Self::PADDING {
+                line += scale;
+                col = 0;
+            }
+
+            writer.render_glyph(
+                &mut frame,
+                Vec2::new(
+                    col * width + Self::PADDING,
+                    line * height + Self::PADDING,
+                ),
+                ch as u8,
+                scale,
+            )?;
+            col += scale;
+        }
+
+        writer
+            .render_glyph(
+                &mut frame,
+                Vec2::new(
+                    self.cursor_col * width + Self::PADDING,
+                    self.cursor_line * height + Self::PADDING,
+                ),
+                b'_',
+                scale,
+            )
+            .expect("TODO: panic message");
+
+        Ok(frame)
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn get_lines(&self) -> Vec<&str> {
+        self.buffer.split('\n').collect::<Vec<&str>>()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn move_cursor(&mut self, x: i32, y: i32) {
+        self.cursor_line = self
+            .cursor_line
+            .checked_add_signed(y as isize)
+            .unwrap_or(self.cursor_line);
+        self.cursor_col = self
+            .cursor_col
+            .checked_add_signed(x as isize)
+            .unwrap_or(self.cursor_col);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn delete_char(&mut self) {
+        let i = self.get_char_idx();
+        self.buffer.remove(i);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn insert_char(&mut self, c: char) {
+        let i = self.get_char_idx();
+        self.buffer.insert(i, c);
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn splitline(&mut self) {
+        let i = self.get_char_idx();
+        self.buffer.insert(i, '\n');
+    }
+
+    fn get_char_idx(&self) -> usize {
+        let frame = Frame::new(&self.window);
+        let font = Font::default();
+        let writer = Writer::new(&font);
+        let (width, _height) = writer.font_size().into();
+
+        let mut col = 0;
+        let mut line = 0;
+        let mut scale = 1;
+
+        for (i, ch) in self.buffer.chars().enumerate() {
+            if ch == '\n' {
+                line += scale;
+                col = 0;
+                scale = 1;
+                continue;
+            }
+
+            if width * (col + 1) > frame.dimensions().x() - 2 * Self::PADDING {
+                line += scale;
+                col = 0;
+            }
+
+            if col == self.cursor_col && line == self.cursor_line {
+                return i;
+            }
+
+            col += scale;
+        }
+
+        0
+    }
+}
+
+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 => {
+                            serial_println!("Left\n");
+                            self.move_cursor(-1, 0);
+                        }
+                        KeyStroke::Right => {
+                            serial_println!("Right\n");
+                            self.move_cursor(1, 0);
+                        }
+                        KeyStroke::Up => {
+                            serial_println!("Up\n");
+                            self.move_cursor(0, -1);
+                        }
+                        KeyStroke::Down => {
+                            serial_println!("Down\n");
+                            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"),
+        }
+    }
+}
@@ -0,0 +1,2 @@
+pub mod editor;
+pub mod shell;
@@ -0,0 +1,49 @@
+// use x86_64::registers::rflags::read;
+
+use crate::arch::x86_64::drivers::ascii::clear_screen;
+use crate::prelude::*;
+use crate::std::application::Application;
+use crate::std::io::stdin::read_line;
+use crate::util::editor::Editor;
+use alloc::vec::Vec;
+
+static FETCH: &str = "
+        $$$$$$$$\\                                  $$\\                     
+        $$  _____|                                 $$ |                    
+        $$ |    $$$$$$\\  $$\\   $$\\ $$$$$$$\\   $$$$$$$ | $$$$$$\\  $$\\   $$\\ 
+        $$$$$\\ $$  __$$\\ $$ |  $$ |$$  __$$\\ $$  __$$ |$$  __$$\\ $$ |  $$ |
+        $$  __|$$ /  $$ |$$ |  $$ |$$ |  $$ |$$ /  $$ |$$ |  \\__|$$ |  $$ |
+        $$ |   $$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |      $$ |  $$ |
+        $$ |   \\$$$$$$  |\\$$$$$$  |$$ |  $$ |\\$$$$$$$ |$$ |      \\$$$$$$$ |
+        \\__|    \\______/  \\______/ \\__|  \\__| \\_______|\\__|       \\____$$ |
+             $$$$$$\\   $$$$$$\\        $$\\    $$\\   $$\\           $$\\   $$ |
+            $$  __$$\\ $$  __$$\\       $$ |   $$ |$$$$ |          \\$$$$$$  |
+            $$ /  $$ |$$ /  \\__|      $$ |   $$ |\\_$$ |           \\______/ 
+            $$ |  $$ |\\$$$$$$\\        \\$$\\  $$  |  $$ |                  
+            $$ |  $$ | \\____$$\\        \\$$\\$$  /   $$ |                  
+            $$ |  $$ |$$\\   $$ |        \\$$$  /    $$ |                  
+             $$$$$$  |\\$$$$$$  |         \\$  /   $$$$$$\\                 
+             \\______/  \\______/           \\_/    \\______|                              
+";
+
+pub async fn shell() {
+    println!("{}", FETCH);
+
+    loop {
+        print!(" Shell> ");
+        let line = read_line().await;
+        match line.as_str() {
+            "fetch" => {
+                println!("{}", FETCH);
+            }
+            "editor" => {
+                let mut editor = Editor::new();
+                editor.run(Vec::new()).await.unwrap();
+            }
+            "clear" => clear_screen(),
+            _ => {
+                println!("Unknown command: {}", line);
+            }
+        }
+    }
+}
@@ -1,21 +0,0 @@
-[package]
-name = "libk"
-publish = ["gitea"]
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-description = "A library crate used to write the kernel for Foundry OS."
-
-[dependencies]
-limine = "0.3.1"
-x86_64 = "0.15.2"
-crossbeam = { version = "0.8.4", default-features = false, features = [
-    "alloc",
-    "crossbeam-queue",
-] }
-pc-keyboard = "0.8.0"
-spin = "0.9.8"
-futures-util = { version = "0.3.31", default-features = false, features = [
-    "alloc",
-] }
-linked_list_allocator = "0.10.5"
@@ -1,24 +0,0 @@
-# libk is for the code that did not make the kernel*
-
-\*crate, lol.
-
-libk is an attempt to move away from the godforsaken git submodules that plagued our forefathers. Now we have a crate containing a bunch of code that didn't quite make the core kernel crate, which should be:
-
-* simpler to maintain
-* has a catchier name
-* less fighting with Cargo.toml manifests
-
-## TODO:
-
-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)
-
-The rationale behind this is that we want some sort of debug log/tracing support so we aren't just printf debugging forever.
-
-## Authors
-
-Again, write your name below if you like:
-
-* @zxq5 (wrote most of the libraries as of 23/02/25)
-* @nullndvoid (made this lushious library crate)
@@ -1,3 +0,0 @@
-pub mod allocator;
-
-pub use self::allocator::init_heap;
@@ -1,45 +0,0 @@
-use linked_list_allocator::LockedHeap;
-use x86_64::{
-    structures::paging::{
-        mapper::MapToError, FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB,
-    },
-    VirtAddr,
-};
-
-/// We are currently using a linked list heap allocator which uses our underlying page allocator.
-pub type FoundryAllocator = LockedHeap;
-
-#[global_allocator]
-/// This is now Rust's global allocator, so we can use stuff requiring heap allocations.
-static ALLOCATOR: FoundryAllocator = FoundryAllocator::empty();
-
-pub const HEAP_START: usize = 0x4444_4444_0000;
-pub const HEAP_SIZE: usize = 1000 * 1024;
-
-/// Sets up the heap using the backing page frame allocator.
-pub fn init_heap(
-    mapper: &mut impl Mapper<Size4KiB>,
-    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
-) -> Result<(), MapToError<Size4KiB>> {
-    let range = {
-        let heap_start = VirtAddr::new(HEAP_START as u64);
-        let heap_end = heap_start + HEAP_SIZE as u64 - 1u64;
-        let heap_start_page = Page::<Size4KiB>::containing_address(heap_start);
-        let heap_end_page = Page::<Size4KiB>::containing_address(heap_end);
-        Page::range_inclusive(heap_start_page, heap_end_page)
-    };
-
-    for page in range {
-        let frame = frame_allocator
-            .allocate_frame()
-            .ok_or(MapToError::FrameAllocationFailed)?;
-        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-        unsafe { mapper.map_to(page, frame, flags, frame_allocator)?.flush() };
-    }
-
-    unsafe {
-        ALLOCATOR.lock().init(HEAP_START as *mut u8, HEAP_SIZE);
-    }
-
-    Ok(())
-}
@@ -1,17 +0,0 @@
-pub mod ascii;
-pub mod framebuffer;
-pub mod keyboard;
-pub mod port;
-pub mod serial;
-
-// Re-exported macro definitions.
-
-pub use crate::print;
-pub use crate::print_log;
-pub use crate::printerr;
-pub use crate::println;
-pub use crate::println_log;
-pub use crate::printlnerr;
-
-pub use crate::serial_print;
-pub use crate::serial_println;
@@ -1,578 +0,0 @@
-pub static FONT: [u8; 288 * 16] = [
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 0
-    0x00, 0x00, 0x3f, 0x33, 0x3f, 0x30, 0x30, 0x30, 0x30, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00,
-    0x00, // 1
-    0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0x81, 0xbd, 0x99, 0x81, 0x81, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 2
-    0x00, 0x00, 0x7e, 0xff, 0xdb, 0xff, 0xff, 0xc3, 0xe7, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 3
-    0x00, 0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00,
-    0x00, // 4
-    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 5
-    0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0xe7, 0xe7, 0xe7, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 6
-    0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x7e, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 7
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 8
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, // 9
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 10
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd, 0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff,
-    0xff, // 11
-    0x00, 0x00, 0x1e, 0x0e, 0x1a, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00,
-    0x00, // 12
-    0x00, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 13
-    0x00, 0x00, 0x7f, 0x63, 0x7f, 0x63, 0x63, 0x63, 0x63, 0x67, 0xe7, 0xe6, 0xc0, 0x00, 0x00,
-    0x00, // 14
-    0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 15
-    0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfe, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00,
-    0x00, // 16
-    0x00, 0x02, 0x06, 0x0e, 0x1e, 0x3e, 0xfe, 0x3e, 0x1e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00,
-    0x00, // 17
-    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 18
-    0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00,
-    0x00, // 19
-    0x00, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00,
-    0x00, // 20
-    0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00,
-    0x00, // 21
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 22
-    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 23
-    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 24
-    0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 25
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 26
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 27
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 28
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x6c, 0xfe, 0x6c, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 29
-    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 30
-    0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c, 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 31
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 32
-    0x00, 0x00, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 33
-    0x00, 0x66, 0x66, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 34
-    0x00, 0x00, 0x00, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x00, 0x00, 0x00,
-    0x00, // 35
-    0x18, 0x18, 0x7c, 0xc6, 0xc2, 0xc0, 0x7c, 0x06, 0x06, 0x86, 0xc6, 0x7c, 0x18, 0x18, 0x00,
-    0x00, // 36
-    0x00, 0x00, 0x00, 0x00, 0xc2, 0xc6, 0x0c, 0x18, 0x30, 0x60, 0xc6, 0x86, 0x00, 0x00, 0x00,
-    0x00, // 37
-    0x00, 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x76, 0xdc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 38
-    0x00, 0x30, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 39
-    0x00, 0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00,
-    0x00, // 40
-    0x00, 0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x30, 0x00, 0x00, 0x00,
-    0x00, // 41
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 42
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 43
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00,
-    0x00, // 44
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 45
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 46
-    0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80, 0x00, 0x00, 0x00,
-    0x00, // 47
-    0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xd6, 0xd6, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00,
-    0x00, // 48
-    0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 49
-    0x00, 0x00, 0x7c, 0xc6, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc6, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 50
-    0x00, 0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 51
-    0x00, 0x00, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc, 0xfe, 0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x00, 0x00,
-    0x00, // 52
-    0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 53
-    0x00, 0x00, 0x38, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 54
-    0x00, 0x00, 0xfe, 0xc6, 0x06, 0x06, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00,
-    0x00, // 55
-    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 56
-    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x0c, 0x78, 0x00, 0x00, 0x00,
-    0x00, // 57
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 58
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00,
-    0x00, // 59
-    0x00, 0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x00, 0x00, 0x00,
-    0x00, // 60
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 61
-    0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00,
-    0x00, // 62
-    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x0c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 63
-    0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xde, 0xde, 0xde, 0xdc, 0xc0, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 64
-    0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 65
-    0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x66, 0x66, 0x66, 0x66, 0xfc, 0x00, 0x00, 0x00,
-    0x00, // 66
-    0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xc0, 0xc0, 0xc2, 0x66, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 67
-    0x00, 0x00, 0xf8, 0x6c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6c, 0xf8, 0x00, 0x00, 0x00,
-    0x00, // 68
-    0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x62, 0x66, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 69
-    0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00,
-    0x00, // 70
-    0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xde, 0xc6, 0xc6, 0x66, 0x3a, 0x00, 0x00, 0x00,
-    0x00, // 71
-    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 72
-    0x00, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 73
-    0x00, 0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00,
-    0x00, // 74
-    0x00, 0x00, 0xe6, 0x66, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00,
-    0x00, // 75
-    0x00, 0x00, 0xf0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x62, 0x66, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 76
-    0x00, 0x00, 0xc6, 0xee, 0xfe, 0xfe, 0xd6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 77
-    0x00, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 78
-    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 79
-    0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00,
-    0x00, // 80
-    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xde, 0x7c, 0x0c, 0x0e, 0x00,
-    0x00, // 81
-    0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x6c, 0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00,
-    0x00, // 82
-    0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x60, 0x38, 0x0c, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 83
-    0x00, 0x00, 0x7e, 0x7e, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 84
-    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 85
-    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00,
-    0x00, // 86
-    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xfe, 0xee, 0x6c, 0x00, 0x00, 0x00,
-    0x00, // 87
-    0x00, 0x00, 0xc6, 0xc6, 0x6c, 0x7c, 0x38, 0x38, 0x7c, 0x6c, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 88
-    0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 89
-    0x00, 0x00, 0xfe, 0xc6, 0x86, 0x0c, 0x18, 0x30, 0x60, 0xc2, 0xc6, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 90
-    0x00, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 91
-    0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00,
-    0x00, // 92
-    0x00, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 93
-    0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 94
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
-    0x00, // 95
-    0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 96
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 97
-    0x00, 0x00, 0xe0, 0x60, 0x60, 0x78, 0x6c, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 98
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 99
-    0x00, 0x00, 0x1c, 0x0c, 0x0c, 0x3c, 0x6c, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 100
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 101
-    0x00, 0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00,
-    0x00, // 102
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xcc, 0x78,
-    0x00, // 103
-    0x00, 0x00, 0xe0, 0x60, 0x60, 0x6c, 0x76, 0x66, 0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00,
-    0x00, // 104
-    0x00, 0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 105
-    0x00, 0x00, 0x06, 0x06, 0x00, 0x0e, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3c,
-    0x00, // 106
-    0x00, 0x00, 0xe0, 0x60, 0x60, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0xe6, 0x00, 0x00, 0x00,
-    0x00, // 107
-    0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 108
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0xfe, 0xd6, 0xd6, 0xd6, 0xd6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 109
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00,
-    0x00, // 110
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 111
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0,
-    0x00, // 112
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0x0c, 0x1e,
-    0x00, // 113
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x76, 0x66, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00,
-    0x00, // 114
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0x60, 0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 115
-    0x00, 0x00, 0x10, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00,
-    0x00, // 116
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 117
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 118
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00, 0x00, 0x00,
-    0x00, // 119
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x6c, 0x38, 0x38, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 120
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0xf8,
-    0x00, // 121
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xcc, 0x18, 0x30, 0x60, 0xc6, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 122
-    0x00, 0x00, 0x0e, 0x18, 0x18, 0x18, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0e, 0x00, 0x00, 0x00,
-    0x00, // 123
-    0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 124
-    0x00, 0x00, 0x70, 0x18, 0x18, 0x18, 0x0e, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00,
-    0x00, // 125
-    0x00, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 126
-    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 127
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 128
-    0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 129
-    0x00, 0x18, 0x18, 0x3c, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3c, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 130
-    0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, 0x60, 0x60, 0xe6, 0xfc, 0x00, 0x00, 0x00,
-    0x00, // 131
-    0x00, 0x00, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 132
-    0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00,
-    0x00, // 133
-    0x00, 0x3c, 0x6c, 0x6c, 0x3e, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 134
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 135
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 136
-    0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 137
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00,
-    0x00, // 138
-    0x00, 0x70, 0xd8, 0x30, 0x60, 0xc8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 139
-    0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xc0, 0x00, 0x00,
-    0x00, // 140
-    0x00, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00,
-    0x00, // 141
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 142
-    0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 143
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36, 0x6c, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 144
-    0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, 0x66, 0xce, 0x9e, 0x3e, 0x06, 0x06, 0x00,
-    0x00, // 145
-    0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, 0x60, 0xdc, 0x86, 0x0c, 0x18, 0x3e, 0x00,
-    0x00, // 146
-    0x00, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x60, 0xc0, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 147
-    0x00, 0xc6, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 148
-    0x38, 0x6c, 0x38, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 149
-    0x00, 0x00, 0x3e, 0x6c, 0xcc, 0xcc, 0xfe, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0x00, 0x00, 0x00,
-    0x00, // 150
-    0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xc0, 0xc2, 0x66, 0x3c, 0x0c, 0x06, 0x7c, 0x00,
-    0x00, // 151
-    0x18, 0x30, 0x60, 0x00, 0xfe, 0x66, 0x60, 0x7c, 0x60, 0x60, 0x66, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 152
-    0x76, 0xdc, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 153
-    0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 154
-    0x00, 0xc6, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 155
-    0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xd8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0x00, 0x00, 0x00,
-    0x00, // 156
-    0x00, 0x60, 0x30, 0x18, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 157
-    0x00, 0x18, 0x30, 0x60, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 158
-    0x00, 0x10, 0x38, 0x6c, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 159
-    0x00, 0x00, 0xcc, 0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 160
-    0x00, 0x38, 0x6c, 0x38, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 161
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0x76, 0x36, 0x7e, 0xd8, 0xd8, 0x6e, 0x00, 0x00, 0x00,
-    0x00, // 162
-    0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x60, 0x60, 0x66, 0x3c, 0x0c, 0x06, 0x3c, 0x00, 0x00,
-    0x00, // 163
-    0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 164
-    0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 165
-    0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 166
-    0x00, 0x00, 0xc6, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 167
-    0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 168
-    0x00, 0x0c, 0x18, 0x30, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 169
-    0x00, 0x18, 0x3c, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 170
-    0x00, 0x00, 0x66, 0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 171
-    0x00, 0x00, 0x76, 0xdc, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00,
-    0x00, // 172
-    0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 173
-    0x00, 0x18, 0x30, 0x60, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 174
-    0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 175
-    0x00, 0x00, 0xc6, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00,
-    0x00, // 176
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x7e, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 177
-    0x00, 0x60, 0x30, 0x18, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 178
-    0x00, 0x18, 0x30, 0x60, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 179
-    0x00, 0x30, 0x78, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 180
-    0x00, 0x00, 0xcc, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 181
-    0x00, 0x00, 0xc6, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0x78,
-    0x00, // 182
-    0x00, 0x0e, 0x1b, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0x70, 0x00,
-    0x00, // 183
-    0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00,
-    0x00, // 184
-    0x00, 0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00,
-    0x00, // 185
-    0x00, 0x00, 0x00, 0xfe, 0xc6, 0x60, 0x30, 0x18, 0x30, 0x60, 0xc6, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 186
-    0x00, 0x00, 0x00, 0x7e, 0x18, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 187
-    0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x6c, 0x6c, 0x6c, 0x6c, 0xee, 0x00, 0x00, 0x00,
-    0x00, // 188
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0xd8, 0xd8, 0xd8, 0xdc, 0x76, 0x00, 0x00, 0x00,
-    0x00, // 189
-    0x00, 0x00, 0x1e, 0x30, 0x18, 0x0c, 0x3e, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 190
-    0x00, 0x00, 0x1c, 0x30, 0x60, 0x60, 0x7c, 0x60, 0x60, 0x60, 0x30, 0x1c, 0x00, 0x00, 0x00,
-    0x00, // 191
-    0x00, 0x00, 0x00, 0x00, 0xfe, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00,
-    0x00, // 192
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00,
-    0x00, // 193
-    0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 194
-    0x00, 0x00, 0x00, 0x03, 0x06, 0x7e, 0xdb, 0xdb, 0xf3, 0x7e, 0x60, 0xc0, 0x00, 0x00, 0x00,
-    0x00, // 195
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 196
-    0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00,
-    0x00, // 197
-    0x00, 0xd8, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 198
-    0x00, 0xf8, 0xcc, 0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0xcc, 0xcc, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 199
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 200
-    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 201
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 202
-    0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 203
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x6c, 0xfe, 0x6c, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 204
-    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 205
-    0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 206
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 207
-    0x00, 0x0f, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x6c, 0x3c, 0x1c, 0x00, 0x00, 0x00,
-    0x00, // 208
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xdb, 0xdb, 0xdb, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 209
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 210
-    0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00,
-    0x00, // 211
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 212
-    0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 213
-    0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x00, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 214
-    0x00, 0x00, 0x00, 0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x00, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 215
-    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 216
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 217
-    0x00, 0x00, 0x0e, 0x1b, 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 218
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00,
-    0x00, // 219
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 220
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 221
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 222
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 223
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 224
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 225
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 226
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 227
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 228
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 229
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 230
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 231
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 232
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 233
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 234
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 235
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 236
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 237
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 238
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 239
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 240
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 241
-    0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 242
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 243
-    0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 244
-    0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 245
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 246
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 247
-    0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 248
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 249
-    0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 250
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 251
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 252
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 253
-    0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 254
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 255
-    0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 256
-    0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-    0x18, // 257
-    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 258
-    0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
-    0x36, // 259
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 260
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, // 261
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, // 262
-    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
-    0xf0, // 263
-    0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
-    0x0f, // 264
-    0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11,
-    0x44, // 265
-    0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55,
-    0xaa, // 266
-    0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd,
-    0x77, // 267
-    0x00, 0x00, 0x00, 0x00, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 268
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00,
-    0x00, // 269
-    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 270
-    0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfe, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00,
-    0x00, // 271
-    0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c, 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 272
-    0x00, 0x02, 0x06, 0x0e, 0x1e, 0x3e, 0xfe, 0x3e, 0x1e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00,
-    0x00, // 273
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 274
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, // 275
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd, 0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff,
-    0xff, // 276
-    0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0x81, 0xbd, 0x99, 0x81, 0x81, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 277
-    0x00, 0x00, 0x7e, 0xff, 0xdb, 0xff, 0xff, 0xc3, 0xe7, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00,
-    0x00, // 278
-    0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 279
-    0x00, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00,
-    0x00, // 280
-    0x00, 0x00, 0x1e, 0x0e, 0x1a, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00,
-    0x00, // 281
-    0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x7e, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 282
-    0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0xe7, 0xe7, 0xe7, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00,
-    0x00, // 283
-    0x00, 0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00,
-    0x00, // 284
-    0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00,
-    0x00, // 285
-    0x00, 0x00, 0x3f, 0x33, 0x3f, 0x30, 0x30, 0x30, 0x30, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00,
-    0x00, // 286
-    0x00, 0x00, 0x7f, 0x63, 0x7f, 0x63, 0x63, 0x63, 0x63, 0x67, 0xe7, 0xe6, 0xc0, 0x00, 0x00,
-    0x00, // 287
-];
@@ -1,97 +0,0 @@
-extern crate alloc;
-
-use core::{
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use crate::prelude::*;
-use crossbeam::queue::ArrayQueue;
-use futures_util::{Stream, task::AtomicWaker};
-use spin::Once;
-
-static KBD_QUEUE: Once<ArrayQueue<u8>> = Once::new();
-static WAKER: AtomicWaker = AtomicWaker::new();
-
-pub fn add_scancode(scancode: u8) {
-    if let Some(queue) = KBD_QUEUE.get() {
-        if queue.push(scancode).is_err() {
-            println!("WARNING: scancode queue full; dropping keyboard input");
-        } else {
-            println!("waking waker");
-            WAKER.wake();
-        }
-    } else {
-        println!("WARNING: scancode queue not initialised");
-    }
-}
-
-pub struct ScanCodeStream {
-    _private: (),
-}
-
-impl ScanCodeStream {
-    pub fn new() -> Self {
-        KBD_QUEUE.call_once(|| ArrayQueue::new(5));
-
-        Self { _private: () }
-    }
-}
-
-impl Default for ScanCodeStream {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Stream for ScanCodeStream {
-    type Item = u8;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let queue = KBD_QUEUE.get().expect("scancode queue not initialized");
-        serial_println!("This is called once.");
-        WAKER.register(cx.waker());
-
-        // fast path
-        if let Some(scancode) = queue.pop() {
-            return Poll::Ready(Some(scancode));
-        }
-
-        queue.pop().map_or_else(
-            || {
-                print!("Returning");
-                Poll::Pending
-            },
-            |scancode| {
-                print!("Scancode found");
-                WAKER.take();
-                Poll::Ready(Some(scancode))
-            },
-        )
-    }
-}
-
-use futures_util::stream::StreamExt;
-use pc_keyboard::{DecodedKey, HandleControl, Keyboard, ScancodeSet1, layouts};
-
-pub async fn print_keypresses() {
-    let mut scancodes = ScanCodeStream::new();
-    let mut keyboard = Keyboard::new(
-        ScancodeSet1::new(),
-        layouts::Us104Key,
-        HandleControl::Ignore,
-    );
-
-    serial_println!("Printing keypresses.");
-
-    while let Some(scancode) = scancodes.next().await {
-        if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
-            if let Some(key) = keyboard.process_keyevent(key_event) {
-                match key {
-                    DecodedKey::Unicode(character) => print!("{}", character),
-                    DecodedKey::RawKey(key) => print!("{:?}", key),
-                }
-            }
-        }
-    }
-}
@@ -1,16 +0,0 @@
-#![no_std]
-#![warn(tail_expr_drop_order)]
-#![warn(clippy::correctness, clippy::perf, clippy::nursery)]
-// alloc
-// io : serial, framebuffer, ascii(?), keyboard
-// ?????
-// scheduling / tasks : async
-
-pub mod alloc;
-pub mod io;
-pub mod scheduling;
-
-/// Re-exports most of the IO macros.
-pub mod prelude {
-    pub use crate::{print, print_log, println, println_log, serial_print, serial_println};
-}
@@ -0,0 +1,15 @@
+[package]
+name = "libm"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[dependencies]
+darling = "0.20.10"
+proc-macro2 = "1.0.93"
+quote = "1.0.38"
+syn = "2.0.98"
+
+
+[lib]
+proc-macro = true
@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly"
+targets = ["x86_64-linux-gnu"]
@@ -0,0 +1,129 @@
+#![allow(dead_code)]
+#![feature(proc_macro_span)]
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc
+)]
+
+use proc_macro::{Span, TokenStream};
+use quote::quote;
+use std::path::PathBuf;
+use syn::{LitStr, parse_macro_input};
+extern crate proc_macro;
+
+#[proc_macro]
+/// Expects the file path to be relative to the current file so this works
+/// similarly to the standard Rust include! macros.
+pub fn include_font(item: TokenStream) -> TokenStream {
+    let span = Span::call_site();
+    let source_file = span.source_file();
+
+    if !source_file.is_real() {
+        panic!(
+            "We can't handle finding files if the source file does not exist. TODO: Can we?"
+        )
+    }
+
+    let filename = parse_macro_input!(item as LitStr);
+    let source_filepath: PathBuf = source_file.path();
+    let file_path = format!(
+        "{}/{}",
+        source_filepath.parent()
+            .unwrap_or_else(|| panic!("Expected to find the calling source file in a folder like src! Got: {}", source_filepath.display())).display(),
+        filename.value()
+    );
+
+    let font_bytes = match std::fs::read(file_path) {
+        Ok(bytes) => bytes,
+        Err(why) => panic!("{}", why),
+    };
+
+    let font_data = match FontBuilder::load(font_bytes) {
+        Ok(font) => font.data,
+        Err(why) => panic!("{}", why),
+    };
+
+    quote!(
+        [
+            #(
+                [#(#font_data),*]
+            ),*
+        ]
+    )
+    .into()
+}
+
+struct Font([[u8; 16]; 512]);
+
+struct FontData {
+    width: u8,
+    height: u8,
+    length: u16,
+    pub data: [[u8; 16]; 512],
+}
+enum FontBuilder {
+    Psf1(FontData),
+    Psf2(FontData),
+}
+
+impl FontBuilder {
+    const PSF1_MAGIC: u16 = 0x3604;
+    const PSF2_MAGIC: u32 = 0x72b54a86;
+
+    fn revision(data: &[u8]) -> u8 {
+        if (data[0] as u16) << 8 | data[1] as u16 == Self::PSF1_MAGIC {
+            1
+        } else if (data[0] as u32) << 24
+            | (data[1] as u32) << 16
+            | (data[2] as u32) << 8
+            | data[3] as u32
+            == Self::PSF2_MAGIC
+        {
+            2
+        } else {
+            0
+        }
+    }
+
+    pub fn load(data: Vec<u8>) -> Result<FontData, &'static str> {
+        match Self::revision(&data[0..4]) {
+            1 => Self::parse_psf1(&data),
+            2 => Self::parse_psf2(&data),
+            _ => panic!("invalid font revision result"),
+        }
+    }
+
+    fn parse_psf1(data: &[u8]) -> Result<FontData, &'static str> {
+        let mode = data[2];
+        let size = data[3];
+
+        let has_512_glyphs = (mode & 0x01) != 0;
+        let mut glyphs = [[0; 16]; 512];
+        let glyph_count = if has_512_glyphs { 512 } else { 256 };
+
+        for i in 0..(glyph_count as usize) {
+            let mut buff: [u8; 16] = [0; 16];
+            for j in 0..(size as usize) {
+                buff[j] = data[4 + i * (size as usize) + j];
+            }
+            glyphs[i] = buff;
+        }
+
+        Ok(FontData {
+            width: 8,
+            height: size,
+            length: glyph_count,
+            data: glyphs,
+        })
+    }
+
+    const fn parse_psf2(_data: &[u8]) -> Result<FontData, &'static str> {
+        Err("PSF2 support is not implemented yet!")
+    }
+}
@@ -0,0 +1,4 @@
+wrap_comments = true
+max_width = 80
+comment_width = 80
+format_code_in_doc_comments = true
@@ -0,0 +1,109 @@
+#!/bin/bash
+
+# Colors
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+BOLD='\033[1m'
+NC='\033[0m' # No Color
+
+# Error handling
+set -e
+trap 'echo -e "${RED}${BOLD}error${NC}: build failed" >&2' ERR
+
+# Get absolute path to project root
+project_root=$(cd "$script_dir/.." &>/dev/null && pwd)
+build_dir="$project_root/build"
+iso_root="$build_dir/iso_root"
+
+# Logging functions
+info() {
+    echo -e "${BLUE}${BOLD}info${NC}: $1"
+}
+
+compiling() {
+    echo -e "${GREEN}${BOLD}Compiling${NC}: $1"
+}
+
+warning() {
+    echo -e "${YELLOW}${BOLD}warning${NC}: $1" >&2
+}
+
+building() {
+    echo -e "${GREEN}${BOLD}Building${NC}: $1"
+}
+
+copying() {
+    echo -e "${GREEN}${BOLD}  Copying${NC}: $1 to $2"
+}
+
+error() {
+    echo -e "${RED}${BOLD}error${NC}: $1" >&2
+    exit 1
+}
+
+copy_file() {
+    copying $1 $2
+    cp "$1" "$2" || error $3
+}
+
+# Check if we're running tests
+if [[ $1 == *"deps"* ]]; then
+    kernel_path="$1"
+else
+    # Build the kernel normally
+    cd "$project_root"
+    # cargo build
+    kernel_path="$build_dir/target/x86_64-kernel/debug/kernel"
+fi
+
+# Check for required tools
+check_tools() {
+    local missing=0
+    for tool in xorriso git qemu-system-x86_64; do
+        if ! command -v $tool >/dev/null 2>&1; then
+            error "required tool '$tool' is not installed"
+            missing=1
+        fi
+    done
+    if [ $missing -eq 1 ]; then
+        error "missing required tools"
+    fi
+}
+
+# Create build directory structure
+info "Creating build directory structure"
+mkdir -p "$iso_root/boot/limine"
+mkdir -p "$iso_root/EFI/BOOT"
+
+# Clone Limine if needed
+if [ ! -d "$build_dir/limine" ]; then
+    compiling "limine bootloader"
+    cd "$build_dir"
+    git clone https://github.com/limine-bootloader/limine.git --branch=v9.x-binary --depth=1 "$build_dir/limine" || error "failed to clone limine"
+    make -C "$build_dir/limine" || error "failed to build limine"
+    cd "$project_root"
+fi
+
+# Copy files
+info "Copying files to ISO root"
+copy_file "$kernel_path" "$iso_root/boot/kernel" "failed to copy kernel"
+copy_file "$project_root/config/limine.conf" "$iso_root/boot/limine/limine.conf" "failed to copy limine config"
+copy_file "$build_dir/limine/limine-bios-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-bios-cd.bin"
+copy_file "$build_dir/limine/limine-uefi-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-uefi-cd.bin"
+copy_file "$build_dir/limine/limine-bios.sys" "$iso_root/boot/limine/" "failed to copy limine-bios.sys"
+copy_file "$build_dir/limine/BOOTX64.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTX64.EFI"
+copy_file "$build_dir/limine/BOOTIA32.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTIA32.EFI"
+
+# Create ISO
+building "bootable ISO image"
+xorriso -as mkisofs -R -r -J -b boot/limine/limine-bios-cd.bin \
+        -no-emul-boot -boot-load-size 4 -boot-info-table -hfsplus \
+        -apm-block-size 2048 --efi-boot boot/limine/limine-uefi-cd.bin \
+        -efi-boot-part --efi-boot-image --protective-msdos-label \
+        "$iso_root" -o "$build_dir/image.iso" || error "failed to create ISO"
+
+# Install Limine
+info "Installing Limine bootloader"
+"$build_dir/limine/limine" bios-install "$build_dir/image.iso" || error "failed to install limine"
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
+
+source scripts/build.sh
+
+warning "This script will OVERWRITE whatever media you throw at it\nwith the built ISO."
+
+info "sudo ./hardware.sh /dev/yourdisk"
+
+if ! echo "$1" | grep -q "/dev"; then
+    error "invalid device"
+fi
+
+read -p "Confirm (y/n): " confirmation
+if [ "$confirmation" != "y" ]; then
+    exit 0
+fi
+
+dd if=./build/image.iso of="$1"
@@ -2,120 +2,16 @@

 # Script originally written by zxq5, I added separate scripts to remove `jq` dependency.

-# Colors
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[0;33m'
-RED='\033[0;31m'
-BOLD='\033[1m'
-NC='\033[0m' # No Color
+script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
+
+source $script_dir/build.sh

 # Error handling
 set -e
 trap 'echo -e "${RED}${BOLD}error${NC}: build failed" >&2' ERR

-# Get absolute path to project root
-script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
-project_root=$(cd "$script_dir/.." &>/dev/null && pwd)
-
 echo -e "${GREEN}${BOLD} Running kernel in debug mode."

-# Logging functions
-info() {
-    echo -e "${BLUE}${BOLD}info${NC}: $1"
-}
-
-compiling() {
-    echo -e "${GREEN}${BOLD}Compiling${NC}: $1"
-}
-
-warning() {
-    echo -e "${YELLOW}${BOLD}warning${NC}: $1" >&2
-}
-
-building() {
-    echo -e "${GREEN}${BOLD}Building${NC}: $1"
-}
-
-copying() {
-    echo -e "${GREEN}${BOLD}  Copying${NC}: $1 to $2"
-}
-
-error() {
-    echo -e "${RED}${BOLD}error${NC}: $1" >&2
-    exit 1
-}
-
-copy_file() {
-    copying $1 $2
-    cp "$1" "$2" || error $3
-}
-
-build_dir="$project_root/build"
-iso_root="$build_dir/iso_root"
-
-# Check if we're running tests
-is_test=0
-if [[ $1 == *"deps"* ]]; then
-    is_test=1
-    kernel_path="$1"
-else
-    # Build the kernel normally
-    cd "$project_root"
-    # cargo build
-    kernel_path="$build_dir/target/x86_64-kernel/debug/kernel"
-fi
-
-# Check for required tools
-check_tools() {
-    local missing=0
-    for tool in xorriso git qemu-system-x86_64; do
-        if ! command -v $tool >/dev/null 2>&1; then
-            error "required tool '$tool' is not installed"
-            missing=1
-        fi
-    done
-    if [ $missing -eq 1 ]; then
-        error "missing required tools"
-    fi
-}
-
-# Create build directory structure
-info "Creating build directory structure"
-mkdir -p "$iso_root/boot/limine"
-mkdir -p "$iso_root/EFI/BOOT"
-
-# Clone Limine if needed
-if [ ! -d "$build_dir/limine" ]; then
-    compiling "limine bootloader"
-    cd "$build_dir"
-    git clone https://github.com/limine-bootloader/limine.git --branch=v9.x-binary --depth=1 "$build_dir/limine" || error "failed to clone limine"
-    make -C "$build_dir/limine" || error "failed to build limine"
-    cd "$project_root"
-fi
-
-# Copy files
-info "Copying files to ISO root"
-copy_file "$kernel_path" "$iso_root/boot/kernel" "failed to copy kernel"
-copy_file "$project_root/config/limine.conf" "$iso_root/boot/limine/limine.conf" "failed to copy limine config"
-copy_file "$build_dir/limine/limine-bios-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-bios-cd.bin"
-copy_file "$build_dir/limine/limine-uefi-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-uefi-cd.bin"
-copy_file "$build_dir/limine/limine-bios.sys" "$iso_root/boot/limine/" "failed to copy limine-bios.sys"
-copy_file "$build_dir/limine/BOOTX64.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTX64.EFI"
-copy_file "$build_dir/limine/BOOTIA32.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTIA32.EFI"
-
-# Create ISO
-building "bootable ISO image"
-xorriso -as mkisofs -R -r -J -b boot/limine/limine-bios-cd.bin \
-        -no-emul-boot -boot-load-size 4 -boot-info-table -hfsplus \
-        -apm-block-size 2048 --efi-boot boot/limine/limine-uefi-cd.bin \
-        -efi-boot-part --efi-boot-image --protective-msdos-label \
-        "$iso_root" -o "$build_dir/image.iso" || error "failed to create ISO"
-
-# Install Limine
-info "Installing Limine bootloader"
-"$build_dir/limine/limine" bios-install "$build_dir/image.iso" || error "failed to install limine"
-
 # Check if KVM is available
 if [ "${KVM_FLAG:-enable}" = "disable" ]; then
    warning "KVM acceleration disabled by user"
@@ -145,6 +41,31 @@ else
    serial_flags="-serial stdio"
 fi

+# Set up VM memory
+if [ $VM_MEMORY ]; then
+    vm_memory_flag="-m $VM_MEMORY"
+else
+    vm_memory_flag="-m 2G"
+fi
+
+# Set up boot flags
+if [ $USE_LEGACY_BIOS ]; then
+    boot_flags=""
+else
+#   Check for the presence of the OVMF firmware.
+    if [ ! -f $build_dir/RELEASEX64_OVMF_CODE.fd ]; then
+        info "Downloading OVMF UEFI firmware for QEMU"
+        info "To disable this, set USE_LEGACY_BIOS=1."
+        pushd $build_dir
+        curl https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF_CODE.fd -LO || error "failed to download OVMF firmware for UEFI"
+        curl https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF_VARS.fd -LO || error "failed to download OVMF firmware for UEFI"
+        popd
+    fi
+
+    boot_flags="-drive if=pflash,format=raw,readonly=on,file=$build_dir/RELEASEX64_OVMF_CODE.fd \
+                -drive if=pflash,format=raw,file=$build_dir/RELEASEX64_OVMF_VARS.fd"
+fi
+
 # Run in QEMU
 if [[ ${QEMU_FLAGS} == *-S* ]]; then
    info "Running OS in QEMU with GDB debugging enabled"
@@ -171,20 +92,27 @@ check_test_res() {
    fi
 }

-
-kvm_flag=""
-
 trap 'check_test_res "tests completed"' ERR
 
+
+# NOTE(ali): For some reason the values in `boot_flags` were causing issues
+# 	     on WSL, so they've been eradicated.
+systemInfo=$(uname -r)
+if [[ $systemInfo == *"WSL"* ]]; then
+    echo "Running on WSL2"
+    boot_flags=""
+fi
+
 cd "$project_root"
 qemu-system-x86_64 -M q35 \
-    ${kvm_flag} \
    -cdrom "$build_dir/image.iso" \
+    ${kvm_flag} \
    -boot d \
-    -m 2G \
+    ${vm_memory_flag} \
    ${serial_flags} \
    -no-reboot \
    ${test_flags} \
    ${debug_flags} \
+    ${boot_flags} \
    ${QEMU_FLAGS:-}

@@ -2,120 +2,23 @@

 # Script originally written by zxq5, I added separate scripts to remove `jq` dependency.

-# Colors
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[0;33m'
-RED='\033[0;31m'
-BOLD='\033[1m'
-NC='\033[0m' # No Color
+script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
+
+source $script_dir/build.sh

 # Error handling
 set -e
 trap 'echo -e "${RED}${BOLD}error${NC}: build failed" >&2' ERR

-# Get absolute path to project root
-script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
-project_root=$(cd "$script_dir/.." &>/dev/null && pwd)
-
 echo -e "${GREEN}${BOLD} Running kernel in release mode."

-# Logging functions
-info() {
-    echo -e "${BLUE}${BOLD}info${NC}: $1"
-}

-compiling() {
-    echo -e "${GREEN}${BOLD}Compiling${NC}: $1"
-}
-
-warning() {
-    echo -e "${YELLOW}${BOLD}warning${NC}: $1" >&2
-}
-
-building() {
-    echo -e "${GREEN}${BOLD}Building${NC}: $1"
-}
-
-copying() {
-    echo -e "${GREEN}${BOLD}  Copying${NC}: $1 to $2"
-}
-
-error() {
-    echo -e "${RED}${BOLD}error${NC}: $1" >&2
-    exit 1
-}
-
-copy_file() {
-    copying $1 $2
-    cp "$1" "$2" || error $3
-}
-
-build_dir="$project_root/build"
-iso_root="$build_dir/iso_root"
-
-# Check if we're running tests
-is_test=0
-if [[ $1 == *"deps"* ]]; then
-    is_test=1
-    kernel_path="$1"
+if [ $VM_MEMORY ]; then
+    vm_memory_flag="-m $VM_MEMORY"
 else
-    # Build the kernel normally
-    cd "$project_root"
-    # cargo build
-    kernel_path="$build_dir/target/x86_64-kernel/release/kernel"
+    vm_memory_flag="-m 2G"
 fi

-# Check for required tools
-check_tools() {
-    local missing=0
-    for tool in xorriso git qemu-system-x86_64; do
-        if ! command -v $tool >/dev/null 2>&1; then
-            error "required tool '$tool' is not installed"
-            missing=1
-        fi
-    done
-    if [ $missing -eq 1 ]; then
-        error "missing required tools"
-    fi
-}
-
-# Create build directory structure
-info "Creating build directory structure"
-mkdir -p "$iso_root/boot/limine"
-mkdir -p "$iso_root/EFI/BOOT"
-
-# Clone Limine if needed
-if [ ! -d "$build_dir/limine" ]; then
-    compiling "limine bootloader"
-    cd "$build_dir"
-    git clone https://github.com/limine-bootloader/limine.git --branch=v9.x-binary --depth=1 "$build_dir/limine" || error "failed to clone limine"
-    make -C "$build_dir/limine" || error "failed to build limine"
-    cd "$project_root"
-fi
-
-# Copy files
-info "Copying files to ISO root"
-copy_file "$kernel_path" "$iso_root/boot/kernel" "failed to copy kernel"
-copy_file "$project_root/config/limine.conf" "$iso_root/boot/limine/limine.conf" "failed to copy limine config"
-copy_file "$build_dir/limine/limine-bios-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-bios-cd.bin"
-copy_file "$build_dir/limine/limine-uefi-cd.bin" "$iso_root/boot/limine/" "failed to copy limine-uefi-cd.bin"
-copy_file "$build_dir/limine/limine-bios.sys" "$iso_root/boot/limine/" "failed to copy limine-bios.sys"
-copy_file "$build_dir/limine/BOOTX64.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTX64.EFI"
-copy_file "$build_dir/limine/BOOTIA32.EFI" "$iso_root/EFI/BOOT/" "failed to copy BOOTIA32.EFI"
-
-# Create ISO
-building "bootable ISO image"
-xorriso -as mkisofs -R -r -J -b boot/limine/limine-bios-cd.bin \
-        -no-emul-boot -boot-load-size 4 -boot-info-table -hfsplus \
-        -apm-block-size 2048 --efi-boot boot/limine/limine-uefi-cd.bin \
-        -efi-boot-part --efi-boot-image --protective-msdos-label \
-        "$iso_root" -o "$build_dir/image.iso" || error "failed to create ISO"
-
-# Install Limine
-info "Installing Limine bootloader"
-"$build_dir/limine/limine" bios-install "$build_dir/image.iso" || error "failed to install limine"
-
 # Check if KVM is available
 if [ "${KVM_FLAG:-enable}" = "disable" ]; then
    warning "KVM acceleration disabled by user"
@@ -128,59 +31,30 @@ else
    kvm_flag=""
 fi

-# I'm lazy but I just remove GDB flags when running this script.
-debug_flags=""
-
-# Set up test-specific flags
-if [ $is_test -eq 1 ]; then
-    test_flags="-device isa-debug-exit,iobase=0xf4,iosize=0x04 -display none"
-    serial_flags="-serial stdio"
+if [ $USE_LEGACY_BIOS ]; then
+    boot_flags=""
 else
-    test_flags=""
-    # serial_flags="-serial tcp:127.0.0.1:1234,server -monitor telnet:127.0.0.1:1235,server"
-    serial_flags="-serial stdio"
+#   Check for the presence of the OVMF firmware.
+    if [ ! -f $build_dir/RELEASEX64_OVMF_CODE.fd ]; then
+        info "Downloading OVMF UEFI firmware for QEMU"
+        info "To disable this, set USE_LEGACY_BIOS=1."
+        pushd $build_dir
+        curl https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF_CODE.fd -LO || error "failed to download OVMF firmware for UEFI"
+        curl https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF_VARS.fd -LO || error "failed to download OVMF firmware for UEFI"
+        popd
    fi

-# Run in QEMU
-if [[ ${QEMU_FLAGS} == *-S* ]]; then
-    info "Running OS in QEMU with GDB debugging enabled"
-    info "To connect GDB, run: gdb"
-    info "At the GDB prompt, type: target remote localhost:1234"
-else
-    info "Running OS in QEMU..."
+    boot_flags="-drive if=pflash,format=raw,readonly=on,file=$build_dir/RELEASEX64_OVMF_CODE.fd \
+                -drive if=pflash,format=raw,file=$build_dir/RELEASEX64_OVMF_VARS.fd"
 fi

-check_test_res() {
-    qemu_exit_code=$?
-    if [ $qemu_exit_code -eq 33 ]; then
-        # Success case (0x10 << 1) | 1 = 33
-        info "All tests passed"
-        exit 0
-    elif [ $qemu_exit_code -eq 35 ]; then
-        # Failure case (0x11 << 1) | 1 = 35
-        warning "Some tests failed"
-        exit 1
-    else
-        # Any other exit code is treated as a failure
-        warning "Some tests failed"
-        exit 1
-    fi
-}
-
-
-kvm_flag=""
-
-trap 'check_test_res "tests completed"' ERR
- 
 cd "$project_root"
 qemu-system-x86_64 -M q35 \
    ${kvm_flag} \
    -cdrom "$build_dir/image.iso" \
    -boot d \
-    -m 2G \
+    ${vm_memory_flag} \
    ${serial_flags} \
    -no-reboot \
-    ${test_flags} \
-    ${debug_flags} \
-    ${QEMU_FLAGS:-}
+    ${boot_flags}
Author	SHA1	Message	Date
zxq5	ecdc76b068	Merge remote-tracking branch 'origin' into unified	2025-03-06 01:18:43 +00:00
zxq5	8ee4af1a48	someone broke a mod.rs so i fixed it.	2025-03-05 21:10:36 +00:00
zxq5	03c07cb5c4	Merging with origin/unified	2025-03-05 21:04:58 +00:00
zxq5	ef70bcf51e	- heap allocator now makes sure virtual memory pages are mapped before using them. this means we no longer have to use page faults to allocate frames, it is done automatically. - fixed the apic code that caused a page fault. it now writes the correct values at the correct physical address - improved startup logging including displaying how much RAM is installed.	2025-03-05 20:49:21 +00:00
nullndvoid	2fb1741100	Begin setting up stack unwinding/tracing. This actually worked so I am chuffed, but it doesn't read the necessary DWARF structures just yet. Still a good step forwards.	2025-03-05 20:44:09 +00:00
nullndvoid	af995d1d76	Tried and failed to use unwinding crate: shall do it myself tomorrow.	2025-03-05 03:24:26 +00:00
nullndvoid	014ec5310c	Some more clippy fixes, warnings are noisy	2025-03-05 00:57:06 +00:00
nullndvoid	d53661b9a0	Ran cargo fmt, clippy fixes, suppressed some warns I will start working on stack traces tonight and tomorrow. We need to be able to 'unwind' by finding calling functions.	2025-03-04 23:06:47 +00:00
zxq5	8704b5d249	FIXED THE APIC HELL YEAH	2025-03-04 12:44:42 +00:00
zxq5	2186b829aa	- made improvements to memory code (refactored) - started on improvements to the page frame allocator. it should be able to provide a usable page for any given virtual memory address requested.	2025-03-04 01:28:39 +00:00
zxq5	f502104a6e	changes	2025-03-04 00:53:38 +00:00
zxq5	48dcde0c02	minor changes & work on threading	2025-03-04 00:53:06 +00:00
nullndvoid	6e913b15d7	Update macro to use relative working dirs, Spans	2025-03-03 15:57:16 +00:00
nullndvoid	0a5269eeb0	Fix clippy errors	2025-03-03 15:51:39 +00:00
zxq5	a0f5ce8797	reorganised memory. starting on threads	2025-03-03 15:50:58 +00:00
nullndvoid	2d3bc56962	Fix some clippy errors	2025-03-03 14:53:30 +00:00
nullndvoid	5703032f87	Fix module inception	2025-03-03 14:47:24 +00:00
zxq5	3966e697da	refactor mega-commit. - reorganised the entire project so that the entire kernel is a single codebase rather than a kernel and a libk.	2025-03-03 02:49:56 +00:00
aha480	e8237f4610	run_debug.sh now checks if it running on wsl and disables boot_flags if it is since it was causing issues with qemu	2025-03-01 12:49:42 +00:00
nullndvoid	53d325749d	Fix incorrect target name in config	2025-02-28 16:15:26 +00:00
zxq5	8a3e9e3afc	- implemented a custom allocator (fixed size block) with a fallback (linked list allocator) for larger block sizes - apic code still not working (commented out, check lib.rs)	2025-02-28 04:18:35 +00:00
zxq5	e38c20dbd3	Merge pull request 'editor' (#6 ) from editor into dev Reviewed-on: OsDev/FoundryOS#6	2025-02-28 03:05:38 +00:00
zxq5	c8bb85364c	- updated to-dos - removed unnecessary debugging code - moved x86_64-kernel.json to the project root	2025-02-28 03:05:10 +00:00
zxq5	fe18004f7d	Merge remote-tracking branch 'origin' into editor merging into dev	2025-02-27 23:58:01 +00:00
zxq5	192100be7a	changed page allocation to happen on page fault for performance reasons	2025-02-27 23:57:23 +00:00
nullndvoid	2915d0c879	Add tips on debugging/disassembling kernel sources	2025-02-27 23:32:05 +00:00
zxq5	9852cb14eb	updated build scripts	2025-02-27 22:58:10 +00:00
zxq5	db8dbff9f2	added memory allocation flag to run command ```VM_MEMORY=<amount>G cargo run```	2025-02-27 21:57:58 +00:00
zxq5	2178215a01	fixed triple fault	2025-02-27 16:52:31 +00:00
zxq5	821759ec63	apic broken pushing to debug	2025-02-27 16:19:43 +00:00
zxq5	0b3dbed4be	updated documentation	2025-02-27 02:30:48 +00:00
zxq5	3b6e272fd2	not working	2025-02-27 01:16:07 +00:00
zxq5	ac0b47a45c	merge	2025-02-26 04:00:00 +00:00
zxq5	15f59e68d5	initial apic implementaion (Commented out / NOT WORKING)	2025-02-26 03:48:11 +00:00
nullndvoid	b7397d8a1b	Remove unused clippy lints	2025-02-25 03:20:05 +00:00
nullndvoid	4fe6109e5b	Rename scheduling to 'async_io', general cleanup	2025-02-25 03:18:12 +00:00
nullndvoid	e294a13a91	Cleanup the README a little more	2025-02-25 02:59:55 +00:00
nullndvoid	752800a3ca	Merge UEFI support for qemu into our runner scripts/build system	2025-02-25 02:56:48 +00:00
nullndvoid	177fddcf7d	Add warnings to hardware script (dd implies 'doubly dangerous')	2025-02-25 02:55:52 +00:00
nullndvoid	375c5aa561	Update limine.conf to boot up faster	2025-02-25 02:54:19 +00:00
nullndvoid	b945416665	Add qemu UEFI firmware support.	2025-02-25 02:53:28 +00:00
zxq5	27ee8226d8	implemented stdin methods for reading a string (async) and reading keystrokes (sync + async). added a very basic shell on top of it for debugging	2025-02-25 02:16:01 +00:00
nullndvoid	00d3a1de72	fb: Added support for typing backspaces.	2025-02-24 23:24:03 +00:00
zxq5	f7723a3944	making the keyboard module more flexible, still needs work	2025-02-24 18:24:21 +00:00
zxq5	438ef7a748	stop banning mod.rs	2025-02-24 16:30:38 +00:00
zxq5	2f7ab8fe6b	Merge remote-tracking branch 'refs/remotes/origin/dev' into dev	2025-02-24 16:29:58 +00:00
zxq5	ca1c695e32	created stdio module, added hardware script	2025-02-24 16:28:56 +00:00
zxq5	1c22f89665	reverted dumb change	2025-02-24 15:34:46 +00:00
nullndvoid	1c147dd933	Ban module inception, this is annoying. @zxq5 thoughts?	2025-02-24 15:34:29 +00:00
zxq5	91044f5fad	merged dumb change	2025-02-24 15:33:59 +00:00
zxq5	d5b15826e2	adding std io idk	2025-02-24 15:33:42 +00:00
nullndvoid	39f1f4905d	Ban mod.rs.	2025-02-24 15:29:39 +00:00
nullndvoid	03a3469d20	Formatting changes to task.rs	2025-02-24 15:19:01 +00:00
nullndvoid	2cbe9641aa	Use prelude lol.	2025-02-24 15:14:12 +00:00
zxq5	e303ecf5a4	fixed merge commit tomfoolery.	2025-02-24 15:14:21 +00:00
zxq5	2f08835d69	merge commit. probably broken tbh	2025-02-24 15:10:58 +00:00
nullndvoid	8d57540566	Fix clippy errors	2025-02-24 15:02:44 +00:00
zxq5	03290e52a3	fixed a dumb error about me hardcoding paths	2025-02-24 13:07:11 +00:00
zxq5	8908a6a281	Update README.md	2025-02-24 03:45:02 +00:00
zxq5	aefc368d41	updated readme for more comprehensive build instructions	2025-02-24 03:44:22 +00:00
zxq5	76ec29b7ec	changed #usage back to being a tag (was not a markdown fail, it's an obsidian tag)	2025-02-24 03:36:28 +00:00
zxq5	d9bbdff08c	- added a new libary libm containing procedural macros for the kernel. these should be used to include external files and resources in the kernel binary at compile time. - libm currently supports loading psf-1 formatted fonts - added two fonts that are included in the binary at compile time - refactored libk to make the crate structure more organised and maintainable in future. new structure: - drivers (hardware interaction) - resources (consts and statics included either manually or via macros) - std (standard functions for higher level interaction with the os, for example creating windows) - added geometry.rs - provides the Vec2<T> struct for use with dimensions, coordinates etc. - added window.rs - provides the Window struct for rendering the state of an application to the screen - added application.rs - provides the Application trait for custom programs to implement in order to run	2025-02-24 03:26:49 +00:00
zxq5	7ff33659fe	async works!	2025-02-23 19:27:13 +00:00
zxq5	efe3034ad0	Merge pull request 'libk now replaces the plethora of lib crates' (#5 ) from nullndvoid/FoundryOS:dev into dev Reviewed-on: OsDev/FoundryOS#5	2025-02-23 17:07:25 +00:00