Arseni Aliakseichyk

CyberGlove is my flagship personal project — an IoT smart glove designed for real-time gesture recognition and control. The firmware runs on an ESP32-S3 using ESP-IDF and FreeRTOS. The glove captures motion data from an ICM-20948 9-DoF IMU (accelerometer + gyroscope) over SPI, and finger bend angles from a custom fiber optic sensor read through the ESP32's 12-bit ADC. All sensor data is streamed at 50 Hz over WebSocket to a web dashboard for real-time visualization. The device connects via Wi-Fi in Station mode with automatic reconnection logic.

• C
• ESP-IDF
• FreeRTOS
• SPI
• ADC
• ICM-20948
• WebSocket
• Wi-Fi

During my internship at GlobalLogic Poland (Koszalin), I worked in a 4-person Agile/SCRUM team building a modular robotic platform. 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. I was responsible for the motion control system, obstacle detection module, and video streaming pipeline. We used Jira for sprint planning and 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 STM32F407VGT6 (ARM Cortex-M4, Discovery board) where I explored both the HAL library and direct register-level programming. These projects covered the core peripherals of the STM32: GPIO configuration, timer-based PWM generation for motor and LED control, NVIC interrupt handling, communication protocols (SPI, I2C, UART), and analog signal processing through ADC and DAC. All debugging was done using a LA1010 logic analyzer and oscilloscope connected via JTAG/GDB.

• C
• STM32 (ARM Cortex-M4)
• HAL/CMSIS
• 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

ChillMove is 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

Cross-platform Flutter fitness application for children, built with BLoC state management pattern, Firebase backend (Firestore + Auth + FCM), and GoRouter for declarative navigation. The app is in production with Firestore real-time sync and push notifications delivered through the self-hosted notification worker.

• Flutter
• Dart
• Firebase
• BLoC
• GoRouter

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