Jack Thake

shader-works 🔗

C, Cross-Platform Development, Embedded Systems, Graphics Programming, Multi-threading

I built a portable 3D software renderer from scratch in pure C with zero external dependencies, achieving impressive performance of 53 FPS while rendering 8,192 triangles on modest hardware. The core library consists of just 1,488 lines of clear, well-organized C code that implements a complete graphics pipeline, including barycentric coordinate rasterization, perspective-correct texture mapping with 1/w correction for proper depth handling, z-buffering for occlusion, and frustum culling for early triangle rejection. A notable feature of this project is its programmable shader system—using function pointers, I engineered a flexible vertex and fragment shader architecture that provides rich context access (camera data, lighting, timing), enabling dynamic visual effects without recompilation.

The renderer demonstrates true portability: the identical rendering code runs seamlessly on Linux, macOS, and Windows desktops, as well as on ARM Cortex-M4 microcontrollers with just a 200MHz clock speed and 192KB of RAM, driving 160x128 TFT displays. To maximize performance, I designed a multi-threaded work-stealing architecture using atomic operations for lock-free triangle distribution across CPU cores, achieving near-linear performance scaling. The codebase is heavily optimized for cache efficiency with interleaved vertex data layouts, leverages the restrict keyword for compiler vectorization, and uses integer arithmetic in rasterization hot paths where precision allows. This project highlights my foundational skills in low-level systems programming, cross-platform development, and performance optimization—key strengths I bring to junior systems engineering roles.

Using this library, I developed two sophisticated demos to further demonstrate the engine's versatility. Tundra features an infinite procedural terrain system leveraging multi-octave fractal Brownian motion for realistic landscape generation, with chunk streaming managed by spatial hash tables for consistent memory usage. It also includes dynamic day/night cycles, real-time weather effects, and a robust finite state machine architecture for game logic—showcasing my ability to design modular and scalable systems. The Microcraft demo is a voxel-based world renderer that I successfully deployed on SAMD51 embedded hardware. This involved creating a custom texture atlas baking pipeline and implementing a UF2 bootloader deployment workflow, highlighting my hands-on experience with embedded systems and deployment processes. These projects underscore my strengths in systems design, problem-solving, and adapting complex solutions to hardware-limited environments—key attributes for a junior systems engineering role.

secure-serve 🔗

C++17, POSIX Sockets, TLS/SSL, Multithreading, Systems Programming

Server logs showing thread pool initialization, route loading, and real-time request handling

I engineered a compact, production-grade HTTPS web server in modern C++17, implementing the full network stack from POSIX sockets up through TLS encryption with OpenSSL 3.0+. The server features a dynamic thread pool that automatically adapts to the system’s core count, ensuring optimal throughput, while a mutex-protected job queue and scoped locking patterns prevent deadlocks and minimize contention.

To ensure robust memory safety, I implemented custom smart pointer deleters for OpenSSL resources, eliminating resource leaks even during exception handling. The server’s routing architecture pre-loads all content into memory at startup, preventing path traversal attacks and reducing latency. I also developed detailed SSL handshake error handling with per-connection logging, streamlining debugging and maintenance.

Throughout development, I took advantage of modern C++17 features like std::optional for safe null handling, std::reference_wrapper for efficient data management, and std::function for flexible callbacks. This project strengthened my understanding of secure systems design, memory management, and professional development workflows, including CI/CD integration and security analysis—skills I am eager to apply as a junior systems engineer.

Tiny-Serial 🔗

C89, POSIX, Serial Communication, Terminal I/O, Systems Programming

I developed a minimal serial port monitor in strict ANSI C89 (just 140 lines) with zero external dependencies, compiling to a highly efficient 17KB binary. The tool uses the POSIX termios API for raw serial communication and carefully configures non-blocking I/O by managing flags—disabling canonical mode, echo, and signal processing—to ensure correct handling of binary data. Instead of relying on select() or epoll(), I implemented a straightforward polling-based, bidirectional communication pattern, enabling reliable simultaneous serial port reading and keyboard input.

The terminal UI employs ANSI escape sequences for color-coded output—bright green for incoming serial data and default color for user input—providing clear visual feedback during debugging. I ensured robust signal handling for graceful shutdown on SIGINT (Ctrl+C), with thorough resource cleanup to prevent serial port corruption or leaks. By using unbuffered output and byte-by-byte processing, the tool achieves sub-millisecond latency, making it ideal for real-time Arduino and microcontroller debugging. Configurable baud rates via command-line arguments with sensible defaults further streamline use in embedded development workflows.

Z80 Single Board Computer

Hardware Design, Assembly, Digital Logic

Custom Z80 single board computer during assembly and testing phase

I designed and assembled a custom Z80-based computer from discrete components, building serial communication and GPIO functionality entirely from scratch. Working at this fundamental level, I programmed a bootloader and test routines in Z80 assembly language, gaining practical experience with memory mapping, interrupt handling, and direct hardware control. This project significantly deepened my understanding of low-level software and hardware integration—an essential skill set for systems engineering.