Kieweg Leander

This project involves designing a custom 2D graphics processing unit (GPU) in VHDL and developing a complete Linux kernel device driver to control it. To bridge the gap between hardware and software, I built a functional software twin of the GPU within the QEMU emulator, allowing for rapid driver development and debugging without waiting for FPGA synthesis. Through this project, I gained deep practical experience in hardware-software co-design, AXI4-Lite bus interfacing, MMIO register control, and Linux interrupt handling. Future plans include transitioning the driver to the Linux DRM (Direct Rendering Manager) subsystem and deploying the full stack onto a physical Terasic DE10-Standard Cyclone V SoC. GitHub Repository

Technologies Used:
C, VHDL, Linux Kernel, QEMU

Focused on Linux kernel internals, device drivers, and the Direct Rendering Manager (DRM) subsystem. Work includes maintaining a personal development fork used to prototype kernel changes (for learning and experimentation), implementing an experimental syscall in that private fork to learn syscall plumbing, and working through example Linux device drivers while studying Linux Device Drivers and the kernel driver model.

Major achievement: I submitted a janitorial patch which was accepted into the mainline Linux kernel (drivers/gpu/drm/tiny/bochs.c). This contribution modernized the driver logging call and was merged after review. The experience taught me about the kernel review process, patch submission etiquette, and working with the DRM maintainers.

Links:

• Linux fork
• Linux Modules
• Linux Device Drivers, 3rd Edition fork
• Mailing-list discussion and patch series (accepted patch)

This project is about developing a small custom OS kernel designed to boot on actual hardware, not just within a virtual machine. Built with C and x86 assembly, the kernel provides a hands-on exploration of low-level computing and system programming. Through this project, I gained a deeper understanding of computer architecture, linker scripts, and creating freestanding binaries. Future plans include loading and executing ELF format programs and implementing basic graphics display. GitHub Repository

Technologies Used:
C, x86 Assembly, Qemu, Docker, Grub

This project explores the challenge of deploying AI models on an ESP32 microcontroller, a device with extremely limited resources and no file system. The goal was to transfer a machine learning model from a Jupyter Notebook environment to a microcontroller, ensuring it runs efficiently despite the hardware constraints. By leveraging C++ for embedded programming and Python for model development, I successfully integrated AI capabilities into a low-power device. This project demonstrates the feasibility of running sophisticated AI algorithms on minimal hardware. GitHub Repository

Technologies Used:
C++, ESP32 Controller, Python, Keras, TensorFlow

Bastionfall is a third-person Action RPG with online co-op, built from the ground up in C++ with Unreal Engine 5. It features skill-based combat and a unique "Warden's Choice" system where players can recruit powerful enemies as AI followers. This project emphasizes a fully server-authoritative multiplayer architecture, supports both Windows and native Linux, and has a public demo available on Steam. Steam Page | GitHub Repository

Technologies Used:
C++, Unreal Engine 5, Steamworks API

This project is a highly modular and cross-platform graphics engine built with Vulkan and modern C++ techniques. Designed specifically for voxel graphics, it aims to leverage Vulkan's cutting-edge capabilities for optimal performance and flexibility. The engine is still in its early stages, being developed from the ground up to ensure modernity and modularity. This project is a learning journey into Vulkan and the latest C++20 features, driven by a desire to stay at the forefront of graphics technology. GitHub Repository

Technologies Used:
C++, Vulkan, CMake

This project is a custom 3D game engine developed directly on Microsoft's DirectX API. Originally implemented using DirectX 9 and later upgraded to DirectX 11, the engine focuses on low-level programming to provide fine-grained control over GPU resources and hardware interaction. The development process explores concepts of efficient resource management and performance optimization, which are essential in both embedded systems and high-performance graphics applications. GitHub Repository

Technologies Used:
C++, DirectX 11 (formerly DirectX 9), Nvidia PhysX

Rust Systems Playground is a collection of Rust programs designed to explore and learn the Rust programming language. The repository currently includes a small voxel renderer using the Bevy engine and a simple to-do list app. The project serves as a learning platform to understand Rust's unique features and capabilities. Inspired by Rust's strong reputation, the next step is to build a web server using Rust. GitHub Repository

Technologies Used:
Rust, Bevy

Rust Web Server is a from-scratch HTTP server implementation built in Rust, designed as a hands-on learning project to explore both web server architecture and Rust's systems programming capabilities. The server handles fundamental operations including TCP connection management, HTTP request parsing, routing, and static file serving. Currently featuring multi-threaded request handling with support for GET requests and HTTP/1.1 protocol implementation. GitHub Repository

Technologies Used:
Rust

ESP32S3-MultiMedia is a portable device built on the ESP32-S3 microcontroller featuring a touch screen interface with multiple apps. The project integrates a camera, heart rate sensor, audio system with dual speakers, and Wi-Fi connectivity. Programmed in C++ using PlatformIO, it offers smartphone-like functionality including: photo capture with SD card storage, image gallery, heart rate monitoring with graphical display, music playback, RGB LED control, and sound effects. GitHub Repository

Technologies Used:
C++, ESP32, PlatformIO

This project is a smart irrigation system that automatically waters plants based on moisture levels detected by a sensor. The system records these moisture values in a database hosted on my home server, and the data is visualized on a website. The system can be built using an ESP32 with C++, and optionally Arduino, though without database connectivity. The project addresses the challenge of efficient plant care and data logging, with future plans to train an AI model on the collected moisture data. GitHub Repository

Technologies Used:
C++, ESP32, MySQL, PHP

OpenHIDevice is a compact, programmable input peripheral that combines customizable buttons with mouse functionality. Built with an ESP32 microcontroller and coded in C++ using PlatformIO, this open-source device allows users to bind specific functions to physical buttons while also controlling cursor movement. Smaller than commercial alternatives like Stream Deck, OpenHIDevice offers a space-efficient solution for programmers, content creators, and productivity enthusiasts seeking a versatile input tool that can be customized for various workflows. GitHub Repository

Technologies Used:
C++, ESP32, PlatformIO

LVGL-Room-Booking is a cost-effective room display system built with an ESP32-S3 and touch screen, designed as an extension for OpenIndoorMaps. These compact devices mount outside meeting spaces to show current and upcoming reservations in real-time. Developed in C++ with PlatformIO and the LVGL graphics library, this solution offers a more affordable and efficient alternative to tablets for room management while integrating with indoor navigation infrastructure. GitHub Repository

Technologies Used:
C++, ESP32, PlatformIO, LVGL

OpenIndoorMaps is an open-source indoor navigation solution that addresses wayfinding challenges in complex environments like shopping centers, airports, and universities. This web application provides detailed indoor mapping capabilities, allowing users to easily locate destinations within large buildings. Built with accessibility and ease-of-use in mind, OpenIndoorMaps offers an intuitive interface that works across devices. The project features a functional prototype available online OpenIndoorMaps
GitHub Repository

Technologies Used:
Typescript, Maplibre

A browser-based tower defense game developed as a comprehensive project to master the Godot Engine and its web export capabilities. The game combines classic TD strategy with direct hero combat, playable on both desktop and mobile browsers. The primary focus was on learning core Godot features, including the scene system, signals for decoupled architecture, and GDScript for implementing all game logic from player controls and enemy AI to dynamic wave spawning. A key technical challenge was creating a seamless cross-platform experience by implementing a JavaScript bridge for reliable mobile device detection. Play on itch.io | GitHub Repository

Technologies Used:
Godot Engine, JavaScript (for mobile web detection)

This project is a personal collection of machine learning experiments and implementations, focused on deepening my understanding of AI. Key highlights include developing GANs, diffusion models, CNNs, and NLP models using the Shakespearean dataset. Additionally, I implemented the "Attention Is All You Need" model, the foundational architecture behind technologies like ChatGPT. The primary motivation was to learn the underlying mathematics and practical implementation of machine learning models from scratch. GitHub Repository

Technologies Used:
Python, Keras, TensorFlow, scikit-learn

This project is a custom-built 2D game development framework designed to streamline the creation of 2D games. It includes support for the Tiled Editor format, a collision detection system, A* pathfinding, and a UI system for HUDs and main menus. The framework was developed to enhance my understanding of the A* algorithm and improve my C++ programming skills. Building this framework allowed me to dive deeper into game development mechanics while creating a versatile tool for 2D game projects. GitHub Repository

Technologies Used:
C++, SDL2

EzioEditore is a lightweight text editor designed with support for Markdown, built specifically to meet the needs of my German Matura. Developed using C++ and Qt, this project was motivated by the desire for a simpler alternative to bloated word processors like Word. The project allowed me to create a streamlined, efficient text editor tailored to my needs, making it a fun and practical coding exercise. GitHub Repository

Technologies Used:
C++, Qt

The Finance Tracker is a personal budgeting tool developed to keep track of my expenses, especially during my time abroad in Italy. Built with C++ and Qt, this tool saves expense data in a human-readable XML format, providing a clear overview of spending habits. The project was inspired by the need for a simple, custom solution to monitor my finances, making it both a practical and enjoyable coding challenge.

Technologies Used:
C++, Qt

This project is an online shop inspired by Willhaben, where users can both buy and sell items. Developed with JavaScript, Angular, Node.js with Express, and MySQL, this platform was created as a school project. It marked my first experience as a team lead and involved building a REST API from scratch. The project was well-received, earning top marks, and provided valuable lessons in leadership and full-stack development. GitHub Repository

Technologies Used:
JavaScript, Angular, Node.js (Express), MySQL, HTML, CSS

Arcus is a website designed for archery enthusiasts to track and compare their performance results. Built with PHP, MySQL, Bootstrap, HTML, CSS, and JavaScript, the platform features a graph that allows users to visualize and compare their performance with others. Developed as a school project, it was well-received and earned top marks. The project provided valuable experience in web development and data visualization. GitHub Repository

Technologies Used:
PHP, MySQL, Bootstrap, HTML, CSS, JavaScript

This project is a unique real-time strategy (RTS) game that combines traditional RTS mechanics with a third-person perspective. Built with C++ in Unreal Engine, the game features a capture-the-flag mode where holding a flag generates money that can be spent on additional units, such as archers or men-at-arms. The motivation behind this project was to create a new twist on the RTS genre and to learn Unreal Engine. The biggest challenge was handling the artistic elements, as 3D modeling is not my specialty.

Technologies Used:
C++, Unreal Engine

This project is a third-person shooter set in a sci-fi scenario, built using C++ and Unreal Engine. The game encompasses the full development cycle, from the initial startup screen and main menu to gameplay and a final win condition. Designed as a learning experience, the goal was to understand the entire process of creating a complete game in Unreal Engine. The artistic aspects posed the biggest challenge, as 3D modeling is not my area of expertise.

Technologies Used:
C++, Unreal Engine

This project is a first-person adventure game inspired by the Indiana Jones films, focusing on recreating the classic dungeon mechanics and unique traps seen in the movies. Developed with C++ in Unreal Engine, the game was primarily a learning experience to master the engine and game development process. The project was driven by a desire to capture the excitement and challenge of classic adventure scenarios.

Technologies Used:
C++, Unreal Engine

This project is a collection of x86 assembly programs, written in both Intel and AT&T syntax, designed to deepen my understanding of low-level computing. These small programs serve as exercises to familiarize myself with assembly language, which is essential for grasping how computers work at the hardware level. The project aims to enhance my overall programming skills by providing insight into what happens behind the scenes when writing higher-level code. As a next step, I plan to explore RISC-V assembly. GitHub Repository

Technologies Used:
x86 Assembly (Intel and AT&T syntax)

This mod introduces a capture-the-flag game mode to Age of Empires IV, where players earn resources by holding sacred sites. Each player starts with a set of knights, a monk, a tower, a stable, and a monastery, focusing the gameplay on intense battles and strategic control. Developed using Lua, this project was an exploration into game modding, driven by my enthusiasm for Age of Empires and a desire to understand the modding process. GitHub Repository

Technologies Used:
Lua

The Arduino Project Suite is a collection of diverse Arduino projects, showcasing various applications and experiments. Notable among these is an audio player that plays a segment of Toto's "Africa," with the audio stored as a char array in the source code. This suite of projects aims to explore and demonstrate different aspects of electronics, sensors, and common Arduino functionalities. The project has been a valuable learning experience in electronics and embedded programming. GitHub Repository

Technologies Used:
C++, Arduino

The AutoClicker Utility is a small program designed to automate mouse clicks, built using C++. The inspiration for this project came from losing one too many times in Minecraft, prompting the development of a tool to improve in-game performance. This project served as a fun and practical exercise in utility programming, providing hands-on experience with C++. GitHub Repository

Technologies Used:
C++