@jayanth_raveendra

What started as a basic software systems course project just got a massive 6-hour architectural overhaul. I wanted to build ARENA, an identity-verified multiplayer Tic-Tac-Toe game where your face is literally your password.Here is the breakdown of the sprint to get to v1.0.0:The Biometric Overhaul (Moving to the Edge)
Originally, the facial recognition was a heavy, monolithic server-side pipeline. It was a dependency nightmare and crushed the server. I completely ripped it out and migrated to Edge ML using face-api.js. Now, the client browser computes 128-d facial encodings directly on the user’s GPU. Server load dropped to near-zero, and the latency is basically gone.The Microservice Migration
I took the original god file and shattered it into a clean microservice architecture. Containerized the whole thing using Docker Compose. It now features a resilient Python backoff/retry loop so the FastAPI backend waits patiently for the databases to initialize before booting.The Local Network “Final Boss”
This was the hardest part of the overhaul. I wanted users to connect via their phones on the same Wi-Fi. But Chrome strictly blocks webcam access on unencrypted HTTP connections unless it is localhost.The Fix: I set up an Nginx reverse proxy to route frontend and API traffic through a single port. Then, I wrote dynamic JavaScript routing and piped the whole thing through an ngrok tunnel. Now, I can spin up the containers, run the tunnel, and send friends a secure HTTPS link to play against me locally! It was a crazy 6 hours of fighting WebSocket race conditions and Nginx regex bugs, but ARENA is finally production-ready (I hope :) ).

Logged 6 hours today wrapping up my C-Shell mid-submission, focusing on fixing a major architecture bug, optimizing features, and thoroughly documenting the codebase. First, I added a stale path cleanup mechanism to my Zoxide-style hop command, ensuring that deleted directories or those with a frecency rank below 0.5 are automatically purged from the hidden database. Next, I tackled a tricky OS trap involving multiple output redirections: because execv() replaces the entire process image, it was obliterating my post-execution file-writing logic. I fixed this by building a custom tee-style pipeline that forks a second proxy “writer” child to safely read the command’s output via a pipe and distribute it to all files simultaneously. Finally, I went through all my files to rigorously comment the complex dup2 file descriptor routing and backward file-chunking logic.

Spent the last 3 hours building the core execution engine for my C-Shell. I implemented external command execution by scanning $PATH and using the fork() and execv() syscalls. The biggest challenge was getting I/O redirection and piping to work correctly. I used dup2() to hijack standard input/output and route them through anonymous temporary files (tmpfile()) to handle multiple file redirections at once.I also ran into a brutal segmentation fault because my built-in commands weren’t expecting redirection operator tokens. I ended up doing a massive architectural refactor to move the entire file descriptor routing to the parent shell level. Now, whether it’s an external binary like ls or my custom peek built-in, they both seamlessly read and write through pipes and files!

I spent the last 8+ hours building a custom POSIX-compliant C shell from scratch. I built a custom lexer and parser to handle right-linear grammar, quoting, and escaping without using standard parsing tools like Lex/Yacc. I also implemented several complex built-in commands natively without relying on exec system calls, including a custom directory jumper (hop) with a time-decaying frecency algorithm (similar to Zoxide) that persists across sessions, and a custom cat-like tool (peek) that uses lseek to read files in reverse chunk-by-chunk to save memory.

Spent the almost 7 hours building a bare-metal, 32-bit RISC-V CPU emulator entirely in Rust from scratch! I finished the core RV32I instruction decoding and set up a simulated 1MB memory array, but getting actual C code to run on it was a massive challenge. I ran into two brutal bugs: The GCC cross-compiler was secretly compressing my instructions into 16-bit chunks, causing my 32-bit fetch() cycle to mash instructions together into unknown opcodes. I had to configure -march=rv32i to force strict 32-bit mode. My CPU tried to jump to an address 4.2 billion bytes out of bounds because of a 64-bit sign-extension trap in Rust! After fixing those, I wrote a tiny bootloader routine to set the Stack Pointer (x2), built a proxy-kernel to handle ecall system traps, and set up Memory-Mapped I/O (MMIO). The emulator can now successfully run a freestanding C program, print to a fake terminal screen, and exit cleanly!

Added a start menu to the game, with some game elements at the bottom to give a glimpse of the game. The first level design has been completely overhauled.

Built the first level, with lots of help from Brackeys beginner tutorial to Godot. Got a taste of game dev and GDScript.