Overview

Overview

The continuation of device to visualize audio signal using real-time FFT on an ESP32 platform, driving a 399-pixel RGB LED matrix with animated effects with additional WiFipackets communication.

Overview

A multiplayer mini-game built from scratch in Rust, featuring a custom async game server and real-time graphical and CLI clients.

The game includes a lobby system, game state transitions, basic NPC behavior, and separate GUI roles depending on player type.

Project Scope

• Async server handling multiple client connections and managing game world state
• In-game chat system distinguishing between server and client messages
• Shared client logic with both CLI and WGPU-based GUI frontends
• Decoupled client connections from in-game character state
• Procedural world generation
• Basic NPC AI logic and movement
• Game state transitions: lobby → active game → summary
• Reward system and scoring logic for winning players

Overview

A personal project inspired by my wife’s hobby.

Users can upload an image, select available DMC colors, and receive a ready-to-print pattern along with a Bill of Materials (BOM) listing all required diamond colors and quantities.

Project Scope

• REST API with endpoints for uploading images and tracking processing status
• Image analysis and dithering using DMC-compatible palettes
• Color quantization and matching using perceptual color distance
• Generates high-resolution PDF output for printing
• Optional UI planned for future use

Overview

Command-line utility for uploading binary data to external NOR Flash on ARM-based devices using a J-Link debugging probe.

The upload process is mediated through a dedicated C-based upload API integrated into the firmware, which is called directly from the host via GDB during a debug session.

Responsibilities

• Studied and leveraged GDB’s ability to call target-resident C functions via `call` commands
• Wrote a set of C functions exposed in the target firmware to receive and write memory chunks
• Implemented GDB subprocess automation and communication from Rust
• Designed chunked, page-aligned transfer with status feedback
• Built a robust CLI around this mechanism for ease of use in production/test environments

Overview

Firmware for an Internet-connected steam sterilizer. Responsible for end-to-end embedded system design, including control logic, connectivity, and modern responsible user interface.

Responsibilities

• Low-level memory driver:
  • Shared FMC bus: NOR + PSRAM with Read/Write management
  • Buffering and caching
  • External memory loading
  • Failsafe filesystem
  • Fragmentation monitoring
• WiFi connectivity:
  • Manage WiFi connection
  • Register device in Azure DPS using HTTPS
  • Send telemetry, chunking & receive notification from IoT Hub via MQTTS
  • Monitor new firmware & do OTA updates with backup
  • RED Directive & service tools
• Implement HMI project:
  • Custom TouchGFX components
  • Optimized rendering
  • External double framebuffer, external graphics data, FLASH write operations management
• Sterilization process control:
  • Implementation of PID and hysteresis
  • Heaters, pumps, valves control
  • Optimizing physical process for speed
• USB dual-role:
  • Host MSC to store process data, download firmware
  • Device CDC/ACM Modbus for production, testing, and service
• LED strips:
  • RGB animations

Overview

Embedded projects are notoriously difficult to transfer between machines or contributors.

This setup isolates the entire development environment inside a Docker DevContainer, making the project reproducible and portable across systems.

It replaces heavier IDEs (e.g., Eclipse-based tools) with a modern, faster workflow using VS Code and Linux-based builds.

Due to USB device mapping limitations in containers, the GDB server is run outside the container — but integrates cleanly with the VS Code debugging workflow.

Responsibilities

• Indepth knowledge how ST-Link and J-Link works
• Built a CMake-based project structure compatible with STM32CubeMX and TouchGFX codegen
• Integrated remote debugging through ST-Link and J-Link
• Wrote custom VS Code tasks and launch configurations for building, flashing, and testing
• Automated host-side unit tests with Google Test
• Analyzed .elf and .map files to enable reliable external memory loading (NOR/PSRAM via FMC) using GDB
• Replaced legacy IDEs with reproducible, Docker-based environment

Overview

A standalone E-Ink picture frame with built-in access point and web interface.

Designed to display user-uploaded images without needing external services.

The device serves a fully self-contained web app (HTML/CSS/JS), allowing users to crop, scale, dither, and upload images directly to the ESP32 for display.

Project Scope

• Developed embedded web server with JavaScript-based frontend
• Implemented captive portal for instant access after connecting
• Created image processing pipeline: crop → grayscale → dithering → upload
• Parsed and displayed PNG images on E-Ink display using custom rendering logic
• Designed minimal, UI-first UX for non-technical users

Overview

A 2D RPG engine inspired by classic top-down games like *Zelda*.

Built in Python with Pygame, it features a layered tile-based world, animated entities, and a component-driven object system.

While the project remains in development, it has laid a strong foundation for a full pixel-art RPG engine.

Project Scope

• Implemented an extensible object model using Python properties and composition
• Integrated TMX/TSX map parsing for Tiled-based level design
• Built a collision system with layered obstacle detection and visual debugging
• Developed pixel-art rendering pipeline with global scaling logic
• Introduced modular animations and entity state management
• Designed and integrated custom tilesets and graphics (WIP)

Overview

This project visualizes audio input using real-time FFT on an ESP32 platform, driving a 399-pixel RGB LED matrix with animated effects.

It’s designed for living room aesthetics, performance, and modular expandability

Overview

A compact, Bluetooth-enabled macro keyboard built using an ESP32 board.

Designed to trigger custom key sequences for automation, shortcuts, and productivity tasks.

Project Scope

• Implemented HID over Bluetooth communication
• Programmed hotkey mapping logic using C++

Overview

A commissioned project to explore a flooded mineshaft located ~20 meters underground in Lubań, Poland.

The vessel was designed to descend into the shaft via 10cm drill and transmit video footage for archaeological and safety assessment.

Project Scope

• Designed custom electronics and control system for vessel navigation
• Integrated video capture with LED lighting for visibility
• Built a watertight enclosure and propulsion system (partially successful)
• Supply power and control signals from the surface
• Contributed to one of the first serious technical attempts to explore the shaft — later fully successful in follow-up expeditions

Overview

This project was commissioned by a printing company to simplify and speed up the process of evaluating wear on printing cylinders.

Previously, this required expensive equipment and manual measurements. The new solution involved a custom device with fixed camera distance and lighting conditions, paired with OpenCV-based analysis.

Responsibilities

• Designed and 3D-printed a custom enclosure to maintain consistent camera positioning
• Implemented a Python + OpenCV script to calculate ink stain surface area
• Tuned thresholding, perspective correction, and region isolation for robustness
• Delivered an affordable and replicable device that reduced measurement time and cost

Overview

A custom game engine and level editor built in Java using OpenGL and LWJGL. Developed over 2 years as a personal challenge to understand real-time rendering, ECS-like architecture, and cross-cutting systems like audio, terrain generation, and GUI handling.

The project helped me explore full-engine architecture and taught me key lessons about code structure, coupling, and the value of testing and separation of concerns.

Heavily inspired by ThinMatrix YouTube series.

Project Scope

• Custom OpenGL rendering pipeline and shader management
• Entity system for managing in-game objects
• Terrain rendering and water effects
• GUI and event system for in-engine editor tools
• Scene serialization and reloading
• Basic audio and camera logic

Overview

A six-legged walking robot designed and built in high school — combining mechanical engineering, embedded software, and robotics. The project earned awards at robotics tournaments and received national media coverage.

Project Scope

• Designed mechanical structure for body and 6 legs
• Wrote control algorithms for inverse kinematics and walking gait
• Implemented Bluetooth communication protocol
• Implemented basic autonomous behavior using sensor feedback (feet and head proximity)