GitHub Finish-Up-A-Thon Challenge Submission
There’s something strangely emotional about reopening an old unfinished game project.
Especially one that once felt like “the next big idea” at 2 AM during a hackathon 😭
You open the folder expecting nostalgia…
…and instead find:
- broken UI
- random commits
- duplicated code
- missing assets
- unfinished features
- and functions named things like
test2_final_REAL.js
That’s exactly what happened when I reopened WhatUsee.
A multiplayer browser game I originally started building as a fun experimental idea.
At first, it wasn’t meant to become anything serious.
It was just a simple concept:
“What if players had to race against each other to identify hidden objects inside chaotic images?”
That tiny idea slowly turned into a real-time multiplayer hidden-object game.
And honestly?
At the beginning, building it was insanely fun.
💡 The Original Idea Behind WhatUsee
Most multiplayer browser games focus on:
- shooting
- drawing
- trivia
- racing
But I wanted something different.
Something that created those chaotic:
“WAIT I SEE IT—NO WAY 😭”
moments.
The idea was simple:
Players join a room together.
An image appears.
Somewhere inside that image is:
- a hidden object
- an animal
- a logo
- a random item
- or something cleverly camouflaged
And everyone races to identify it before the timer ends.
Fast reactions.
Visual focus.
Pure multiplayer chaos.
That became WhatUsee.
At first, the project was extremely small.
Just:
- Socket.IO
- basic image display
- simple guessing
- and a rough scoreboard
No polish.
No proper lobby.
No smooth UI.
But even in that early state…
…the game already felt fun.
And that’s what made me continue building it.
😭 Then The Project Slowly Got Abandoned
Old unfinished WhatUsee multiplayer game interface with basic UI and minimal styling
Like most side projects…
life happened.
College work.
Burnout.
Other responsibilities.
Random unfinished ideas.
And slowly, WhatUsee became:
“that project I’ll definitely finish later.”
The game technically worked.
…but only barely.
The multiplayer flow was messy.
The UI looked unfinished.
The mobile experience was terrible.
Room handling was unreliable.
Animations were missing.
The codebase had become a complete hackathon-style disaster 😭
And after months away from the project, reopening the code felt overwhelming.
So the repository stayed untouched for a long time.
Still public.
Still unfinished.
Still full of potential.
🚀 Then The Finish-Up-A-Thon Challenge Happened
When I saw GitHub’s Finish-Up-A-Thon challenge…
WhatUsee instantly came back to my mind.
Not because it was my most technically advanced project.
But because it was the project I genuinely wanted to complete someday.
I think most developers have one unfinished project sitting quietly in their GitHub profile.
A project they still secretly care about.
WhatUsee became that project for me.
And this challenge finally pushed me to stop saying:
“I’ll finish it later.”
🛠️ Rebuilding WhatUsee After Months
Coming back to old code is honestly terrifying 😭
Especially multiplayer game code.
At first, everything looked confusing.
Socket events everywhere.
Messy logic.
UI inconsistencies.
Large unreadable files.
Instead of rebuilding everything from scratch, I decided to improve the project piece by piece.
That decision completely changed the experience.
⚡ Rebuilding the Multiplayer System
One of the biggest improvements was the room system.
The original version had:
- unreliable room handling
- weak synchronization
- inconsistent player states
So I rebuilt the multiplayer architecture properly using:
- Socket.IO
- Redis
- cleaner room management
- improved lobby handling
Players can now:
- create private rooms
- join using unique room codes
- wait inside live multiplayer lobbies
- see connected players in real time
- smoothly transition into gameplay
This instantly made the game feel much more complete.
🎨 Making the UI Feel Like a Real Game
One thing I realized while rebuilding the project:
Using GitHub Copilot while rebuilding multiplayer systems, Redis integration, and UI improvements.
A polished UI completely changes how people perceive a game.
So I redesigned almost everything.
I added:
- glassmorphism UI
- neon gaming aesthetics
- animated buttons
- theme customization
- typography settings
- responsive mobile layouts
- smoother transitions
- improved gameplay HUD
The game finally stopped feeling like:
“a rough prototype”
…and started feeling like an actual multiplayer browser game.
That moment genuinely motivated me to keep building.
🤖 How GitHub Copilot Helped Me Finish The Project
GitHub Copilot became surprisingly useful during the rebuilding process.
Not because it magically built the game for me…
…but because it helped reduce the friction of continuing an abandoned project.
It helped me:
- refactor messy Socket.IO logic
- restructure UI components
- improve Redis integration
- fix broken functions
- generate repetitive UI code faster
- debug multiplayer issues
- improve responsiveness
One of the most useful moments was while restructuring the room system and fixing multiplayer synchronization issues.
Instead of spending hours rewriting repetitive logic manually, Copilot helped accelerate the cleanup process significantly.
And honestly…
when revisiting old code months later, even small productivity boosts matter a lot.
🔥 Features Added During The Revival
While rebuilding WhatUsee, I expanded the original concept much further.
The newer version now includes:
🎮 Real-time multiplayer rooms
⚡ Live synchronized gameplay
🧠 Hidden object challenge system
🎨 Theme customization
🔊 Sound and UI feedback
📱 Mobile responsive design
🏆 Live scoreboards
✨ Animated transitions and effects
⚙️ Settings system
🚀 Redis-powered room handling
One feature I personally enjoyed building was the customizable theme system.
It made the game feel far more alive and personal.
Small details surprisingly make a huge difference in multiplayer games.
📚 What Reviving This Project Taught Me
Starting projects is exciting.
Finishing them is difficult.
Hackathons teach you how to build quickly.
But unfinished projects teach you something else:
patience.
Reviving WhatUsee made me realize that abandoned projects are not always failures.
Sometimes they’re just unfinished ideas waiting for the right moment.
And honestly?
Rebuilding something old felt far more meaningful than starting another random new project.
Because this time:
it wasn’t about rushing to submit something.
It was about finally completing something I genuinely cared about building.
❤️ Final Thoughts
Months ago, WhatUsee was just an unfinished multiplayer prototype hidden inside my GitHub repositories.
Today, it feels like a real game.
Maybe not perfect yet.
But finally moving in the right direction.
And I think that’s what this challenge is really about.
Not perfection.
Just refusing to leave good ideas unfinished.
Sometimes the best projects aren’t the ones that start perfectly.
They’re the ones we choose to come back to.
Try WhatUsee
🎮 Play the Game
💻 Explore the Source Code
⭐ Feedback is welcome!
🔗 Links
🎮 Live Demo: https://whatusee.onrender.com
💻 GitHub Repository: https://github.com/A-dot-hub/WhatYouSee--multiplayer-game