--> 🤖 Click to jump to Robotics + Simulation and GUI Projects section 🤖 <--

Machine Learning (ML) / Deep Learning (DL) / Natural Language Processing (NLP)

• ML/NLP: 2020 U.S. Election Twitter Sentiment Analysis — Collected over 3M tweets using the Twitter API, performed data cleaning and preprocessing, and applied TF-IDF vectorization with Logistic Regression and Naive Bayes classifiers to predict sentiment (positive, negative, neutral) toward presidential candidates. Analyzed trends over time and visualized sentiment distributions using matplotlib and seaborn. Tech: Python, scikit-learn, pandas, NumPy, matplotlib, seaborn, Twitter API, NLP, sentiment classification
• Netflix Challenge — Movie Rating Prediction [report] — Built an Item-Item Collaborative Filtering system using Pearson correlation (centered cosine similarity), achieving RMSE 0.84991 on Kaggle (rank 1/250+). Tuned nearest neighbors N, applied rating capping, and tested dynamic N selection; added cold-start handling via local deviation adjustment; evaluated on held-out datasets via Kaggle API. Tech: Python, NumPy, Pandas, Kaggle API.
• ML/DL: Prediction of Gait Freezing in Parkinson’s Disease — Built machine learning models (LSTM and CNN) to detect and predict gait freezing episodes from wearable sensor data in PD patients. Achieved competitive accuracy in classification tasks and evaluated models with confusion matrices and ROC curves. Tech: MATLAB, Deep Learning Toolbox.
• ML/NLP: Stock Price Prediction via News Sentiment — WIP: Building a machine learning model to forecast stock trends based on financial news sentiment, combining text analytics with historical market data. Tech: Python, Pandas, scikit-learn, NLP, sentiment analysis, time series forecasting

Computer Graphics (CG)

• CG: Ray Tracer — Implemented a ray tracing engine from scratch, supporting recursive reflections, refractions, Phong shading, and multiple light sources. Tech: C++, OpenGL (for preview), image output to PPM.

Computer Vision (CV) / Robotics

• ML/CV: Semantic Segmentation — Developed computer vision pipeline to classify each pixel into semantic categories, enabling scene understanding for downstream robotics tasks. Benchmarked against BiSeNet. Tech: Python, OpenCV, PyTorch
• CV: Object Contour Detection & Following — Implemented contour detection to identify and track object boundaries in real time, integrating with motion control for robotic following. Tech: Python, OpenCV, edge detection, contour extraction
• Robotics: Line-Following Music Robot — A line-following robot that converts varying grayscale levels into corresponding sound frequencies, integrating motion control with auditory feedback. Tech: Arduino programming, hardware design (MOSFET, motors), sensor integration, algorithm design

Hardware / Embedded Systems

• Verilog: FPGA Music Player — Designed and implemented a music playback system on an Altera DE2 FPGA board, supporting WAV audio decoding, SD card file I/O, real-time playback control, and synchronized LED visual effects. Implemented hardware control for push buttons and switches, along with modular Verilog design for audio output via the audio codec chip. Tech: Verilog, C, Quartus Prime, Altera DE2, Audio Codec, SD Card I/O.
• Verilog: Kirsch Edge Detection — Implemented the Kirsch operator in Verilog for 8-directional edge detection on grayscale images, optimized for high-throughput processing in FPGA-based systems. Tech: Verilog, FPGA design, hardware optimization, image processing algorithms

Apps & Software Tools

• App Development: 2048 Game (Android) — Implemented both touch swipes and sensor control: shake/tilt in each direction to trigger moves, using the device accelerometer with a high-pass filter to detect directional impulses. Smooth animations and score/undo included. Tech: Java (Android Studio), SensorManager (Accelerometer), View animations.
• Matrix Calculator (CLI) — Implemented a matrix computation suite (for integers only) with file/terminal input, supporting arithmetic, linear algebra solvers, and property analysis (rank, determinant, transpose, power), with Python helpers for matrix generation and result validation. Tech: C (core), Python (generation & validation).

Simulation-Driven Web Game (Stealth project; WIP)

A real-time, military-themed, multiplayer, semi-automation/incremental webgame. Designed for maintainability, expandability, and performance — built entirely from scratch with no templates.

I designed and implemented both front-end and back-end systems, including user authentication, language localization, and gameplay logic — all while self-learning full-stack development and Vue.

• Vue 3 + Vite: Reactive front-end framework with lightning-fast build system
• TypeScript: Static typing for code robustness and maintainability
• Pinia: Centralized state management for UI/data sync
• BEM CSS: Structured CSS for consistent styling
• UI/UX design: Custom layout for dashboard and card interface
• Node.js: Server logic and API endpoints
• MongoDB Atlas: Cloud-hosted database for users, teams, and game state
• JWT Auth: Secure user authentication
• CORS config: Safe cross-origin API calls
• WebSocket: Real-time multiplayer chat and game state updates
• Axios: Standard API requests
• Browser storage: Persistent user settings and localization
• Jest: Unit tests
• GitHub Actions: CI/CD
• Core game design: Real-time sim engine, progress bars, idle/active hybrid
• Anti-hacking logic: Defensive coding and validation
• User system: Account, login, progress tracking
• Resource system: Mining, construction, conversion, storage
• Dashboard: Teams, missions, reports
• Design thinking: Future-proofing, reusability, coherence
• vibe-coding: Accelerated development using code suggestions

Fill-Game, with AI Opponents [GitHub] [report]

A two-player, adversarial version of Fillomino—built with heuristic search algorithms to support both PvE (Human vs. AI) and PvP (Human vs. Human) play.

Implemented in modern C++ (with a Qt GUI), and featuring a variety of search strategies—Depth-First Proof Number Search (DFPN), Proof Number Search (PNS), Minimax & Negamax (each with alpha-beta pruning and transposition tables), plus Monte Carlo Tree Search (MCTS).

• C++ 20
• Qt (cross-platform GUI)
• DFPN, PNS: Strategic search planning
• Minimax / Negamax w/ alpha-beta pruning & transposition tables
• MCTS: Probabilistic, long-horizon planning
• Cross-machine & local play
• Unit tests & performance tuning
• Profiler: Valgrind, KCachegrind

Reinforcement Learning: IRB2600 Welding Task Simulation

A simulation of an ABB IRB2600 robot executing a welding operation in a virtual environment. The project focused on task-specific motion planning, welding path generation, and fine-tuning joint trajectories for smooth and accurate operation.

Combined industrial simulation software with scripting to automate and visualize welding processes before deployment. I also benchmarked reinforcement learning approaches — Proximal Policy Optimization (PPO) and Soft Actor-Critic (SAC) — to evaluate their performance in learning efficient welding paths.

• RL Algorithms: PPO, SAC
• Python: Welding path scripting, RL benchmarking
• Lua: Custom motion control in CoppeliaSim (V-REP)
• CoppeliaSim (V-REP): Kinematics and task validation
• Ubuntu: Development and runtime environment

Dual Simulation: IRB2600 with ABB RobotStudio and CoppeliaSim (V-rep)

A simulation project demonstrating motion planning and execution for the ABB IRB2600 industrial robot arm. Developed using a mix of scripting and simulation tools to bridge virtual prototyping with real-world robotics workflows.

The work included creating robot motion sequences, integrating with ABB RobotStudio for visualization, and using CoppeliaSim (formerly V-REP) for simulation and control logic testing on Ubuntu.

• Python: Control scripts and data handling
• Lua: Embedded scripting for CoppeliaSim (V-REP)
• ABB RobotStudio: Industrial robot simulation and programming
• CoppeliaSim (V-REP): Physics-based robot simulation
• Ubuntu: Development and runtime environment

OMPL LazyPRM Obstacle Avoidance

A motion planning demo using the Open Motion Planning Library (OMPL) with the LazyPRM algorithm to navigate around obstacles. Demonstrates efficient graph-based planning for environments with complex geometry.

• OMPL: LazyPRM motion planning
• Python: Planning orchestration and visualization
• Ubuntu: Development and runtime environment

Husky UGV — Teleop & Camera Perception (Gazebo + RViz)

A simulation and control stack for Clearpath’s Husky UGV: keyboard teleoperation in Gazebo with live camera streams visualized in RViz. Includes topic wiring, launch files, and a minimal perception pipeline for testing navigation behaviors in a sandboxed environment.

• ORB_SLAM3: localization and mapping
• ROS: node graph, topics, launch files
• Gazebo: physics simulation, Husky model/plug-ins
• RViz: visualization (camera/image topics, TF, robot model)
• teleop_twist_keyboard: WASD keyboard control
• Camera input: Gazebo camera / USB cam via image_transport
• Ubuntu: development & runtime
• rosbag: data capture & replay (optional)
• URDF/Xacro: robot model tweaks (optional)

BobaTron — Bubble Tea Self-Serving Machine [report]

Fully automated, tablet-operated bubble tea machine integrating dispensing, assembly/delivery, power, micro-controller, and user interaction subsystems. Built to cut wait time and ensure taste consistency, with precise feedback-controlled dispensing and contact-less mixing.

Highlights: load-cell feedback loop with pumps & Archimedes screw for accurate dosing; orbital shaker for hygienic mixing; tablet UI with Wi-Fi control; multi-Arduino network over I²C. The prototype meets key specs and produces a drink in ~70 seconds; the milk module actively cools from ~9.5 °C to ~3 °C in ~25 minutes.

• Control: Multi-Arduino network (I²C), ESP32 Wi-Fi server, tablet UI
• Dispensing: Diaphragm & peristaltic pumps, Archimedes screw, load-cell feedback
• Assembly/Mixing: Conveyor & cup dispenser, orbital shaker (contact-less)
• Power/Thermal: Regulated DC rails, Peltier cooling with temperature feedback
• Performance: ≈70 sec/drink;
• Cost: Prototype ≈ C$1,500 (under C$4,000 target)

WGViewer — Game Automation & GUI Tool [GitHub] [More Screenshots]

Developed a cross-platform GUI tool for Warship Girls, a popular mobile game in Asia, enabling advanced automation and in-depth game data management. The project reverse-engineered and integrated with the game’s API to provide full automated gameplay, equipment management, and resource optimization features. Achieved 50,000+ downloads from Chinese gaming forums.

• GUI Development: Built an intuitive, cross-platform interface using PyQt.
• Game API Reverse Engineering: Automated gameplay, resource/equipment tracking, and event handling.
• Automation Engine: Designed routines for fully unattended daily tasks, battles, and upgrades.
• Version Management: Created modular architecture to quickly adapt to frequent game updates.
• CI/CD: Set up GitHub Actions for automated builds and releases.
• Asset Organization: Structured resources for images, configs, and logs for maintainability.
• Performance Optimization: Improved memory and network efficiency for long-running sessions.

Mobile Game Automation & Reverse Engineering [GitHub]

A personal deep-dive into automation and memory-level reverse engineering of a real-time AR ARPG, Monster Hunter NOW (from Pokemon Go company). Explored mobile system behavior, game memory, and scripting logic.

• OpenCV + Vysor: Vision-based automation of hunting flows
• Python Scripting: Real-time control logic for timing, items, decisions
• Rooted Android: Elevated permissions for GPS spoofing
• GameGuardian: Address-based memory inspection for weapon stats
• APK reverse engineering: Decompiled client for hidden assets/keys (educational)

The system could hunt all monsters automatically. I was among the earliest to reach max level and a complete weapon collection via scripting and reverse engineering.