Boris's Résumé

Noster: Hope

Tech stack: Godot 4.3, GDScript, Blockbench, Git/GitHub, MuseScore, Furnace, Audacity.

Personal project.

A two-player networked bullet-hell game built around fast gameplay and multiplayer interaction. I developed the game in Godot 4.3 and worked with the practical problems of connecting two players over a network, with UPnP used for peer connectivity. The project also involved creating the game's 3D assets and audio pipeline rather than relying entirely on third-party content. A playable build is also available on itch.io.

Castlevania 1986

Tech stack: Godot 4.3, GDScript, Godot 2D renderer.

Course group project
Role: Lead programmer role.

A small Godot project recreating the feel and structure of the original Castlevania as a gameplay study. The project contains a playable first level together with dedicated player, enemy, boss and item systems, physics layers and a 256×240 internal viewport matching the game's deliberately low-resolution presentation. I focused on reproducing classic platforming-style movement, combat and enemy interactions within Godot rather than relying on prebuilt gameplay systems.

Minesweeper

Tech stack: C11, raylib 6.0, X11, GCC, Make.

Personal project.

A small Minesweeper implementation written in a single evening as an exercise in reconstructing a familiar game from first principles while refreshing my C knowledge. I implemented the game logic and graphical presentation as a compact standalone program rather than using an existing game framework. The project is deliberately small, but it demonstrates that I am comfortable dropping to C and building gameplay logic without an engine.

SSFv2

Tech stack: C++17, raylib, CMake.

Personal project.

A C++ rewrite of an earlier arcade-shooter prototype, created to explore native game development, game-loop structure, entity/projectile systems, rendering and resource management.

SSFv1

Tech stack: Godot 4.2, GDScript, Godot 2D renderer.

Personal project.

An early version of my 2D arcade shooter, developed as an exploration of gameplay programming and Godot's scene and scripting systems. I implemented the player controls, attack system, enemy interactions, collision/hitbox logic, menus and gameplay flow, using separate collision layers for player and enemy hitboxes, hurtboxes and physical shapes. The project uses a deliberately small 200×150 internal viewport, giving the game a low-resolution arcade presentation while keeping the gameplay logic independent of the final window size. This project was later evolved into SSFv2, where I moved the project toward a native C++ implementation and a more structured codebase.

SSFv0

Tech stack: Python, Pygame, Python threading and synchronization primitives.

Course group project
Role: Co-Programmer - QA

A 2D arcade shooter implemented as an early exploration of game programming and concurrency. The game separates the main game loop from projectile and enemy movement using multiple threads, with mutexes protecting shared state during projectile movement, enemy movement and background resizing. It includes player control, collision detection, enemies, projectiles, menus and a second-player mode.

Spectre Attack - speculative-execution security research

Tech stack: C, x86 intrinsics, Linux, perf_event_open, hardware performance counters, GCC.

University group coursework - security/performance research.

A low-level security experiment investigating the Spectre speculative-execution side channel on x86 systems. I implemented a proof-of-concept attack that mistrains the branch predictor and uses cache-timing measurements to infer data from a victim function outside its intended bounds. The implementation uses RDTSCP for high-resolution timing and CLFLUSH to manipulate cache state, together with repeated training/attack iterations and statistical scoring to identify the most likely leaked byte. I also wrote a separate performance-measurement utility using Linux perf_event_open to work with hardware performance counters and investigate cache and branch-misprediction behaviour while running the attack. The source is kept private because it was produced as university security coursework.

HTTP server

Tech stack: C23, POSIX sockets, Linux, Clang, Make.

Personal project.

A small HTTP server written from scratch in modern C as an exercise in networking and systems programming. I implemented the TCP socket server, request reception, HTTP header parsing, request-body handling, routing, response generation, error handling and static-file serving without relying on a web framework. The server explicitly handles malformed requests and payload-size limits and uses a modular structure separating HTTP parsing, routing, responses and static files.

Microaudio

Tech stack: C23, ALSA, libm, Make, Linux.

Personal project.

A compact Linux audio playback library built from scratch to understand the fundamentals of audio playback and mixing. The library supports WAV PCM/float input and FLAC files, stereo mixing, up to 32 simultaneous voices, volume and panning controls, looping and simple linear resampling. I implemented the playback core directly against ALSA instead of using a high-level audio library, keeping the project intentionally small and understandable.

oTinyWM

Tech stack: Odin, X11, Bash, xinit, Xephyr.

Personal project.

A rewrite of the tinywm window manager in Odin, created to explore low-level interaction with the X11 environment. I implemented the project in Odin and added a small build/install/run workflow, including the ability to launch the window manager inside a nested Xephyr X server for testing without replacing the main desktop session.

Reiha

Tech stack: Rust 2024, Macroquad, macroquad-canvas, regex, dirs.

Personal project.

A personal presentation generator inspired by an earlier university project, MIASI Presentation Generator. I rebuilt the idea independently in Rust, creating my own text-based presentation format and rendering system supporting text, images, code blocks, themes, custom fonts, slide numbering, configurable resolution and a next-slide preview in the terminal. The tool grew from a minimal implementation of the Takahashi presentation style into a more general presentation system.

Elastic Optical Network Routing

Tech stack: Python, NetworkX, dataclasses, custom graph/data structures, algorithmic simulation.

Course group project
Role: Co-Developer

An algorithmic project investigating routing and resource allocation for time-varying traffic in elastic optical networks. I implemented and evaluated four strategies - First Fit and Exact Fit, each with and without static grooming - across Polish and US network topologies, multiple traffic loads and several modulation schemes. The test harness measures average transceiver utilization and dropped bitrate for each configuration and writes comparable experimental results.

testownik_cli

Tech stack: Odin, Odin core libraries, Bash, Linux CLI.

Personal project.

A lightweight terminal application for studying from Testownik question banks. I implemented the question-file parser, random question selection, answer checking, progress tracking and an adaptive repetition system where incorrect answers increase the number of future repetitions while correctly answered questions are eventually removed from the active pool. The program also supports command-line configuration, ANSI terminal output, statistics and native release builds.

Pupilove

Tech stack: Python, FastAPI, Jinja2, MySQL, SQLAlchemy/MySQL Connector, Uvicorn, Docker, Percona XtraDB Cluster, ProxySQL.

Course group project
Role: Co-Developer

A web platform for animal-adoption listings supporting user accounts, publishing and editing listings, searching and filtering animals, contacting owners and managing reservations through a queue-based process. The project also considers a high-load scenario in which a popular listing generates many simultaneous database reads and proposes Percona XtraDB Cluster with ProxySQL for replication, availability and traffic distribution.

Machine Learning / Spam Classification

Tech stack: Python, scikit-learn, NumPy, pandas, PyTorch, Hugging Face Transformers/Datasets, Ollama.

Course group project
Role: Co-Developer

A text-classification project for separating spam and legitimate messages using several machine-learning approaches. The implementation includes TF-IDF feature extraction with Multinomial Naive Bayes, train/test splitting and standard classification metrics, together with several approaches to handling class imbalance including undersampling, synthetic sample generation and optional LLM-generated augmentation. The project also contains an optional BERT-based classification path using PyTorch and Hugging Face Transformers.

ProjEct-NOKIA

Tech stack: Python, Flask, Flask-SocketIO, SQLAlchemy, SQLite, OpenCV, Pygame, threading, Linux, Raspberry PI, C, Bash, Docker.

Team project - web portion only
Role: Frontend/Backend Co-Developer - CI/CD engineer

The web portion of a project connecting a camera and game controller to a browser-based application. The Python backend uses Flask and Flask-SocketIO to handle users, rooms and real-time communication, while OpenCV provides a live camera stream and Pygame reads controller input in a separate thread before sending the state to connected clients. The application uses SQLite through SQLAlchemy for persistent data and includes registration, login, meeting rooms, chat history and session management.

archdruid

Tech stack: Bash, Arch Linux, pacman, Git/AUR, Linux system administration.

Personal project.

An automated setup script for configuring a fresh Arch Linux installation around my development workflow. I built the script to handle hardware-specific GPU configuration, package installation, desktop/session setup, development tools, audio tooling, applications and optional AUR packages, while keeping most of the configuration centralized in arrays that can be modified for different machines. The script was tested on both AMD and Intel ThinkPad hardware and includes safeguards for configuration such as the GPU vendor before installation begins.

MIASI Presentation Generator

Tech stack: Java, ANTLR 4.13.2, IntelliJ IDEA.

Course Group Project
Role: Co-Developer

A Java-based presentation-generation project built around a dedicated presentation format and parser. The repository contains a Java module together with generated sources and ANTLR 4.13.2 dependencies, suggesting that a central part of the project was converting a structured presentation description into generated output. Later inspired development of Reiha.

Core

Game Development

Systems & Networking

Web

Familiar with

Non-technical