EduArcade

Inspiration

Our inspiration came from seeing how platforms like Google Doodles can turn a simple interaction into an engaging game, as well as educational platforms like i-Ready, which combine learning with personalized student progress.

We wanted to explore a different approach: What if studying didn't feel like studying?

Traditional learning often requires students to read information and then answer questions separately. We wanted to combine those two experiences into one interactive environment where students could learn a concept, immediately practice it, make mistakes, receive feedback, and continue learning through gameplay.

That led us to create Learning with EduArcade, an AI-powered educational game that combines adaptive learning with a familiar arcade-style experience.

What it does

Learning with EduArcade turns almost any topic into an interactive learning experience.

A student begins by searching for a topic they want to learn about. Gemini generates a short lesson and breaks the topic into four key concepts, creating a Learning Map that shows what the student should understand and how the concepts relate to one another.

The student then enters the Pac-Man game, where their gameplay is connected directly to their learning.

Instead of simply answering a static list of questions, students encounter questions as part of the game experience. Their answers are recorded and used to track their understanding of individual concepts.

When a student answers incorrectly, the system can provide an explanation and additional practice rather than simply telling them that they are wrong.

Behind the scenes, the application maintains a student model that tracks things such as:

Concept mastery Correct and incorrect answers Recent accuracy Difficulty of questions answered Learning gains Concepts the student may need to practice

This allows the experience to become more than just "Pac-Man with questions." The goal is to create an adaptive learning system where gameplay provides a way to measure and reinforce understanding.

How we built it

We built the project using a combination of Python, JavaScript, HTML, CSS, SQL, Flask, and the Gemini API, with Google AI Studio helping us develop and test the AI-powered learning experience.

Frontend

The frontend was built with HTML, CSS, and JavaScript.

We designed the interface to feel familiar and approachable while creating a custom learning experience around the game. JavaScript handles the Pac-Man gameplay, including:

Player movement Ghost movement Collision detection Pellets Power Pellets Scoring Game states Questions Game Over Boss interactions Progress transitions Backend

The backend was built using Python and Flask.

The server handles the application's core logic, including:

User authentication Learning-package generation Game sessions Question validation Student progress Mastery calculations Communication with Gemini Database interactions

We intentionally kept Gemini calls on the server side so the API key and learning logic aren't exposed directly to the browser.

AI

We used the Gemini API to generate learning content dynamically.

Rather than asking Gemini to simply generate random questions, we structured the prompts so Gemini produces a learning package containing concepts, prerequisites, lesson content, and questions.

We also added validation on the backend to make sure the generated content follows the structure our application expects.

Database

We used SQL/SQLite to store information such as:

User accounts Topics Concepts Questions Student attempts Concept mastery Learning history

This allows the application to maintain progress instead of treating every game as an isolated experience.

Challenges we ran into

major challenge was the frontend transformation.

Our original prototype looked and behaved very differently from the final application. We completely transformed the frontend, including the overall visual design, navigation, game presentation, and interaction model. This required us to preserve the underlying functionality while essentially rebuilding how the user experiences the application.

Getting the Pac-Man mechanics to behave correctly was another challenge. We had to account for things like:

Ghost movement Chase behavior Frightened behavior Power Pellets Collision detection Pellet collection Game Over states Questions triggered by gameplay Boss mechanics

We also had to make sure that changing one part of the game didn't unintentionally break another part.

Another challenge was storing and managing student information. We needed to connect gameplay to a persistent student model so that answers weren't simply discarded after a game ended. This required designing database tables and backend logic that connected users, concepts, questions, attempts, and mastery.

Finally, prompt engineering became much more complicated than we initially expected. We weren't just asking Gemini to write a paragraph. We needed Gemini to generate structured educational content that our application could actually use. We had to think carefully about how to prompt Gemini, validate its responses, handle unexpected outputs, and ensure questions were connected to the correct concepts.

Accomplishments that we're proud of

One of our biggest accomplishments is the frontend transformation.

We started with a much simpler prototype and turned it into a significantly more polished interactive experience. We are proud of how the learning interface, game interface, navigation, and progress screens work together as one application.

We're also proud of the backend architecture and Gemini integration.

Instead of putting AI calls directly into the frontend, we created a backend flow where Python communicates with Gemini, validates the generated content, and then provides the appropriate information to the frontend.

Another accomplishment we're proud of is how interactive the application is. The student isn't simply reading a lesson and clicking through questions. Their actions inside the game determine when learning interactions occur.

We're particularly proud of the student progress system.

The application doesn't only track whether someone got a question right or wrong. It tracks performance at the concept level and uses that information to provide a more meaningful picture of what the student understands and where they may need more practice.

The progress dashboard allows students to see their development over time instead of treating each game as a separate experience.

What we learned

This project taught us a lot about full-stack development because we had to work across nearly every layer of an application.

We gained practical experience with:

HTML CSS JavaScript Python Flask SQL SQLite REST-style backend communication APIs Git/GitHub Database design Gemini APIs Google AI Studio

We also learned that making an application feel fast is very different from simply making the code function correctly.

We spent time improving the responsiveness of user inputs and outputs, particularly around gameplay controls, searches, API requests, and AI-generated responses.

Another major lesson was that AI integration requires much more than sending a prompt. We learned how important structured prompts, response validation, error handling, and controlling AI-generated output are when the AI is directly connected to an application's functionality.

We also learned a lot about iterative development. Many of our early implementations worked technically but didn't provide the experience we wanted. We repeatedly tested, identified problems, changed the implementation, and tested again.

Most importantly, we learned how to take an idea that started as a game concept and turn it into a working full-stack adaptive learning application.

What's next for EduArcade

Our biggest next step is to expand the platform beyond Pac-Man.

The goal is to create a collection of learning games that all use the same underlying student measurement system.

Instead of forcing every student to learn through one game, students could eventually have multiple ways to practice the same concepts. The important part is that the measurement system stays consistent even when the game changes.

A student could practice Python loops through Pac-Man one day, then use a different game to reinforce the same concepts another day. Their performance would continue contributing to the same concept-level progress.

We also want to make the system increasingly adaptive by using a student's history to determine what they should practice next, rather than simply generating the same experience for everyone.

Long term, we envision Learning with EduArcade becoming a platform where students can choose from different interactive learning experiences while the underlying system continuously measures their understanding and adapts practice to their needs.