Projects Portfolio

LOCUS FIT

🚀 Active Development

Know Where You Are. Know What You Lift.

LOCUS FIT is an automatic workout logging system that eliminates the friction of manual tracking. Simply bring the Puck to your workout, lift, and your exercises, weights, and reps are logged automatically, so you can focus on training, not typing.

The Problem

Manual workout logging is broken. Most fitness apps are abandoned within weeks because entering every set, rep, and weight mid-workout kills momentum and flow. Athletes know that consistent tracking leads to faster progress, but the tools make it too hard to stay consistent.

The Solution

LOCUS FIT uses spatial context technology to understand what you're doing without any input from you. The gym becomes aware of your workout, automatically detecting exercises, counting reps, and tracking weights in real-time.

What You Get

• Zero-Friction Logging: No buttons, no typing, no app switching, just lift and go
• Automatic Exercise Detection: The system knows what movement you're performing
• Precise Rep Counting: Every rep tracked accurately without manual input
• Weight Tracking: Automatic detection of the load you're lifting
• Progress Insights: See your training history and progress over time
• Works Anywhere: Take the Puck to any gym, it works with standard equipment

Current Status

LOCUS FIT is in active development with a working prototype. Currently running a pilot program at Dalhousie University with plans to launch in 2026. The product website is live at locus.fit.

My Role

As the founder and sole developer, I'm responsible for the complete product vision, from hardware design and embedded software to the mobile app and marketing website. This project demonstrates my ability to take a product from concept through prototype to market launch.

Skills Applied

• Product Development: End-to-end product design from concept to working prototype
• Full-Stack Development: Hardware, embedded software, mobile app, and web development
• User Experience: Designing for zero-friction user interaction
• Entrepreneurship: Market research, pilot programs, and go-to-market strategy

Red Light Green Light Brain Computer Interface

SURGE BrainHack Fall 2025 (Winner): An innovative EEG-controlled survival game that adapts the classic "Red Light, Green Light" concept into an immersive brain-computer interface experience. Players control their avatar's movement speed using real-time alpha/beta brainwave analysis from OpenBCI EEG hardware.

Competition Report (PDF)

Game Concept

A survival-mode adaptation where there is no finish line, players must stay alive by not going off-screen while avoiding randomly passing cars. The twist: EEG brain data controls avatar speed, with higher alpha wave activity resulting in faster movement. During red lights, avatars move backwards; during green lights, they move forward. The last player standing wins.

Brain-Computer Interface Implementation

• Real-time EEG Processing: OpenBCI Cyton board integration with BrainFlow for live data streaming
• Alpha/Beta Wave Analysis: Welch's method for power spectral density analysis of brain waves
• Adaptive Control System: Player 1 controlled by real EEG alpha/beta ratio, Player 2 uses simulated values for comparison
• Graceful Fallback: Automatic fallback to test mode when no EEG hardware is detected
• Real-time Feedback: Live visualization of brainwave ratios and movement speed multipliers

Technical Architecture

• Game Engine: Built from scratch using Python and Pygame for real-time rendering
• Signal Processing: NumPy and SciPy for EEG data analysis and frequency domain processing
• Hardware Integration: BrainFlow library for OpenBCI board communication and data acquisition
• Perspective Rendering: Custom 3D perspective system for road simulation and depth perception
• State Management: Traffic light finite state machine with randomized timing intervals

Advanced Features

• Dynamic Difficulty: Car hazards spawn randomly with varying speeds and positions
• Collision Detection: Sophisticated hitbox system accounting for perspective scaling
• Visual Effects: Real-time fog rendering, animated traffic lights, and player movement feedback
• Dual Player System: Simultaneous control for competitive gameplay (A/D vs Arrow Keys)
• Performance Optimization: Efficient sprite caching and scaling for smooth 60fps gameplay

EEG Signal Processing Pipeline

• Data Acquisition: 250Hz sampling rate from 8-channel EEG headset
• Preprocessing: DC offset removal and artifact filtering
• Frequency Analysis: Real-time FFT processing for alpha (8-12Hz) and beta (12-30Hz) band extraction
• Ratio Calculation: Alpha/beta power ratio computation with fallback mechanisms
• Movement Translation: Direct mapping of brainwave ratios to movement speed multipliers

Development Achievements

• Complete Game Development: Built entire game engine from scratch in Python within hackathon timeframe
• BCI Integration: Successfully implemented real-time brain-computer interface with OpenBCI hardware
• Team Collaboration: Led technical development while collaborating with Paras on BCI implementation
• Problem Solving: Overcame real-time signal processing challenges and hardware integration issues
• Innovation: Created novel application of BCI technology for interactive gaming

Skills Demonstrated

• Brain-Computer Interface Development: EEG signal processing, real-time data analysis
• Game Development: Physics simulation, collision detection, real-time rendering
• Signal Processing: FFT analysis, frequency domain filtering, power spectral density
• Hardware Integration: OpenBCI board interfacing, serial communication protocols
• Python Programming: NumPy, SciPy, Pygame, real-time system development
• Team Leadership: Technical project coordination and collaborative development

Technologies Used

Python, Pygame, NumPy, SciPy, BrainFlow, OpenBCI Cyton Board, EEG signal processing, real-time data visualization, and competitive game design principles.

View on GitHub

Arduino Security System

Overview

This project implements a microcontroller-based security system with sensor inputs and audible/visual alerts. See the full design write-up for specifications, design decisions, and evaluation results.

Architecture

• Microcontroller platform
• Sensor inputs (e.g., motion/door)
• Output actuators (e.g., buzzer/LED)
• Arming/disarming and alert logic

Key Features

• Real-time monitoring and alerting
• Simple state machine to handle system modes
• Modular design to add or modify sensors

Testing & Validation

Functional tests cover normal, triggered, and reset conditions. Timing and debounce behavior are verified to ensure reliable activation without false alarms.

Read the detailed report for requirements, system diagrams, and measured results: Full Report (PDF) View on GitHub

Arduino Catapult System

Overview

A precision-engineered projectile launching system controlled by Arduino microcontroller with servo-driven targeting and release mechanisms. This project demonstrates mechanical engineering principles combined with embedded systems programming for automated control and targeting accuracy.

Architecture

• Arduino microcontroller platform with servo control libraries
• Servo motors for azimuth and elevation positioning
• Release mechanism with timing control
• Optional targeting system with distance sensors
• User interface for manual control and automated sequences

Key Features

• Precise angular positioning using servo feedback
• Programmable launch sequences and targeting patterns
• Safety interlocks and controlled firing mechanism
• Modular design for different projectile types
• Real-time control via serial interface or wireless communication

Testing & Validation

Accuracy testing across multiple distances and angles, repeatability analysis for consistent targeting, and safety validation to ensure controlled operation. Performance metrics include launch consistency, targeting precision, and mechanical reliability under repeated use.

Library Catalog

Overview

A lightweight cataloging system to manage books, authors, and categories with fast search and clean list/detail pages. Built to demonstrate structured data modeling, CRUD workflows, and CLI.

Architecture

• Core entities: Book, Author, Category/Genre
• CRUD flows for create, edit, delete, and view
• Search and filter pipeline across title, author, and tags

Key Features

• Keyword search with sort and filter
• Clean list, detail, and edit forms
• Validation for required fields and data consistency

Testing & Validation

Verified create/edit/delete flows, and search accuracy. Focused on usability and data integrity under typical usage.

Read the related course report for background and design rationale: Course Report (PDF) View on GitHub

Generations: Industrial Revolution

An elegant, swipe-choice narrative strategy game set in the Industrial Revolution. Balance four competing societal stats, climb the social ladder across generations, and survive the consequences of your decisions.

Live Demo

One-liner

A minimalist, mobile-friendly, card-driven game where every left/right choice shifts Wealth, Reputation, Health, and Stability. Pushing you toward ascension or collapse.

Overview

• Core loop: Drag or swipe a card left/right to choose; each choice alters multiple stats and advances the story.
• Multi-class progression: Start as a Laborer and, by hitting thresholds, ascend to Merchantile, Noble, and ultimately Royalty.
• Tight balance: Let any stat drop too low (or, for some classes, soar too high) and you trigger unique failure states and endings.
• Session-based play: On death or dynasty end, review your outcome and tap “Live Again” to restart instantly.

Core Mechanics

• Stats: Wealth, Reputation, Health, Stability with visible bar fills and threshold markers for next/previous milestones.
• Classes & thresholds: Each class defines ascension requirements and maximum bar sizes. Threshold markers help you plan risks and rewards.
• Card choices: Narrative cards present two options; outcomes are tuned per class via tags (e.g., laborer, merchantile, noble, royalty, opportunity, danger).
• Endings: Distinct end screens with title, message, and optional imagery; restart is one click.

Implementation Highlights

• Stack: HTML5 + CSS3 + Vanilla JavaScript (no frameworks, fully client-side, deploys as static site).
• Responsive UI: Fixed 2:3 card aspect ratio, image-first card composition with an overlaid gradient text container and large choice hints.
• Polished feedback: Subtle drag transforms, left/right swipe feedback halos, and animated stat bar updates.
• Thematic typography: Google Font Merriweather for narrative text; clean sans-serif for UI elements.
• Config-first design: Central class definitions and thresholds in script.js gate content and progression via card tags.

View on GitHub

Roguelike Card Adventure

A sophisticated web-based roguelike card game that combines traditional poker mechanics with strategic artifact collection and enemy encounters. Built with pure HTML5, CSS3, and vanilla JavaScript.

Live Demo

Overview

Roguelike Card Adventure is a single-page web application inspired by Balatro that challenges players to defeat enemies using poker hands formed from playing cards. The game features a progressive difficulty system, collectible artifacts that modify gameplay mechanics, and smooth CSS animations for enhanced user experience.

Core Gameplay Mechanics

• Poker-Based Combat System: Players form traditional poker hands (Royal Flush, Straight, etc.) to deal damage
• Strategic Card Management: 8-card hand limit with deck shuffling and discard pile mechanics
• Progressive Enemy Encounters: 5 unique enemies with distinct AI patterns and special abilities
• Artifact Collection System: 9 unique artifacts that modify game rules and provide strategic depth

Technical Highlights

• Pure Vanilla JavaScript: No frameworks or libraries - demonstrates strong foundation in core web technologies
• Responsive CSS Design: Flexbox-based layout with mobile-friendly responsive design
• Advanced CSS Animations: Keyframe animations for card movement, damage indicators, and visual feedback
• Modular Architecture: Clean separation of game logic, UI management, and animation systems
• State Management: Comprehensive game state system handling multiple game phases

Advanced Systems

• Dynamic Hand Evaluation: Complex algorithm evaluating poker hands with artifact modifications
• Animation Queue Management: Smooth transitions and visual feedback for all player actions
• Damage Calculation Engine: Multi-layered system incorporating base damage, hand scores, and artifact bonuses
• Enemy AI Patterns: Unique attack patterns and special abilities for each enemy type

Game Features

• Combat System: Royal Flush (250 damage), Straight Flush (150 damage), Four of a Kind (100 damage)
• Artifacts: "Sapphire Lens" reduces flush requirement, "Berserker's Pact" provides damage bonus with risk
• Enemies: Goblin Grunt (150 HP), Slime Cube with healing (200 HP), Shadow Mage with drain (250 HP), Orc Brute (300 HP), The Card Master boss (500 HP)
• Single File Implementation: Entire game contained in one HTML file for easy deployment

Skills Demonstrated

• Frontend Development: HTML5, CSS3, JavaScript (ES6+)
• Game Development: State management, game loops, animation timing
• Algorithm Design: Card shuffling, hand evaluation, damage calculation
• Code Architecture: Modular design, clean code principles

View on GitHub

Daily Nutrition Tracker

A comprehensive web-based nutrition tracking application built with vanilla JavaScript, featuring interactive data visualizations and persistent local storage.

Live Demo

Overview

The Daily Nutrition Tracker is a full-featured single-page application that helps users monitor their daily nutritional intake through an intuitive interface with real-time visual feedback. The app demonstrates proficiency in front-end development, data management, and user experience design.

Key Features

• Interactive Data Visualization: SVG-based animated progress rings for macronutrients with real-time updates
• Balance Score Algorithm: Intelligent scoring system based on macro ratios, target achievement, and dietary variety
• Persistent Storage: Client-side data persistence using localStorage API with data integrity validation
• Responsive Design: Mobile-first CSS Grid layout with smooth animations and intuitive navigation

Technical Implementation

• Frontend Technologies: JavaScript (ES6+), CSS3, HTML5, SVG with modern features like arrow functions and template literals
• Architecture Patterns: Component-based structure, event-driven programming, centralized state management
• Data Structures: Nutritional calculations with precision handling, efficient sorting and search algorithms
• Performance Features: Optimized rendering, memory management, lazy loading, smooth CSS animations

Core Functionality

• Ingredient Management: Dynamic ingredient creation with validation and automatic per-gram nutrition calculation
• Meal Composition: Create reusable meals from multiple ingredients with automatic nutritional aggregation
• Daily Logging: Date-specific food entries with historical tracking and running calculations
• Analytics Dashboard: Progress tracking with multi-factor balance scoring and contextual feedback

Skills Demonstrated

• Problem Solving: Complex nutritional calculation algorithms with mathematical precision
• Data Modeling: Efficient relational data structures and normalization
• Browser APIs: localStorage, Date API, advanced DOM manipulation
• Code Quality: Clean, maintainable, well-documented code with defensive programming

Technologies

JavaScript ES6+, HTML5, CSS3, SVG, localStorage API with mobile-first responsive design and progressive enhancement.

PaddleApp - Dragon Boat Team Management iOS Application

Work in Progress: A comprehensive iOS application designed for dragon boat racing teams, providing seamless team management, athlete coordination, and coaching tools. Developed in collaboration with SoftX Innovations as part of their product suite.

Overview

PaddleApp is built with modern SwiftUI architecture and Firebase backend integration, demonstrating full-stack mobile development capabilities with real-time data synchronization. This project showcases advanced iOS development skills while serving as a foundation for SoftX Innovations' sports team management solutions.

Key Features & Achievements

• Advanced Authentication System: Firebase Authentication with role-based access control for Athletes and Coaches
• Team Management Platform: Team creation, smart joining via unique IDs, and real-time roster updates
• Dynamic Dashboard System: Performance analytics with circular statistics for distance, stroke rate, and speed metrics
• Real-time Features: Live team member updates using Firestore listeners with instant UI synchronization

Technical Implementation

• Tech Stack: SwiftUI, Firebase (Firestore, Auth, Cloud Storage), iOS 18.2+ deployment
• Architecture: MVVM design pattern with clean separation of concerns and protocol-oriented programming
• Custom Components: Reusable UI library including InputView, TeamCardView, and StatisticCircle components
• Data Management: Real-time synchronization with comprehensive error handling and validation

Development Status & Collaboration

Currently in active development as part of a collaboration with SoftX Innovations, this project serves as both a learning experience in professional iOS development and a foundation for commercial sports management applications. The codebase demonstrates production-ready development practices with proper state management and scalable architecture.

Skills Demonstrated

• iOS Development: SwiftUI framework mastery, MVVM patterns, Xcode project management
• Backend Integration: Firebase SDK implementation, real-time database operations, cloud storage
• Software Engineering: Clean code architecture, component-based design, Git version control
• Professional Collaboration: Working with external development teams and commercial product requirements

Future Development

Planned enhancements include real-time chat systems, GPS-based activity tracking, advanced performance analytics, push notifications, and social team features. The app will continue evolving.

View on GitHub

FirefighterDEC Firefighting Drone Swarm

Dalhousie Engineering Competition Programming Category (Winner): Autonomous firefighting drone swarm simulation and visualization for Nova Scotia, built from scratch for the Dalhousie Engineering programming competition. Selected and funded by Dalhousie Engineering Society and Dalhousie Student Union after meeting competition criteria.

Competition Project C++ Port

Overview

A complete prototype system for firefighting drone swarm behavior, mapping, and visualization. The project simulated how a group of drones would explore a 550×300 grid, discover fires from limited local observations (1-tile radius), and influence an external environment file by dropping water. Built for the Dalhousie Engineering competition with no starter code provided our team implemented the full stack from first principles.

Environment Data Format

The competition specified that each map tile would be encoded as a fixed-length string where:

• Position encoding: 3 digits for x-coordinate (0-549), 2 digits for y-coordinate (0-299)
• Fire & weather: Fire severity (0-9), wind speed, wind direction (0-3)
• Entities: Citizen flag, firefighter flag, turns-since-seen, trust value
• Constraint: Drones could only act on tiles discovered through their 1-tile radius scan per round

Technical Challenges

• Zero Blueprint Design: No starter code or framework provided; designed encoding/decoding, mapping, drone scanning rules, and visualization from first principles
• Limited Observability: Drones operated with 3×3 vision windows per round, requiring intelligent exploration and memory management
• Interoperability: Python agent had to interface with coordinators' C environment writer (format mismatches prevented real-time integration during competition)
• Performance Visualization: 550×300 grid with dynamic overlays required careful Matplotlib artist reuse to avoid repaint overhead

My Role Lead Visualization Developer & System Integrator

As the visualization lead, I developed the complete interactive GUI showing historical vs predicted fire maps, drone positions, scan windows, citizens, firefighters, and wind vectors. I also helped design data structures and classes for the multi-agent system. Using seeded test data to demonstrate functionality, the visualization system featured:

• Fire Severity Heatmaps: Dynamic color-coded severity mapping (0-9 scale) with custom Matplotlib colormaps and transparent unmapped areas
• Multi-Drone Tracking: Real-time drone position tracking with historical path logging and 3×3 vision window visualization
• Entity Overlays: Citizen and firefighter position markers with real-time updates
• Wind Vector Display: Directional indicators showing fire spread dynamics
• Animated Rendering: In-place Matplotlib artist updates for performance, avoiding full repaint overhead on large grids
• GIF Export System: 1680×504 resolution output with background basemap support and rotation

Competition Outcome: Judges and coordinators specifically praised the visualization work as a standout element. While our Python program encountered format/interop issues with the coordinators' C environment runtime during competition, the visualization successfully demonstrated our system's intended functionality using seeded data. Post-competition, I ported the Python code to C++ and produced a working integrated demo.

System Architecture

Our team implemented a modular design with specialized components:

• Grid System: Efficient tile encoding/decoding with compact 14-character format per cell
• Fire Dynamics: Deterministic spread model with downwind propagation based on wind direction
• Drone AI: State machine with scouting, targeting, extinguishing, and refilling modes
• Multi-Drone Coordination: One drone per base station with intelligent severity-based targeting (≥4)
• Data Persistence: Per-round map archives, vision logs, and drone path CSVs
• Visualization System: My focus interactive GUI with historical/predicted maps and entity tracking

Post-Competition Development C++ Port

After the competition, I independently ported the entire Python codebase to C++20 to validate our approach and achieve full integration with the coordinators' environment framework. This post-competition work involved:

• Complete Language Migration: Translated all Python classes and algorithms to modern C++20
• Build System Setup: Configured CMake with MSVC/MinGW/Clang support and PowerShell build scripts
• Framework Integration: Successfully interfaced with the C environment generator after resolving format mismatches
• Enhanced Drone AI: Water capacity management with automatic refill, path logging, and vision recording
• Performance Optimization: Leveraged C++ efficiency for faster simulation cycles and real-time rendering
• Working Demo: Produced fully functional integrated system demonstrating autonomous multi-drone coordination

Atlantic & Canadian Engineering Competition

Building on this success, our team is advancing to the Atlantic Engineering Competition, where we will compete to earn our spot representing the Atlantic region at the Canadian Engineering Competition. This progression demonstrates the quality and innovation of our work.

Technical Stack

Competition Version (Python):

• Languages & Libraries: Python 3.9+, NumPy (grid operations), Matplotlib (visualization), Pillow (image processing)
• Architecture: Modular design with Grid, FireGen, Drone, Rescue, Predict, and Simulation components
• Data Management: Per-round archives, vision logs, path tracking CSVs

Post-Competition Port (C++):

• Languages & Tools: C++20, CMake, PowerShell build scripts
• Build Support: MSVC, MinGW, Clang cross-platform compatibility
• System Design: STL containers, modern C++ features, efficient state machines

Skills Demonstrated

• Zero-Blueprint System Design: Built complete simulation architecture without starter code or framework
• Data Visualization: Interactive GUI with real-time animated rendering and performance optimization
• Multi-Agent AI: State machine design, limited-observability pathfinding, autonomous coordination
• Cross-Language Development: Python rapid prototyping, full C++20 port with build system integration
• Problem Solving: Format compatibility debugging, interoperability resolution, post-competition validation
• Team Leadership: Lead visualization developer, system integrator, data structure design contributor

Key Achievements

• Competition Recognition: Winner at Dalhousie Engineering programming category (selected and funded after meeting competition criteria)
• Judges' Praise: Visualization specifically highlighted as standout element by judges and coordinators
• Complete System Delivery: Full autonomous drone swarm from scratch with no provided framework
• Post-Competition Success: Independently ported to C++20 and produced working integrated demo
• Advanced to Atlantic Competition: Team progressing to Atlantic Engineering Competition to compete for Canadian Engineering Competition spot