#cmsc-131
Displaying 22 projects.
Abstract
After-Exam is a 2D action-platformer Game Boy game developed using GB Studio and inspired by the Metroidvania genre. The project applies concepts from game logic and hardware-constrained programming by implementing movement, combat, enemy behavior, and a boss fight built around a hexadecimal-to-binary puzzle. The final output is a fully playable Game Boy ROM compatible with standard emulators. Although some planned features such as weapon upgrades and additional stages were not completed, all core objectives were met. The project demonstrates effective design within the limits of Game Boy hardware while showcasing a complete gameplay loop supported by custom assets, scripts, and documentation.
Abstract
Arceus Cup is a Playable Pokémon ROM Hack, using Pokémon Emerald as the base. It is a GBA file that can be run on any GBA emulator to play, using the characters and system of Pokémon Emerald, you will select a Character to play as from the given roster of Pokémon CHAMPIONS across all generations. You will then Participate in a Tournament where you Fight to become the Very Best like no one ever was.
Abstract
Bombasm is an interactive learning platform that teaches bit manipulation through puzzles requiring users to transform an initial bitstring into a target bitstring using a set of operations. The project originally proposed a full assembly-language simulation with registers and flags, but the scope was reduced to core bit operations due to time and experience constraints. The visual design also shifted from a bomb theme to an analog-computer style to better reflect low-level programming contexts. The final system was delivered on time, implementing all basic bit operations and tutorial levels, while only partially completing advanced puzzle modes. Overall, the project successfully met its primary educational objectives within the refined scope.
Abstract
CAScape is a 2D escape platformer game created using GB Studio. The goal of the project is to build a short but challenging game inspired by earthquake scenarios and our school dog, CASie. CAScape includes three main levels with obstacles such as spikes, bombs, and appearing floor gaps. The game features player movement, collision detection, hazards, scene transitions, dialogues, simple UI, sound effects, and background art. Most of the planned features were completed, resulting in a playable demo with about 98% of the intended mechanics implemented. The game meets the main project goals and provides a fun but rage-baiting experience.
Abstract
CTRL+BIT is a 2D educational maze game designed to enhance students' understanding of Assembly mnemonics through interactive gameplay. Developed using C and the Raylib library, the game engages players in navigating dynamically generated mazes while manipulating binary values to unlock gates representing Assembly instructions, including INC, DEC, ROR, ROL, SHL, and SHR. The maze generation employs depth-first search and backtracking algorithms to ensure every maze is solvable while maintaining unique and replayable experiences. Players receive a set of bits that guide their collection strategy to meet the requirements of mnemonic gates, promoting deeper conceptual understanding of Assembly language operations. The implementation successfully combines gameplay, problem-solving, and bit manipulation to create an engaging educational tool that improves critical thinking and mastery of low-level programming concepts. The game demonstrates how gamification can transform traditionally difficult lessons into an interactive learning environment. Compiled to WebAssembly using Emscripten, the game runs efficiently in web browsers with load times under 20 milliseconds for cached assets. The source code, documentation, and deployment artifacts are publicly available on GitHub, enabling reproducibility and extension by future developers.
Abstract
Technological advances in today's world have significantly influenced the evolution of the gaming industry. Game development has become a powerful medium for learning, making educational content more engaging, interactive, and enjoyable. The purpose of this project is to create a 2D game that incorporates assembly programming concepts using C++ and Raylib, and to compile it into WebAssembly using Emscripten. This project was completed within a one-month timeframe, utilizing freely available assets. The final output is a locally deployable game that runs directly in the browser, featuring smooth and responsive player controls, properly timed lasers, and persistent high scores. By combining low-level programming concepts with modern web technologies, this project demonstrates the potential for creating interactive, browser-based games that are both educational and entertaining.
Abstract
This project presents an Automatic Fire Detection, Extinguishing, and Alert System that integrates real-time flame sensing with automated suppression and GSM-based emergency notification. The system employs an infrared flame sensor for fire detection, a dual-servo mechanism for directional scanning and nozzle aiming, and a relay-controlled 12 V water pump for targeted fire suppression. Upon flame detection, the Arduino Uno microcontroller simultaneously activates the GSM module to transmit SMS alerts to registered recipients, enabling remote monitoring and emergency response. The servo-driven scanning mechanism sweeps from 0° to 180° to locate the strongest flame signal; however, the water nozzle is mechanically restricted to operate only within a 90° range directly in front of the system, ensuring controlled and stable spray direction during extinguishment. Once the flame coordinates are determined, the nozzle automatically positions itself within this allowable range for precise suppression. System testing demonstrated accurate flame detection within a 24 cm range with response times under 2 seconds, consistent pump activation via relay control, and reliable SMS transmission through cellular networks. This autonomous fire-response system provides a cost-effective solution for residential and commercial fire safety applications, combining sensor-driven detection with automated suppression to minimize response time and property damage.
Abstract
This project presents the Fitness AI Planner, an intelligent offline TinyML system capable of generating personalized workout schedules on low-power embedded hardware. The system is built around a dataset of 1,800 synthetic fitness profiles, each containing key user attributes such as age, gender, BMI, and stated fitness goals. These variables were preprocessed and used to train a Decision Tree classifier in Python, enabling the model to learn how individual user characteristics correlate with appropriate workout routines. Once the model achieved reliable performance, it was exported and converted into highly optimized C++ code through the micromlgen library. This conversion allowed the classifier to run on an Arduino microcontroller with only 2 KB of RAM, demonstrating the feasibility of deploying machine-learning-based personalization on extremely resource-constrained devices. To make the system fully interactive, a lightweight physical interface was developed using an LCD display and Serial input, enabling users to enter their fitness information and immediately receive customized workout recommendations. By eliminating the need for internet connectivity or cloud-based computation, the Fitness AI Planner highlights the practical potential of TinyML for real-time health and fitness applications. It showcases how compact machine-learning models can deliver meaningful, user-specific guidance entirely offline, making intelligent fitness assistance more accessible, portable, and efficient.
Abstract
Flappy Byte is a Game Boy Advance (GBA) homebrew project that reimagines the classic Flappy Bird mechanic through the lens of digital logic and low-level programming. Written entirely in C using tonclib, the game challenges players to navigate a bouncing ball through scrolling pipes while simultaneously solving 8-bit logic-gate puzzles in real time. Each pipe set displays two possible byte outputs, one correct and one decoy, based on a randomized combination of a game byte, a secondary byte, and a logic gate (AND, OR, XOR, or NOT). The player must mentally compute the correct result before the pipes reach the ball's position. This project demonstrates low-level graphics manipulation, sprite management, timing loops, memory organization, collision detection on the GBA. The outcome is a fully playable, original, and educational puzzle-arcade hybrid that successfully blends reflex-based gameplay with mental reasoning.
Abstract
jocSING is a low-cost, portable, and user-friendly karaoke prototype system built using the ESP32 microcontroller. The project's purpose is to simulate a commercial karaoke experience while providing real-time singing feedback and a basic scoring mechanism. Its core features include IR remote-controlled song selection from a custom songbook, synchronized lyrics display on a 16x2 LCD screen, audio playback via the DFPlayer Mini MP3 module, and real-time pitch analysis using the INMP441 microphone. The system processes the user's pitch via an autocorrelation algorithm and provides immediate visual feedback through an RGB LED module. The final outcome demonstrates a fully functional, integrated system capable of reliably reading user input, playing back audio, displaying synced lyrics, and analyzing and scoring the user's performance based on pitch consistency and accuracy, meeting all primary functional objectives.
Abstract
Understanding low-level machine architecture is a fundamental requirement for computer science students, yet the cognitive bridge between high-level source code and raw binary execution remains opaque. While industry-standard tools like IDA Pro and Ghidra offer powerful disassembly capabilities, their steep learning curves and feature complexity often hinder novice learners from grasping the core concepts of instruction decoding. This project addresses this educational gap by presenting "MISSION DISASSEMBLE," a lightweight, transparent disassembler designed specifically for inspecting and analyzing x86-64 NASM (Netwide Assembler) binaries. The system is architected using Python 3 and employs a linear sweep algorithm to parse variable-length x86-64 instruction sets. Technical implementation relies on a custom SQLite opcode database integrated with a bitwise decoding engine capable of handling complex addressing modes, including ModR/M and SIB bytes. Key features include a user-friendly graphical user interface (GUI) that visualizes memory addresses alongside raw hex bytes, a syntax highlighter for NASM directives, and a statistical analyzer that generates reports on register usage and instruction distribution. Validation procedures involved a reverse-engineering test where binaries compiled from known NASM source code were disassembled and compared against the original source. Results demonstrate that the tool achieves 100% decoding accuracy for the supported instruction set, correctly identifying opcodes, operands, and immediate values. The outcome is a fully portable, standalone executable compiled via PyInstaller, which significantly lowers the barrier to entry for students. This project proves that custom-built inspection tools can serve as effective, accessible educational aids in the field of systems programming.
#Morse Code Translator using LED Lights
> Michaela Borces> Marinelle Joan Tambolero 2025-2026
#Morse Code Translator using LED Lights
Abstract
This work presents the design and implementation of a microcontroller-based Morse Code Translation System utilizing an Arduino Uno platform. The system enables character input through a 4×4 matrix keypad employing a T9 multi-tap selection algorithm, which resolves alphabetic characters from limited numeric keys. A 16×2 I2C LCD module provides real-time feedback of user input and system status. The translation process is performed using an indexed lookup table that maps each character to its corresponding Morse code sequence, while precise timing control governs LED-based optical output according to standard Morse code specifications. The complete system was evaluated through functional testing of character recognition, timing accuracy, and signal reliability. Results demonstrate consistent performance across the full A–Z character set and stable optical transmission under varying input rates. The system offers a compact and low-cost platform suitable for instructional use in embedded systems, digital communication principles, and human–machine interaction.
Abstract
This project presents a Pathfinding Visualizer designed to demonstrate and analyze the performance of various pathfinding algorithms in a grid-based environment. The application visualizes the search process using a wavefront propagation method, providing real-time insight into how different algorithms traverse a graph. Upon locating the target node, the system highlights the resulting path, allowing for immediate visual verification of efficiency. We implemented nine distinct algorithms for comparison, including A*, Dijkstra's Algorithm, Depth-First Search (DFS), Breadth-First Search (BFS), Greedy Best-First Search, Bidirectional Search, Weighted A*, Beam Search, and Bidirectional A*. The tool features a fully interactive interface where users can customize grid topology by placing barriers and adjusting start and end coordinates. Additionally, the system includes an automated maze generator to facilitate rapid testing scenarios. To provide quantitative performance metrics, the visualizer calculates and displays the path length, total nodes visited, and execution runtime for each search. This project serves as both an educational tool for understanding algorithmic logic and a benchmarking utility for comparing heuristic and non-heuristic pathfinding strategies.
Abstract
RowBlocks is an arcade game that is inspired by Breakout. It runs on 16-bit Assembly and operates on the DOS platform. For the graphics, it uses VGA Mode 13h, which allows it to display a resolution of 320 by 200 pixels on the screen with 256 colors.
Abstract
This project develops a single-level 2D horizontal shooter game for the Game Boy platform. The game is a wave-based Amogus-themed shooter with progressive difficulty, multiple enemy types, and a boss encounter. The final game is fully playable and demonstrates core Game Boy programming concepts, including sprite management, state machines, collision detection, and audio integration, while delivering a playable arcade experience.
Abstract
Shoot the Komsai is a high-performance, retro-futuristic arcade shooter designed to highlight the practical advantages and modern capabilities of WebAssembly (WASM) in web-based game development. This project showcases a hybrid architecture that combines a C++ backend which is responsible for core game logic, real-time physics calculations, collision detection, and enemy behavior with a JavaScript, CSS and HTML frontend that manages rendering pipelines, asset handling, audio playback, and user interaction.
Abstract
This project presents the development of a Web-based Sudoku game implemented entirely in the C programming language and deployed as WebAssembly. Sudoku puzzles are generated using recursive backtracking algorithm and a hole-digging difficulty model, ensuring each board is solvable and contains a unique solution. The user interface combines CLAY for structured layouting and Raylib for rendering and input handling. The game is deployable both locally and on the web. Through testing, including unit, integration, and system-level assessments, the project meets its objectives of functional reliability, consistent rendering, and user interaction accuracy.
Abstract
SyscallScope is a lightweight Linux syscall monitoring and detection system that leverages eBPF/BPFtrace and rule-based heuristics to identify suspicious behaviors such as unauthorized execution, rapid file writes, unusual memory protections, directory enumeration, and abnormal process interactions. The system provides a complete tracing pipeline from syscall collection to structured event parsing and anomaly detection. While some proposed activities, such as using external offensive tools (Nmap, Hydra), were not implemented, custom C-based simulators for getdents, connect, chmod, and rapid-write workloads enabled controlled, reproducible testing. SyscallScope meets its core objectives, demonstrating effective syscall-level attack detection with minimal performance overhead.
Abstract
Tabok Run is a retro-inspired 2D road-crossing game developed using GB Studio, demonstrating the practical application of low-level computer organization concepts within interactive game logic. The game features precise collision detection, dynamic movement physics, and multi-level progression through a series of increasingly challenging environments. This project exemplifies how machine-level programming principles—including data representation, bitwise operations, control structures, memory management, and array manipulation—integrate into real-time game development. The final deliverable is a fully playable .gb ROM executable compatible with Game Boy emulators, complete with technical documentation and comprehensive architectural analysis.
Abstract
Tic-Tac-ISKOe is a Game Boy–style recreation of the classic tic-tac-toe game, developed in GB Studio to explore compact game design within a limited 8-bit environment. The project aims to reimplement a familiar grid-based game while examining how its mechanics—turn alternation, board interaction, and automated win or draw detection—can be modeled through event-driven logic. Featuring a retro-inspired interface with binary markers (1s and 0s) that reflect the developers' computer science background, the game includes responsive two-player interaction and integrated audio with background music and sound effects. It relies on GB Studio's variable and scene systems to manage board states, player turns, and game flow, while incorporating a thematic nod to binary notation that adds a layer of originality to the classic design. The final product presents a fully playable and visually consistent mini-game that demonstrates how traditional mechanics can be adapted to a constrained development tool while maintaining clarity, coherence, and functional gameplay.
Abstract
WODO (WASM-Optimized Do Organizer) is a browser-installable, offline-capable To-Do List system built using WebAssembly (C → WASM), minimal Clay CSS UI, and a Progressive Web App (PWA) architecture. The project demonstrates full integration of C logic compiled to WebAssembly, persistent storage using JavaScript bridges and browser localStorage, a modern UI using Clay CSS-inspired components, offline fallback and caching through a service worker, and deployment on GitHub Pages as a fully functional PWA. WODO fulfills the requirements of Weeks 1–4 of the CMSC 131 final project by demonstrating WebAssembly fundamentals, JS–C communication, UI integration, and web deployment.
Abstract
This project presents the development and evaluation of a lightweight pattern-based malware detection system implemented in C++ using the YARA rule module. The scanner performs static analysis of executable files through recursive directory traversal, matching binary content against predefined signature rulesets to identify potentially malicious software. Core features include automated file system scanning, YARA C API integration for rule compilation and pattern matching, and structured reporting in JSON and CSV formats. Custom YARA rules were developed for malware families based on flagged API imports and behavioral characteristics extracted through static analysis tools. The system was validated against a corpus of 3,090 files, demonstrating practical detection capabilities while highlighting the importance of rule tuning to balance sensitivity and specificity. Performance metrics indicate scan completion times below 20 seconds for the test dataset, with detection accuracy dependent on rule comprehensiveness and signature specificity. The project successfully integrates cybersecurity principles with system programming, providing a functional foundation for signature-based malware detection suitable for educational and small-scale security analysis environments. The source code, documentation, and deployment artifacts are publicly available on GitHub, enabling reproducibility and extension by future researchers.