Team Name: Codenomaly

Members: Stephen Mertyl, Kira Archer, Marilyn Anderson, Naima Sana


Inspiration

During this semester, the team constantly found ourselves debugging projects for class. As Computer Science students, we're always surrounded by code, and sometimes, it feels like the bugs are hunting us. That was when, during this hackathon, we decided to devise a both fun and innovative solution to practicing debugging.

We created Codenomaly, a horror-themed survival game inspired by "I'm On Observation Duty", where players must work together to debug constantly propagating errors before they are overwhelmed.


What It Does

Codenomaly is a browser-based multiplayer game where players must survive 5 minutes inside a shared coding project.

Players:

  • Join a lobby using a 4-letter code
  • Choose a programming language (C#, C, Python)
  • Load into a VSCode-style environment
  • Search for errors that spawn over time
  • Select a line and classify the error type
  • Manage their Stability meter

Errors accumulate dynamically. If too many exist at once, the game ends in a loss.

If a player’s stability drops to 0%: $$ \text{Stability}_{new} = 50\% $$ Their screen glitches temporarily and they cannot interact, but they rejoin the game shortly after.

The goal is simple:
Survive until the 5-minute timer ends.


How We Built It

Backend

We built the real-time multiplayer server using PartyKit, a WebSocket-based room server.

The server:

  • Maintains authoritative game state
  • Spawns errors over time
  • Tracks player stability
  • Broadcasts synchronized updates

Key logic includes:

  • Dynamic error spawning
  • Stability decay when viewing corrupted files
  • Global error counter monitoring
  • Win/loss evaluation

We made the server authoritative to prevent desynchronization issues between clients.


Frontend

Our frontend stack includes:

  • React 18
  • Vite
  • Tailwind CSS
  • Monaco Editor
  • Zustand

We used Monaco Editor to replicate a real IDE experience. Players click lines, select error types from a dropdown, and submit fixes.

We separated:

  • Client-local UI state (Zustand)
  • Server-synced game state (PartyKit broadcasts)

One key architectural decision was isolating latency-heavy processes from the main UI thread. Stability effects, popups, and glitch overlays are managed separately so the editor never freezes.


Challenges We Ran Into

Learning Real-Time Systems

Keeping:

  • Error counts
  • Player cursors
  • Stability meters
  • Timers

perfectly synchronized across browsers was much harder than expected.

Early builds suffered from:

  • Ghost errors
  • Lobby & multiplayer syncing
  • UI alignment issues

We solved this by:

  • Making the server authoritative
  • Broadcasting full room snapshots
  • Preventing clients from making assumptions

Monaco Editor Complexity

Monaco is powerful, but integrating it into a game environment was tricky.

We had to:

  • Track line indices precisely
  • Overlay UI elements dynamically
  • Disable interactions during glitch states
  • Prevent race conditions during state updates

Balancing Difficulty

If errors spawned too fast, the game felt impossible.
If too slow, it felt boring.

We experimented with scaling spawn rate: $$ \text{SpawnRate} \propto 1 + 0.3 \times \text{Players} $$

Balancing tension without frustration became one of the most interesting design challenges.


Accomplishments We’re Proud Of

We are incredibly proud that we:

  • Built a fully synchronized multiplayer game
  • Designed a scalable error system
  • Turned debugging into a survival mechanic
  • Successfully integrated real-time WebSockets
  • Balanced UI performance with game logic

What We Learned

We learned:

  • Real-time architecture design
  • Multiplayer state management
  • Server-authoritative systems
  • Deployment configuration
  • Game balancing psychology

Most importantly, we learned that complex systems only work when responsibilities are clearly separated.


What’s Next for Codenomaly

Codenomaly will continue evolving.

Planned improvements include:

  • Campaign progression system
  • Unlockable “boss repositories” (multi-file mega projects)
  • Currency-based powerups
  • Persistent player profiles
  • Expanded language support
  • Ranked mode

We also plan to deploy permanently and refine performance optimizations.


Built With

  • React
  • Vite
  • Tailwind CSS
  • Monaco Editor
  • Zustand
  • PartyKit
  • TypeScript

Built With

  • monaco-editor
  • partykit
  • react-18
  • tailwind-css
  • vite
  • zustand
Share this project:

Updates