Skip to main content
Adam Mikael

CASE_STUDIES

Work

Selected work across AI/ML, XR/VR, parallel computing, telerobotics and 3D systems.

Featured technical work

CASE_01

ATC Voice Resilience Lab: Core Networking Prototype

A C++20 mission-critical voice networking lab for SIP/SDP call control, real RTP media resilience, deterministic fault injection, and live operational telemetry.

ATC Voice Resilience Lab is an mission-critical communications prototype developed from an empty C++20 toolchain skeleton into a reproducible version 1.0.1 release. It demonstrates signaling, media transport, fault handling, observability, security, testing, profiling, containerized delivery, and professional operational presentation within one coherent system. The prototype executes bounded SIP/SDP call flows between simulated controller and radio-gateway endpoints and transports real bidirectional synthetic G.711 PCMU frames over UDP through a C++ RTP relay. It records packet validation, forwarding, loss, jitter, duplication, and reordering metrics while deterministic scenarios exercise a healthy call, packet loss, Call-ID mismatch, and a live 30-second resilience sequence with healthy operation, complete media outage, recovery, stabilization, and clean teardown. A Boost.Asio and Boost.Beast gateway exposes local HTTP and WebSocket interfaces to a responsive browser dashboard. The dashboard presents scenario state, exact signaling and media timelines, live RTP counters, semantic component states, structured telemetry, independently resizable and exportable logs, run-isolated event streams, follow-latest controls, and a professional full-width monitoring layout. The final release includes loopback-only exposure, strict Host and Origin validation, bounded HTTP and WebSocket parsing, client limits, request throttling, security headers, CSP, structured overload handling, 171 unique automated tests, GCC and Clang validation, static analysis, sanitizers, coverage evidence, deterministic benchmarks, Docker-based build and packaging, Jenkins pipeline structure, a Conan lockfile, reproducible release archives, and complete documentation.

WHAT_I_BUILT

  • Designed the project scope and architecture around mission-critical air-traffic voice networking requirements
  • Implemented the C++20 RTP, PCMU, UDP, SIP, SDP, call-state and relay layers
  • Designed deterministic scenarios, virtual scheduling and the real-time resilience demonstration
  • Built the HTTP and WebSocket telemetry gateway with Boost.Beast
  • Created the complete browser dashboard and operational state model
  • Implemented packet metrics, event contracts, snapshots and run-isolation logic
  • Designed precise semantic mappings for endpoint, signaling, RTP and relay states
  • Added resizable monitoring panels, automatic drag scrolling and per-run log exports
  • Implemented local gateway security controls and structured overload behavior
  • Created unit, integration, stress, browser, security, delivery and benchmark tests
  • Configured GCC, Clang, Clang-Tidy, sanitizers and coverage workflows
  • Implemented CMake presets, install rules and automatic dashboard asset propagation
  • Created Docker multi-stage builds, Jenkins stages and deterministic release packaging
  • Produced the final version 1.0.1 release, checksums, source handoff and reproducibility evidence

TECH_STACK

C++20
Boost.Asio
SIP/SDP
RTP/UDP
Boost.Beast
G.711 PCMU
CMake
GoogleTest
HTTP
WebSocket
JavaScript
HTML5
CSS3
Docker
Jenkins
Conan 2
Ninja
GCC
Clang
Clang-Tidy
CTest
AddressSanitizer
UndefinedBehaviorSanitizer
LeakSanitizer
gcov/gcovr
Playwright
Chromium
Python
JSON
Linux
WSL2
Explore project

CASE_02

Parallel 3D Voxel Pattern Matching v2

High-performance 3D CT voxel pattern matching with optimized sequential, POSIX Threads and MPI implementations.

An end-to-end performance engineering project focused on processing thresholded 3D CT data and counting all ordered pairs of identical 4 × 4 × 4 voxel patterns. The project includes a fully optimized sequential implementation, a shared-memory POSIX Threads version, and a distributed-memory MPI version. The original quadratic approach required approximately 1.1 trillion pairwise comparisons. It was redesigned around direct `uint64_t` bitmask generation, 8-pass LSD radix sorting, and linear aggregation of equal-value runs. This reduced the computation from tens of seconds or minutes to milliseconds while preserving the exact result across every implementation and benchmark configuration.

WHAT_I_BUILT

  • Designed the optimized end-to-end algorithm for 3D voxel pattern matching
  • Replaced the original O(n²) comparison strategy with radix sorting and linear run aggregation
  • Implemented the sequential reference solution in C
  • Developed the shared-memory implementation using POSIX Threads
  • Developed the distributed-memory implementation using C++17 and MPI
  • Designed compact uint64_t encoding for 4 × 4 × 4 voxel blocks
  • Implemented stable eight-pass LSD radix sorting
  • Designed local run compression and distributed mask ownership for MPI
  • Optimized memory layout, allocation strategy, synchronization, and communication
  • Created repeatable benchmark procedures across multiple thread and process configurations
  • Validated correctness against the expected result of 970,777,711,592 ordered matching pairs
  • Analyzed scalability limits caused by synchronization, memory bandwidth, and MPI communication overhead
  • Prepared complete technical documentation and benchmark reporting in English and Slovak

TECH_STACK

C
C++17
POSIX Threads
MPI
Algorithm Optimization
Performance Engineering
Open MPI
LSD Radix Sort
uint64_t Bitmask Encoding
Shared-Memory Parallelism
Distributed-Memory Computing
3D CT Voxel Processing
Performance Benchmarking
GCC/G++
Ubuntu 24.04 LTS
WSL2
Explore project

CASE_03

Telerobotic Digital Twin for the xArm 1S

Hand-tracked XR control connected through ROS2 to a real-time Unity digital twin.

This project explores an intuitive approach to remote robotic control by combining immersive interaction, ROS2 communication and a real-time Unity digital twin. A Meta Quest 3 application provides a hand-tracked XR control panel that allows the operator to command each joint of a 6-DOF xArm 1S without physical controllers. The XR application publishes joint positions as ROS2 JointState messages, while a desktop Unity application subscribes to the same data and maps the received values to an articulated URDF-based robot model. The digital twin updates in real time through Unity ArticulationBody drives, preserving joint limits and synchronized movement across the robotic arm. The system was developed as a functional end-to-end prototype and designed with future physical deployment in mind. By replacing the simulated robot with a ROS2-connected xArm 1S, the same control architecture could be extended from digital-twin interaction to real-world telerobotic operation.

WHAT_I_BUILT

  • Designed the end-to-end XR telerobotics system architecture.
  • Developed the Meta Quest 3 hand-tracked control interface in Unity.
  • Implemented virtual XR controls for independent manipulation of all six robot joints.
  • Integrated ROS2 communication between the XR application and the desktop digital twin.
  • Implemented ROS2 JointState publishing and subscription through the /joint_states topic.
  • Imported and configured the URDF-based xArm 1S model in Unity.
  • Developed real-time mapping of ROS2 joint data to Unity ArticulationBody components.
  • Implemented radians-to-degrees conversion and joint-limit-aware target control.
  • Configured articulation stiffness, damping, force limits and movement behavior.
  • Implemented synchronized mirrored control of the two-sided robotic gripper.
  • Developed and tested the complete prototype using ROS2 on Ubuntu and Unity applications.
  • Prepared the modular control pipeline for future integration with a physical xArm 1S robot.

TECH_STACK

ROS2
Unity
C#
Ubuntu
Hand Tracking
XR
Meta Quest 3
OpenXR
Meta XR SDK
ROS TCP Connector
URDF
ArticulationBody
sensor_msgs/JointState
Explore project

CASE_04

XR/VR Rehabilitation System

Cross-platform XR rehabilitation with hand tracking, upper-limb exercises and multi-user therapy sessions.

Unity/C# system enabling therapists and patients to perform guided upper-limb rehabilitation exercises in a shared virtual environment. Implements OpenXR and Meta XR interaction rigs, real-time hand and finger synchronization, hybrid hand/controller input and configurable avatar scaling. Tested on Meta Quest 2 and 3.

WHAT_I_BUILT

  • Designed and implemented two hand-tracking-compatible XR rigs using OpenXR and Meta XR workflows
  • Developed controller-free hand interaction with virtual hand visualization and tracked finger articulation
  • Integrated inverse kinematics for real-time synchronization between tracked hands and full-body avatars
  • Implemented near, far, poke, grab, ray, teleport and object-use interactions for rehabilitation tasks
  • Extended Mirror Networking to synchronize hand transforms, finger movement and interaction state across participants
  • Added hybrid switching between hand tracking and physical controllers while preserving avatar and interaction state
  • Implemented configurable scaling for the full avatar, arms, hands and palms
  • Validated functionality and runtime performance on Meta Quest 2 and Meta Quest 3

TECH_STACK

Unity
C#
OpenXR
Meta XR SDK
XR Interaction Toolkit
XR Hands
Mirror Networking
Final IK
Hand Tracking
Inverse Kinematics
Multiplayer Systems
Real-Time 3D
Meta Quest 2/3
Explore project

CASE_05

AI Cardiovascular Risk Application

AI-powered cardiovascular risk assessment with clinical inputs, predictive modeling and interpretable health insights.

Python desktop application that processes structured patient data, runs a trained TensorFlow/Keras neural network and stores measurement results locally for later review. The system combines data preprocessing, offline inference and a CustomTkinter interface in a complete end-to-end machine learning workflow.

WHAT_I_BUILT

  • Selected and prepared the cardiovascular dataset for supervised classification
  • Designed the preprocessing pipeline for structured patient features
  • Applied numerical standardization and class balancing with SMOTE
  • Designed, trained and tuned the TensorFlow/Keras neural network
  • Implemented early stopping and train/test evaluation workflows
  • Evaluated model performance using accuracy, precision, recall, F1-score and a confusion matrix
  • Serialized the trained model and preprocessing components for offline reuse
  • Integrated model inference into the CustomTkinter desktop application
  • Implemented patient configuration, prediction and measurement-history workflows
  • Added local persistence for completed measurements without external services

TECH_STACK

Python
TensorFlow/Keras
Scikit-learn
Pandas
CustomTkinter
NumPy
SMOTE
StandardScaler
Pickle
Matplotlib
Seaborn
Local Database
Offline Inference
Neural Networks
Data Preprocessing
Explore project

CASE_06

Parallel 3D Voxel Pattern Matching v1

Sequential, multithreaded and distributed 3D voxel search across volumetric CT datasets.

This project investigates parallel approaches to detecting 4 × 4 × 4 voxel patterns inside volumetric 3D CT datasets. The goal is to compare multiple execution models while preserving identical matching logic and result accuracy across implementations. The sequential version establishes a correctness and performance baseline in C. A POSIX Threads implementation distributes the search across multiple CPU threads within shared memory, while an MPI implementation partitions the workload across independent processes for distributed-memory execution. Each implementation scans the 3D voxel volume, evaluates candidate subvolumes and compares them against the target pattern. The project focuses on workload decomposition, synchronization, data distribution, boundary handling and performance measurement across different levels of parallelism. The result is a comparative parallel computing prototype that demonstrates how the same 3D search problem behaves under sequential, multithreaded and distributed execution models, providing a foundation for further optimization and scalability testing.

WHAT_I_BUILT

  • Designed the complete sequential and parallel solution architecture.
  • Implemented the baseline 3D voxel pattern-matching algorithm in C.
  • Developed the 4 × 4 × 4 sliding-window comparison logic for volumetric CT data.
  • Created the POSIX Threads implementation for shared-memory parallel execution.
  • Partitioned the search space across worker threads while preserving complete coverage.
  • Implemented thread-local result collection and final aggregation.
  • Developed the MPI implementation for distributed-memory processing.
  • Designed workload distribution across MPI ranks and coordinated partial computations.
  • Implemented boundary-aware partition handling to prevent missed pattern matches.
  • Aggregated distributed match results into a unified final output.
  • Maintained identical matching behavior across sequential, multithreaded and distributed versions.
  • Measured and compared execution time, speedup, scalability and parallel overhead.
  • Validated result consistency across all three implementations.
  • Structured the project for future optimization, larger datasets and alternative parallel strategies.

TECH_STACK

C
POSIX Threads
MPI
Parallel Computing
Multithreading
Distributed Computing
Shared Memory
Distributed Memory
3D Voxel Data
CT Imaging
Pattern Matching
Performance Benchmarking
Explore project

CASE_07

Functional Full-Stack RAG Document Intelligence System

Upload PDF documents and query them through semantic retrieval and context-grounded AI responses.

This project delivers a full-stack Retrieval-Augmented Generation system for querying PDF documents through natural language. Users can upload files, manage the indexed document collection and interact with a conversational interface that generates answers grounded in the uploaded content. The backend processes each PDF by extracting its text, dividing it into overlapping chunks and converting those chunks into OpenAI embeddings. The resulting vectors are stored in Supabase with pgvector support, enabling semantic similarity search across the document collection. When a user submits a question, the system retrieves the most relevant document sections, assembles them into a structured context and sends that context to an OpenAI chat model. The prompt is designed to keep responses grounded in the retrieved material and to avoid fabricating information when the answer is not present in the documents. The application combines a Next.js and TypeScript frontend with a NestJS backend, LangChain orchestration and a Supabase vector store. The result is a functional document-intelligence platform that demonstrates the complete RAG lifecycle from ingestion and indexing to retrieval and context-aware answer generation.

WHAT_I_BUILT

  • Designed the end-to-end architecture of the full-stack RAG application.
  • Developed the PDF ingestion and text extraction pipeline using LangChain.
  • Implemented context-preserving document chunking with configurable size and overlap.
  • Integrated OpenAI embeddings for semantic representation of document content.
  • Configured Supabase PostgreSQL with pgvector for persistent vector storage and retrieval.
  • Implemented semantic similarity search to retrieve the most relevant document chunks for each query.
  • Built the grounded question-answering pipeline that combines retrieved context with user prompts.
  • Designed prompt safeguards to reduce hallucinations and handle missing information transparently.
  • Developed the NestJS backend for document upload, indexing, querying, listing and deletion.
  • Built the Next.js and React frontend for file management and conversational document search.
  • Integrated the frontend, backend, vector database and OpenAI services into one functional system.
  • Created a modular architecture that allows retrieval settings, models and storage components to be replaced independently.

TECH_STACK

RAG
OpenAI
LangChain
React
Next.js
TypeScript
NestJS
Supabase
PostgreSQL
pgvector
Vector Embeddings
Semantic Search
PDFLoader
RecursiveCharacterTextSplitter
Tailwind CSS
shadcn/ui
REST API
Explore project

CASE_08

Earthquake Data ETL and Monitoring API

Automated USGS earthquake ingestion, validation, storage and statistical monitoring through a documented FastAPI service.

This project implements a complete data pipeline for collecting, processing and serving recent earthquake information. It retrieves event data from the USGS GeoJSON feed, validates and transforms the raw records and stores the normalized results in a local SQLite database. The FastAPI backend exposes the processed dataset through a documented REST API. Users can retrieve earthquake events, filter records by minimum magnitude and access aggregated statistics such as daily summaries and tsunami-alert counts. Each event includes key attributes such as magnitude, location, timestamp, coordinates, depth and tsunami status. Pydantic models are used to enforce consistent data structures across the ingestion and API layers. The result is a functional data-engineering service that demonstrates the full lifecycle of external data acquisition, ETL processing, relational storage, filtering, aggregation and API delivery.

WHAT_I_BUILT

  • Designed the complete earthquake data ingestion and API architecture.
  • Implemented automated extraction from the USGS GeoJSON feed.
  • Developed transformation logic for nested earthquake event data.
  • Normalized identifiers, magnitudes, locations, timestamps, coordinates, depths and tsunami indicators.
  • Created Pydantic models for validation and consistent data structures.
  • Designed and implemented persistent SQLite storage for processed events.
  • Built FastAPI endpoints for earthquake retrieval and magnitude-based filtering.
  • Implemented daily statistical summaries from stored seismic records.
  • Developed tsunami-alert aggregation for risk-oriented analysis.
  • Integrated Swagger and OpenAPI documentation for interactive API testing.
  • Separated extraction, transformation, persistence and API delivery into maintainable layers.
  • Prepared the backend architecture for future dashboards, alerting systems and geospatial extensions.

TECH_STACK

Python
Data Engineering
ETL
FastAPI
REST API
USGS API
GeoJSON
SQLite
Pydantic
Data Validation
Data Transformation
Statistical Aggregation
OpenAPI
Swagger
Explore project

CASE_09

Adaptive Clicker Automation Game

A Java Swing clicker game that learns the player’s rhythm and turns it into adaptive automated progression.

This project is a Java Swing desktop clicker game built around adaptive automation and progressive gameplay. The player manually increases or decreases the score while the application records the timing between clicks and calculates an average interaction interval. After the training phase, the game can reproduce the learned clicking rhythm automatically, creating a lightweight self-adapting control system without using a traditional machine-learning model. The automation supports both score directions and integrates with the broader progression mechanics. The game includes unlockable vehicles, speed multipliers, fuel consumption, refueling, temporary boosts and achievement milestones. Progression advances from a car to an airplane and finally to a rocket, with each stage introducing stronger scoring effects and additional visual feedback. A custom Swing interface presents animated elements, score updates, unlock states and an endgame starfall sequence in which the player can collect falling bonuses. The project demonstrates desktop UI development, event-driven programming, timing analysis, state management and game-mechanic design in Java.

WHAT_I_BUILT

  • Designed the complete architecture and gameplay loop of the Java desktop application.
  • Developed the adaptive click-timing system that records manual input intervals and calculates the player’s average rhythm.
  • Implemented automated score progression based on the learned clicking interval.
  • Created bidirectional score controls for both increasing and decreasing progression.
  • Designed and implemented the vehicle progression system with car, airplane and rocket stages.
  • Added vehicle-specific scoring multipliers and unlock conditions.
  • Implemented fuel consumption, refueling and temporary speed-boost mechanics.
  • Developed the achievement system and milestone-based progression logic.
  • Built the Java Swing user interface with custom components, controls and real-time state updates.
  • Implemented timer-driven animations, visual feedback and interactive game events.
  • Created the final starfall sequence with clickable bonus objects and victory logic.
  • Managed the complete application state across automation, scoring, vehicles, achievements, fuel and endgame behavior.
  • Structured the code to keep gameplay logic, state management and user-interface behavior maintainable and extensible.

TECH_STACK

Java
Java Swing
Desktop Application Development
Event-Driven Programming
Adaptive Automation
Timing Analysis
Game Development
Custom UI Components
Animation
State Management
Achievement System
Vehicle Progression
Explore project

INDEX

Additional work

Supporting capability areas and adjacent technical work. Contact me to discuss scope and collaboration.