Projects

Full Minesweeper clone built from scratch in modern C++ using SFML. Features randomized board generation, neighbor-count algorithm, recursive flood-fill reveal, flagging system, and win/loss detection. Compiled to WebAssembly for browser play.

Machine learning API that predicts housing prices based on property features. Built with scikit-learn using a KNN regression model, deployed as a Flask REST API on Render with a responsive web interface.

A fully synthesizable 5-stage pipelined CPU implementing a subset of MIPS with hazard detection, data forwarding, and branch handling. Designed and implemented IF/ID/EX/MEM/WB pipeline stages, ALU, register file, control unit, and forwarding logic. Features instruction-level parallelism with proper pipeline state handling.

A collection of embedded programs for the HCS12 microcontroller including real-time audio sampling at 8kHz, waveform synthesis, 7-segment display drivers, timer interrupts, and UART-driven command interfaces. Implemented deterministic timing guarantees with optimized ISR latencies using RTI interrupts and ADC.

Built a custom dynamic memory allocator in C featuring segmented free lists and a slab allocator design. Implemented block splitting, coalescing, boundary tags, and alignment optimizations to achieve strong throughput and utilization performance. Designed the allocator to minimize fragmentation, reduce allocation time, and maintain a robust internal heap-checker for debugging and validation.

• Implemented segmented free lists for fast allocation based on size classes
• Added a slab allocator for small, fixed-size frequent allocations
• Designed coalescing and block-splitting logic to reduce fragmentation
• Integrated boundary tags and a heap consistency checker
• Tuned for balanced throughput and memory utilization

Built a concurrency-safe messaging system in C featuring thread-safe channels with blocking and non-blocking semantics. Implemented synchronization using mutexes, condition variables, and semaphore-based wakeups. Designed a CSP-style channel abstraction supporting multiple producers and consumers with FIFO ordering, deadlock prevention, and deterministic selection via a select() API. Ensured safe closure behavior, correct wakeups, and robust memory cleanup across concurrent workflows.

• Implemented blocking and non-blocking send/receive operations with mutex-protected queues
• Designed a FIFO message buffer supporting concurrent producers and consumers
• Added a semaphore-based notification system powering a scalable select() mechanism
• Ensured safe shutdown semantics that wake all blocked threads on channel close
• Built deterministic selection logic for multi-channel operations
• Implemented robust memory management and thread-safe cleanup guarantees

A distributed AWS-based automation system for monitoring and validating utility valve states in real time. Designed for WSSC Water to monitor valve operations, validate field data, and trigger automated workflows. Features operational workflow automation, email notifications, audit logging, and backend integrations.

A Python-based sensor visualization system on Raspberry Pi with real-time dashboard, joystick control, LED matrix output, and TCP/IP communication. Visualizes accelerometer, temperature, and humidity data in real time. Features remote monitoring and socket communication between devices.

A parametric performance study of CPU microarchitecture exploring 18 tuning knobs including fetch width, ALU count, cache parameters, and branch predictors. Automated simulation experiments in SimpleScalar across hundreds of configurations. Evaluated performance, energy, and EDP metrics to find optimal design points.