After writing drivers for NVMe storage, my bare-metal kernel could load files and run JIT code. However, I was still typing commands into a text-only COM1 serial terminal. I needed a graphical interface.
Last night, the second agent took over to build a double-buffered visual rendering compositor on top of the UEFI Graphics Output Protocol (GOP) framebuffer.
The V.E.L.O.C.I.T.Y.-OS 12-Part RoadmapWe are building a bare-metal, self-healing operating system running entirely inside the CPU's L3 cache. Here is the roadmap for this 12-part series:
This led to the design of the Synaptic Canvas GUI.
I started by mapping the physical screen buffer pointer discovered by UEFI GOP. I implemented a double-buffering scheme: drawing elements to a heap-allocated backbuffer (Vec<u32>
) and blasting it to screen memory in a single operation to prevent screen flicker.
I implemented three swappable GUIs that compile in #![no_std]
without float libraries:
GlassmorphicShellGui: A premium, semi-transparent frosted glass terminal container. It overlays active system metrics (RAM allocated, SMP core status, W^X protections) with a live terminal prompt and a COM1 log streaming console.
MatrixRainGui: Cuz I mean why not, I'm putting an AI in the Matrix?
SynapticCanvasGui (The Workspace): A spatial coordinate interface. Instead of rendering files inside folders, files and JIT execution blocks float as interactive nodes on a 2D plane.
Here is the double-buffered renderer implementation in src/gui.rs
showing the radial background gradient and the frosted-glass blending loop that runs at bare metal:
// velocity-boot/src/gui.rs — Double-Buffered Glassmorphic Compositor
impl GlassmorphicShellGui {
fn render(&mut self, buffer: &mut [u32], width: usize, height: usize) {
// 1. Draw premium Slate radial background gradient
for y in 0..height {
let offset_y = y * width;
let ratio = y as f32 / height as f32;
let r = (20.0 + ratio * 20.0) as u32;
let g = (26.0 + ratio * 20.0) as u32;
let b = (38.0 + ratio * 24.0) as u32;
let color = (r << 16) | (g << 8) | b;
buffer[offset_y..(offset_y + width)].fill(color);
}
let win_x = 40usize;
let win_y = 60usize;
let win_w = width - 80;
let win_h = height - 120;
// 2. Draw glass background panel (frosted glass transparency blend)
for dy in 0..win_h {
let py = win_y + dy;
let offset = py * width + win_x;
for dx in 0..win_w {
let pixel = buffer[offset + dx];
// In-place linear blend with frosted glass white tint (glassmorphism)
let r = (((pixel >> 16) & 0xFF) * 8 + 25) / 9;
let g = (((pixel >> 8) & 0xFF) * 8 + 30) / 9;
let b = ((pixel & 0xFF) * 8 + 42) / 9;
buffer[offset + dx] = (r << 16) | (g << 8) | b;
}
}
// 3. Draw glass border (thin Slate outline)
draw_rect_outline(buffer, width, win_x, win_y, win_w, win_h, 0x00D9E2EC, 2);
// Render header title bar
draw_rect(buffer, width, win_x + 2, win_y + 2, win_w - 4, 36, 0x0010172A);
draw_string(buffer, width, "V.E.L.O.C.I.T.Y.-OS :: STANDALONE KERNEL METRICS PANEL", win_x + 16, win_y + 14, 0x0038BDF8);
// ... render telemetry columns and bottom interactive shell console
}
}
The compositor computes the pairwise cosine similarity between all files in the FAT32 directory.
I implemented a Force-Directed layout entirely in #![no_std]
using a custom Newton-Raphson integer f32_sqrt
method. Nodes repel each other, pull together based on cosine embedding similarities, and gravitate toward the center of the screen, sliding smoothly across ticks.
Connection splines are drawn using quadratic Bezier curves, rendering moving glow ripple dots to visualize live data transmission between executing JIT threads.
Here is the visual mapping of the Synaptic Canvas graphics pipeline:
Fig 4: The graphics pipeline and force-directed graph compositor stages.To accelerate these embedding calculations and compositor draws, I laid the groundwork for the V-NCE GPU Compute API (gpu.rs
).
The driver scans the PCI space for standard graphics adapters (like VGA or Nvidia adapters) and maps their registers in Unified Memory Architecture (UMA) space.
This enables zero-copy CPU-to-GPU memory transfers. The JIT compiler emits hardware-agnostic command lists (BindPipeline
, SetPushConstants
, DispatchCompute
) that write directly to the GPU's registers, falling back to SIMD/AVX2 software emulation on unmapped hardware.
When I discussed the native visual compositor and display list specifications with
, he highlighted the next major logical hurdle:
"GUI rendering natively in NDA is the next hard problem — you need a display list format that maps to the immediate-mode rendering pipeline you described earlier. But the draw commands are already in the NDA spec, so the path is clear."
Pascal pointed out that by anchoring file locations to semantic embeddings, and utilizing the immediate-mode drawing commands already specified in the NDA header, the IDE was no longer a static folder tree—it was an interactive cognitive map of the code.
But running a complex GUI alongside real-time JIT compilation was hitting core contention bottlenecks. I needed to distribute work across CPU cores.
In the next post, I'll document how I implemented the Nexus Core multi-agent swarm runtime, headless serial streaming, and zero-downtime hot-patching.
Have you written custom graphics layout renderers or GUI environments at bare metal? What are the biggest challenges in coordinating double-buffering, mouse coordinate mapping, and spatial layouts (like force-directed graphs) without a Window Server or GUI framework? Let's discuss in the comments below! And lemme know, should I call the AI Neo or Agent Smith? I'm leaning towards Agent Smith cuz it can spawn sub-agents...
*Special thanks to *
Disclaimer: AI was used throughout this project, it is just fitting that it would co-author with me, so special thanks to the Foundry for its tireless hours toiling away and Gemini for producing the cover image.