@jphwb

This is a short change, initially I was working on making working CSS styling however I don’t have the time for it so all I did was create a release workflow (which took longer than expected) and I made a README going through all the features and limitations as well as a rundown of the app. I have made 3 executables. One for Windows, Linux and MacOS. All are x86_64 not ARM. I am unable to test the Linux and MacOS executables however the windows one works.

First in the UI and Rendering architecture I added a 2010 style chrome colour palette. I also implemented new vertex, rect and ui structs with layout_ui() to calculate and position the tab strip, address bat, navi buttons and the content viewport. I also made a new WGSL shader pipeline and vertex buffer for rendering flat colour rectangles. I then added normalise_url(), fetch_page(), navigate(), go_history() and reload(). Then I updated the core State struct, removed the raw display_text stering and replaced it with rectangle pipelines, address input state, focus flags, document title tracking, history stacks, scroll offsets and mouse tracking. I rewrote window_event() and app resume logic to handle the mouse movements, vlivks, wheel scrolling and keyboard typing including Enter backspace and shortcuts with ctrl and alt. I also removed the esc to quit application and it now just refocuses onto the addrtess bar. And render() draws the UI rectabgles first, then the address text, tabs buttons and page text with clipping and scroll offsets on a white background.

I also made a new HTML Parser module. With tokenisation and scanning, it includfes void/raw text element lists, entitity decoding with &amp, &nbdp, etc, character scanning and attribute parsing. parse() constructs the existing HTMLDocument and HTMLNode types from client.rs which handles comments, doctypes, closing tags and script/style. With DOM Utils it includfes is_block_level(), extract_visible_text() which skips , , and tags while infecting liner breaks around block elements and nodewalking and title extraction (find_title()).

I also deleted cssrom.rs whcih I originally had plans for but I just merged them into parser.rs and cascade.rs.

My current limitations are rendering since the pages only display as plain text so no images, hyperlinks, styling or CSS in general. There is also network bliocking where page fetching is synchronus and blocks the UI window while loading.

I can guarantee you I am not dead even though its been like 3 months. I build about the entire css engine. I can now display the web page’s html onto the app. In the app you can’t scroll down as I still need to implement that but this is progress. A lot of the functionality is there in my code but it is unused since I need to do a whole lot more work on it but this devlog is already 8 hours and I don’t want to go over 10 so I’m making a devlog here.

tokenise.rs is a css level 3 tokeniser and is pretty much the architecture. units.rs is just simple unit and angle conversion. colour.rs is just colour parsing. colours.rs is mostly just the colour-name hex table. selectors.rs is the full selector parser. parser.rs is the component valuesa dn declarations into a Stylesheet model. cascade.rs matches an element against a stylesheet and sorts it by specificity/order. box_model.rs and layout.rs just set the layout of the app’s edges/borders/padding/margin and a block-layout pass decoupled from font types that dont exist in the app natively.

I would write a lot more and style the devlog better but this new stardance thing with the animations everywhere make it almost impossible to type properly and I’m on a gaming laptop

So what I implemented was a keyboard event queue, a shell, IDE driver for a FAT-16 readonly filesystem and a preemptive scheduler. I didn’t add a true ring3 userspace in this because I need GDT ring transitions and a syscall ABI that is annoying and I don’t have the legal brain capacity in my skillset to do it.

This is now capable of switching into 32-bit protected mode and directly loads the C kernel into memory. I also made cleanups to kernel.c/h and fixed some minor build errors.

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.