UNROT

Unrot is a cognitive training game that challenges you to notice what others miss, remember what matters, and sharpen observation, listening, and recall through adaptive challenges.

Comment

Inspiration

UNROT started from a problem I noticed in myself: sometimes I wasn't really forgetting things — I had never properly noticed them in the first place.

I could listen to someone speak and remember most of what they said while completely missing one important detail. I could look at something without actually registering everything that was in front of me. With so much time spent rapidly scrolling through content and constantly switching attention, I wanted to build something that pushed in the opposite direction.

That led to the idea behind UNROT:

You can't remember what you never noticed.

Most memory tools start by giving you information to memorize and then testing whether you can recall it. I wanted UNROT to start one step earlier: Can you actually notice the information first?

That became the core loop:

NOTICE → ENCODE → RECALL → ADAPT

What it does

UNROT is a browser-based observation, listening, and memory training game built around short interactive challenges.

In Observation, players are given a limited amount of time to study a visual scene without knowing exactly what they will be asked about. Once the scene disappears, UNROT tests what they actually noticed.

In Listening, players hear generated messages containing details such as names, times, places, quantities, objects, and other information. They then have to recall the important details. At higher difficulties, additional information and corrections make active listening more important.

UNROT also tracks performance across different skills. Instead of only producing a final score, it can identify categories where a player is struggling and give those areas more attention in future challenges. XP, levels, and increasing difficulty turn this into a progression system spanning 100 levels.

The Memory Palace explores another side of memory: deliberately encoding information. Players can build visual spaces, place objects, associate information with them, study the environment, and later attempt to recall those memories using their locations as anchors.

UNROT also supports portable custom challenge packs that can be imported, stored locally, played, exported, and shared.

All of these systems are designed around the same process:

Notice something → encode it → recall it → learn what you tend to miss.

How we built it

UNROT is built using React 18, Vite 5, and JavaScript.

I chose to make it completely client-side. There is currently no backend, database, or account system. Player progress, profiles, settings, challenge packs, and Memory Palace data are stored locally in the browser using localStorage.

The project also uses:

  • Web Audio API for synthesized interface and game sounds
  • Browser Speech Synthesis for listening challenges
  • SVG for parts of the skill/statistics visualization
  • Custom rendering systems for the Memory Palace
  • A question-generation system for creating challenges from structured scene data
  • Adaptive skill tracking for changing question selection based on performance
  • A validation script that checks scenes, questions, packs, and Memory Palace content before production builds

Rather than creating 100 completely separate levels, UNROT uses progression rules to scale difficulty as the player's level increases.

One of my main goals while building it was keeping everything connected without requiring external services. Even custom challenge packs can be imported and shared as files while the application remains local-first.

Challenges we ran into

The biggest challenge was scope.

UNROT started as a much simpler observation-training idea. But observation naturally led to listening, listening led to thinking about different types of attention, and recall led to the Memory Palace and adaptive skill system.

At one point, the danger was that UNROT would become a collection of unrelated minigames instead of one coherent project.

The solution was defining the core loop:

NOTICE → ENCODE → RECALL → ADAPT

Every major feature now needs to fit somewhere within that idea.

Another challenge was making generated questions fair. If a question asks about something that wasn't clearly represented in a scene, or a listening question doesn't match what the player actually heard, difficulty becomes randomness. This pushed me toward structured scene data, controlled question generation, and validation.

The Memory Palace was probably the most technically ambitious part. It required handling object placement, room geometry, interactions, persistence, rendering, study and recall modes, and scoring while keeping everything inside a browser application.

I also had to balance difficulty carefully. A challenge needs to be difficult enough to force attention without simply overwhelming the player.

Accomplishments that we're proud of

I'm most proud that UNROT grew from a small idea into a working system while still running entirely in the browser.

The adaptive skill system is one of my favorite parts. UNROT doesn't just tell a player that they scored 70%; it can keep track of what kinds of information they tend to miss and use that when selecting future questions.

I'm also proud of building the Memory Palace rather than reducing the idea to a normal flashcard interface. It became its own interactive visual environment with rooms, objects, memory assignments, study and recall modes, scoring, and local persistence.

Another accomplishment was getting several very different systems — observation, listening, adaptive difficulty, progression, custom challenge packs, and the Memory Palace — to work under one central idea instead of existing as completely separate features.

And perhaps most importantly, UNROT became something that other people could actually try rather than remaining an idea or prototype sitting in my head.

What we learned

This project taught me that building something is very different from simply knowing how to code individual features.

UNROT forced me to think about systems.

I had to work with state management, procedural content, difficulty progression, validation, local persistence, audio, rendering, UI design, player feedback, and the relationships between different parts of the application.

I also learned that more features don't automatically make a project better.

As UNROT became larger, explaining why each feature existed became increasingly important. Building the feature was sometimes easier than making it feel like a natural part of the product.

That changed how I approached development. Instead of asking only:

“Would this be cool to build?”

I started asking:

“Does this actually strengthen what UNROT is trying to do?”

That is probably the biggest thing I'll take away from this project.

What's next for UNROT

UNROT is still an alpha, so there is a lot I want to continue experimenting with.

The immediate next step is expanding the variety and quality of observation and listening challenges while improving the adaptive system so progression responds even better to individual performance.

I also want to expand the Memory Palace with more environments, objects, customization, and better ways to turn information someone actually wants to learn into spatial memories.

Custom challenge packs could eventually allow teachers, students, or other users to create completely new types of UNROT exercises without modifying the application itself.

Another direction I'm interested in is taking observation beyond generated on-screen scenes and experimenting with challenges that encourage people to pay attention to the real world around them.

Most importantly, I don't want UNROT to become another app making exaggerated promises about “boosting your IQ” or scientifically improving your brain.

UNROT's goal is simpler:

Make deliberate observation, listening, encoding, and recall engaging enough that people actually want to practice them.

Because you can't remember what you never noticed.

Built With

Share this project:

Updates

Submission history