@jphwb

Kernel Refactor

One of the biggest changes in this update was reorganising the kernel into individual components rather than keeping everything inside a single source file.The project now contains dedicated modules for:
VGA text output
Interrupt Descriptor Table (IDT)
Interrupt Service Routines (ISR)
Hardware Interrupt Requests (IRQ)
Programmable Interrupt Controller (PIC)
Programmable Interval Timer (PIT)
Keyboard driver
Low-level I/O helpers

Interrupt Descriptor Table

The kernel now builds and installs a complete Interrupt Descriptor Table (IDT) containing all 256 entries. CPU exceptions (ISR 0-31) are fully registered, while IRQs from the Programmable Interrupt Controller occupy vectors 32-47 after remapping. Once the IDT has been loaded using lidt, the kernel is capable of safely responding to both processor exceptions and hardware interrupts.

CPU Exception Handling

Proper exception handling has now been implemented. Instead of the CPU immediately crashing with no feedback, exceptions are caught and displayed on screen with useful debugging information including:
Exception name
Interrupt number
Error codeInstruction pointer (EIP)
Code segment
CPU flags
After reporting the error the kernel safely halts, making debugging much easier during development.

Programmable Interrupt Controller (PIC)

The legacy PIC is now fully initialised and remapped away from the CPU exception vectors .Support has also been added for:
Sending End Of Interrupt (EOI) commands
Masking individual IRQ lines
Unmasking IRQs when drivers are ready

Programmable Interval Timer (PIT)

The PIT has now been configured as the kernel’s first hardware timer. It generates periodic interrupts at a configurable frequency and maintains a continuously increasing tick counter. While simple for now, this timer will eventually become the basis for delays

Keyboard Driver

Perhaps the most noticeable improvement in this update is the addition of the first real hardware driver. The keyboard driver:
Receives hardware interrupts on IRQ1
Reads raw PS/2 scancodes
Translates scancodes into ASCII characters
Buffers incoming keystrokes
Allows the kernel to read characters without directly accessing hardware every time

Improved VGA Terminal

The VGA text driver has also been rewritten into its own module.
I added Cursor updates, Automatic scrolling, Backspace support, Colour control, Decimal output and Hexadecimal output

I rewrote the bootloader into two stages.
Each item in stage 2 is
Disk loader: disk_read_lba in stage2 is fully reusable (LBA, count, drive, destination segment:offset via a Disk Address Packet), checks for INT 13h extensions first, and retries 3 times with a disk reset between attempts, same pattern in stage1’s simpler loader.
Print routine: print_string prints status lines at each stage (“loading kernel…”, “enabling A20…”, etc) plus explicit disk error and unsupported extensions messages.
A20: now enabled in real mode before the protected mode switch, using the BIOS function and the fast A20 gate together.
Boot drive: saved from DL at both stage1 and stage2 entry rather than hardcoded.
Magic numbers: sector counts, load addresses, and buffer addresses all moved into src/config.inc, shared by both stages.
E820 memory map: collected in real mode into a fixed buffer before switching to protected mode.
Boot info struct: built in 32-bit mode and handed to the kernel via EBX. Matching BootInfo struct is in kernel.h.
Load/execute address mismatch: The kernel now loads to physical 0x10000 in real mode, then once in flat 32-bit protected mode, stage2 copies it to 0x100000 with rep movsd before jumping there, so the linker script’s link address and the actual jump target now agree.

Got the bootloader to load kernel.c which is empty but you can see in the gdb log in the terminal that it does load void kernel_main. Next I am going to rewrite the bootloader into a two stage bootloader so it can have a print routine, retrying disk reads, A20 handling and an E820 memory map. Since all of this isnt possible in just 510 bytes (last two bytes reserved for the boot sector signature being 0x55 and 0xAA) I will split it into two stages.

Created a basic assembly project that prints hello world to the terminal and tested it by booting the built .bin file in qemu.

Added Protocol::connect_tls() method using rustls::StreamOwned<rustls::ClientConnection, TcpStream>.
Created AllowAnyVerifier implementing rustls::client::danger::ServerCertVerifier to accept any certificate
AddedClient::connect_tls() that loads ca-certificates.crt if present otherwise falls back to system certs
TLS now works for HTTP1_1 and HTTP2_0 protocols
New DNSCache struct with Arc<Mutex<HashMap<String, DNSCacheEntry»> thread-safe, TTL-based
DNSCacheEntry stores resolved SocketAddr list + expiry timestamp
resolve_dns() now uses trust_dns_resolver::Resolver::from_system_conf() for proper DNS lookups, with fallback to ToSocketAddrs
parse_url() extracts the host, port, and TLS flag from http:// or https:// URLs
Handles explicit ports (example.com:8080) and defaults (80/443)
connect_to() now calls resolve_and_connect() which uses DNS cache + TLS decision logic
Client now tracks redirect_count
send_request() detects 3xx status codes, reads location header, and follows redirects
HTMLTag -enum of all standard HTML5 tags
HTMLAttribute -name/value pairs
HTMLNode - tag + attributes + children + optional text content
HTMLDocument -doctype + root node
HTMLTag::from_string() - case-insensitive parser for all tags

I added text rendering to the wgpu window so it displays the HTTP status code instead of just printing it to the console. The window now shows “Status: 200” (or whatever the server returns)

I added response decoding and support for http0.9 1.0 and 1.1. These guides: browser.engineering, firefox guides and servo were amazing resources for learning how HTTP works and with encoding/decoding requests and responses. I mostly just followed along with how firefox worked and built my way away from it but the code formatting went a bit off in the middle (it was 4:30am I have an exam in 4 hours I was tired)
Next I want to print everything in the UI instead of terminal

Finished the program and I added all the icons and details

Added the initial browser engine foundataion. I added basic support for http protocol and implemented http request encoding.

I created the basic app here but it just shows a colour right now. I was following a tutorial on basic rust because I’m still learning it.

Using OpenF1 API when the user runs /verstappen-info it shows them info on Max Verstappen. when they run /verstappen-quote it shows them a random quote from a list of quotes said by verstappen.

Made the basic code from the guide so it says a catfact, a joke and displays the help menu and ping.

made the firmware and updated the CAD to the Xiao can be accessed from outside, added labels to buttons, rounded corners and made a render with the parts.

Finished the CAD (im absolutely horrid at it) took me way too long to figure it out. Anyways I hope my screws were correct.

Created the PCB, I had somehting with more switches but it got too complex and I couldnt figure out how to do the tracing. I lost about 6ish hours bc the kicad wakatime app wasnt working.