Arseni Aliakseichyk

CyberGlove is my flagship personal project - an IoT smart glove for real-time gesture recognition and control, in active development. Phase 1 (complete): firmware on ESP32 (C, ESP-IDF, FreeRTOS) with MPU-6050 (photo) → MPU-9250 → ICM-20948 (on order) IMU over SPI and custom fiber optic bend sensor via 12-bit ADC, streaming sensor data at 50 Hz over WebSocket to a live web dashboard. Hardware drafted schematically in KiCad 8 Schematic Editor, with perfboard layout planned in KiCad PCB Editor to keep hand-soldering clean and trace routing deliberate. Assembled on perfboard with hand-soldered SMD and through-hole components for comfortable iteration: ESP32-C3-Zero + IMU sensor node + full LiPo power chain (TP4056 USB-C charger → S9V11F3S5C3 buck-boost 3.3V regulator + SPDT power switch). KiCad here is used as a drafting and layout-planning tool - full multilayer PCB fabrication is an experiment I’m still exploring. The Phase 1 sensor node was validated in a real application - integrated into the robot platform as an IMU-based tilt controller, proving the hardware and firmware stack before moving to Phase 2. Phase 2 (in progress): adding fiber optic bend sensors on all five fingers via ADC for full finger curl detection, combined with IMU orientation - enabling full gesture recognition with planned TinyML inference on-device.

• C
• ESP-IDF
• FreeRTOS
• SPI
• ADC
• ICM-20948
• WebSocket
• Wi-Fi
• KiCad (Schematic)
• Perfboard
• LiPo Power

Post-internship personal project built on the robotic hardware developed at GlobalLogic Poland. The goal was to completely rethink the UX: the original firmware required technical setup, SSH access, and command-line knowledge. The new firmware requires nothing - user powers on the robot, connects to its Wi-Fi hotspot, navigates to the web control panel, and drives. No installation, no configuration, no technical knowledge needed. The entire stack - motor drivers, sensor polling, networking stack, web server, and MQTT broker client - is one multithreaded C11 program using pthreads, compiled as a single static binary. The project was demonstrated at a university open day as an example of what students can build.

• C11
• pthreads
• Raspberry Pi 5
• WebRTC
• MQTT
• ESP-NOW
• ESP32
• ESP-IDF
• UDP
• ESP32-WROOM
• USB CDC
• IMU
• Linux 6.x
• Wi-Fi Hotspot

During my internship at GlobalLogic Poland (Koszalin), I independently developed the motion control system, FPV video pipeline, and ultrasonic obstacle detection module for a modular robotic platform - working within an Agile/SCRUM team environment (Jira). The robot runs on a Raspberry Pi 5 with a C++17 multithreaded architecture where 5 concurrent threads handle different subsystems: motor PWM control, ultrasonic sensor polling, MQTT message handling, GStreamer video pipeline, and a FastAPI REST server. The entire stack was containerized with Docker Compose.

• C++17
• Raspberry Pi 5
• GStreamer
• MQTT
• FastAPI
• Docker
• CMake
• Hailo AI

A collection of firmware projects on the STM32F4 family. The main working board is the STM32F411 (Nucleo / Black Pill class), chosen for its compact form factor and lower power draw. The STM32F407VGT6 Discovery was introduced to me during training at GlobalLogic Poland and is the board I use primarily as a learning platform for peripheral exploration.

My deliberate choice on both boards is the ST Low-Level (LL) driver library together with CMSIS - not HAL. STM32CubeMX is used only for the initial clock tree configuration (PLL setup, SYSCLK source, peripheral clock dividers); the generated project is stripped down to the LL headers + startup + linker script, and every peripheral from that point on is configured and driven directly from application code through LL calls. This gives register-level control and determinism without writing the full bit-banging boilerplate by hand.

• C
• STM32F411
• STM32F407
• ARM Cortex-M4
• LL drivers
• CMSIS
• CubeMX (clock init)
• SPI
• I2C
• UART
• ADC/DAC
• NVIC

A complete machine learning pipeline built for a university project - from dataset creation and model training to real-time edge inference. I trained a MobileNetV3 model in PyTorch on ~16,000 synthetic images across 80 classes (geometric shapes, mathematical symbols, arrows, etc.), exported it to ONNX format, and deployed it on a Raspberry Pi 5 where it runs inference at 25–30 FPS on 640×480 camera input. The system includes a custom SPI LCD driver for the ST7735S display (RGB565 pixel format via libgpiod) and an HTTP dashboard for real-time classification statistics and confusion matrix visualization.

• Python
• PyTorch
• ONNX Runtime
• OpenCV
• RPi 5
• SPI
• libgpiod

A series of three ESP32 projects built during university coursework, all written in C using the ESP-IDF framework with FreeRTOS. Each project explored different aspects of embedded IoT development - from Bluetooth Low Energy communication to cloud integration and low-power design.

• C
• ESP-IDF
• FreeRTOS
• BLE (NimBLE)
• SPI
• Firebase
• Deep Sleep

A children's fitness platform I built as a freelance project. The core is a Flutter app (~31,000 lines of Dart) using BLoC for state management, Firebase for backend services, and GoRouter for navigation. My main challenge was building a kill-resistant device monitoring system that works across Android and iOS. On Android, I wrote a native Kotlin module using the Device Owner API with a Foreground Service (OOM adj 200) and a 9-layer protection architecture, tested on Xiaomi MIUI and Samsung One UI. On iOS, I implemented Screen Time monitoring using Swift with the Family Controls / DeviceActivityMonitor framework. I also deployed a self-hosted notification worker (Node.js, Docker) that processes 10 event types with locale-aware delivery and retry logic. The project includes a full GitLab CI/CD pipeline with 3 stages (test → build → release), enforced static analysis, and automated APK artifact publishing.

• Flutter
• Dart
• Kotlin (Android)
• Swift (iOS)
• Firebase
• Docker
• Node.js
• BLoC
• GitLab CI/CD

My personal VPS infrastructure has been running continuously for over 2 years, hosting 13+ containerized services across 4 domains. The architecture follows a security-first approach: a system-level Nginx acts as a reverse proxy with SSL termination (Certbot), forwarding traffic to Docker containers bound exclusively to 127.0.0.1. Critical services (VPN admin panel, Guacamole RDP/SSH proxy) are protected behind Authelia SSO with YubiKey WebAuthn 2FA. The firewall (UFW) only exposes ports 80, 443, 51820 (WireGuard), and a non-standard SSH port.

• Docker/Compose
• Nginx
• Linux (Ubuntu)
• WireGuard
• Certbot
• UFW
• Authelia
• Redis

A full-featured schedule management system built for my university and actively used by students. The backend is a FastAPI application with SQLAlchemy ORM, PostgreSQL database (7 tables), and JWT authentication with role-based access (admin/user). The admin panel provides full CRUD for lessons, users, and dynamic filter system (groups, specializations). Schedule data can be imported from JSON using a companion desktop tool built with Python Tkinter. The whole stack runs in Docker Compose (3 containers: PostgreSQL + FastAPI + Nginx) with Let's Encrypt SSL.

• Python
• FastAPI
• PostgreSQL
• SQLAlchemy
• JWT
• Docker Compose
• Nginx

A web application that solves the problem of a slow and unstable university schedule API by providing a fast, cached interface. The backend is Flask with Celery for asynchronous task processing and Redis as the message broker. Schedule data is cached in SQLite with a 4000-hour TTL, and async Celery workers handle background refresh. The frontend is a Progressive Web App (PWA) with Service Worker for offline support, bookmarks, dark theme, and weekly navigation. Rate limiting (100/min, 10/sec) protects the upstream API. Deployed on VPS via Docker Compose (4 services).

• Python
• Flask
• Celery
• Redis
• SQLite
• Docker Compose
• PWA

A Discord bot written in Python (~2,500 lines) using discord.py. It provides music playback via yt-dlp and FFmpeg with queue management, a ticket system for server moderation, and various utility commands. The bot runs as a Docker container on my VPS and serves multiple Discord servers.

• Python
• discord.py
• yt-dlp
• FFmpeg
• Docker

End-to-end encrypted messaging and file transfer system with a server-client architecture. Uses NaCl/libsodium public key cryptography (Curve25519 key exchange, XSalsa20 stream cipher, Poly1305 MAC) over raw TCP sockets. Features encrypted multi-client chat, encrypted file storage on the server, and a curses-based terminal UI with status bar and input line. ~845 lines of Python.

• Python
• NaCl/libsodium
• Curve25519
• TCP Sockets
• curses
• Threading

A real-time multiplayer blackjack game with 3D visualization. Up to 5 players at one table with full game mechanics (Hit, Stand, Double Down, Surrender, Insurance, 6-deck shoe). The frontend renders cards in 3D using Three.js with GSAP animations for dealing and flipping. Real-time synchronization via Socket.IO, in-game VIP chat, sound effects, and an admin panel for table management.

• Node.js
• Three.js
• Socket.IO
• GSAP
• Express
• Docker

Web service for comparing Steam libraries of two players and finding common co-op games. Features multiplayer type filtering (Co-op, PvP, Online, Local), random game roulette, sorting by total playtime, and a “Pile of Shame” filter for games under 2 hours. Metadata cached in SQLite with 7-day TTL. Deployed on VPS behind Nginx.

• Python
• FastAPI
• SQLite
• Steam API
• Docker

Telegram bot that captures user messages (text, photos, stickers, voice) and forwards them to admins with inline reply capabilities. Built with Aiogram 3.14 and asyncio, featuring FSM-driven admin workflows for replies and broadcasts. ~530 lines of Python.

• Python
• Aiogram
• asyncio
• FSM