From a Forgotten Multiplayer Prototype to a Chaotic Hidden-Object Game — Reviving WhatUsee 🚀

Abhishek Jaiswar — Thu, 28 May 2026 06:25:54 +0000

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

DEV Community: Abhishek Jaiswar