Build a Pac-Man-Style Mini-Game in 100 Hours with Godot and GitHub: A Beginner’s Guide

Absolutely.

Not a perfect clone.
Not a “full commercial release.”
Not a four-year passion project that disappears into a folder called prototype_final_v12.

A real, playable, one-level, Pac-Man-style mini-game?
Built solo, as a beginner, in 100 hours?

Yes. That future is very real.

And honestly, it is one of the best possible first projects.

Why? Because a Pac-Man-style game has something beginners desperately need: clear shape. You can see the finish line. A maze. A player. A few enemies. Dots. Score. Lives. Sound effects. Win screen. Done.

The trick is not “use AI for everything.”
The trick is to use AI where beginners usually lose time: planning, implementation, asset generation, and debugging.

For this version, the stack is simple:

• Engine: Godot
• Language: GDScript
• Showcase: GitHub
• Optional “play now” route: GitHub Pages for the web build
• Optional “download now” route: GitHub Releases for desktop builds

That combo is practical because GitHub Pages is a static hosting service that can publish files directly from a repository, GitHub Releases can package binaries for download, and Godot officially supports web export. For this project, though, GDScript is the safe lane: Godot’s documentation says Godot 4 projects written in C# currently cannot be exported to the web.

How to Use This Guide

Read the full roadmap first. Then move section by section: build the feature, check the official source when needed, and keep going until you have a playable game.

This Is Not a Complete Manual — It’s a Beginner Roadmap

This is a map.

A good map does not force one road.
A good map lets beginners choose a road that still leads to a finished game.

If you can imagine your first playable game clearly enough to believe in it, you are already halfway there.

Here is the target:

• A one-level Pac-Man-style mini-game
• Two enemy types
• Collect all dots to clear
• Score and lives
• A few sound effects
• A GitHub repository that makes the project feel real
• Bonus points if you publish a browser version

That is not “small.”
That is smart.

A 30-Second Future Simulator

Imagine this:

100 hours from now, you send someone one link and say, “Play this.”

That is the whole dream.

So fix the goal in one sentence:

Build a one-level Pac-Man-style mini-game in Godot and publish it on GitHub, with a browser-playable version if possible.

Now choose your 100-hour container:

• 2 hours a day for 50 days
• 5-hour weekend blocks plus small weekday sessions
• 10 focused days at 10 hours each

There is no perfect schedule.
There is only the one you will actually finish.

And now the most important beginner rule:

Lock your tools to three.

My recommended beginner loadout:
• Godot
• GitHub
• Godot AI Assistant Hub

Add GitHub Copilot only if you want extra implementation help.
Use GitHub Pages later, at the publishing stage.

That is enough to finish a first game without drowning in options.

The Real Secret: Win 100 Hours by Using AI in Only 4 Places

Most beginners think AI helps by “doing the whole project.”

Wrong.

AI helps by shrinking the places where time melts.

Use it here:

Planning

AI is great at helping you cut scope.
That matters more than clever code.

Code Skeletons

Movement systems, UI states, collision behavior, and basic enemy logic are all perfect AI-assist territory.

Asset Volume

Retro-style projects are not about “one masterpiece asset.”
They are about consistent small assets: dots, walls, UI icons, simple portraits, sound placeholders.

Debugging

This is where AI can save entire evenings.
Especially when your game “almost works.”

How to Scope a Pac-Man-Style Game for a 100-Hour Build

This is the ritual.

Do not build the original game.
Build the version that fits in your life.

Must-Have Features

• Tile-based maze
• Player movement on a grid
• Turn buffering, so cornering feels good
• Two enemy types:
  • one simple chaser
  • one random mover
• Dots to collect
• Clear condition when all dots are gone
• Score
• Lives
• Game over
• Small sound effects for eating, dying, and clearing the level

Dangerous Features for a First 100 Hours

• Full original ghost behavior
• Multiple stages
• Fancy cutscenes
• Overdesigned menus
• Too many power-up systems
• “Just one more mechanic”

Your goal is not “arcade history accuracy.”

Your goal is:

one small game that already feels good to play.

Why Godot + GitHub Is Such a Good Beginner Combo

Godot is a strong beginner choice because it has clear web export documentation, and projects can be shipped to the browser. Godot also has an ecosystem plugin called Godot AI Assistant Hub, which can read and write code inside the editor and can connect to local back ends like Ollama as well as several hosted options. The project is listed as MIT-licensed in both GitHub and the Godot Asset Library.

GitHub is not just a code host here.
It is your display shelf.

• Pages = “Play it now”
• Releases = “Download it now”
• README = “Understand it in 15 seconds”

GitHub Pages can publish from a branch or from a /docs folder, which makes it perfect for a clean beginner setup. GitHub also notes that Pages sites are public on the internet, and its release system is explicitly designed for software packages, release notes, and binary files.

For web export, Godot’s docs recommend using index.html as the export filename, and they warn that renaming exported web files later can cause issues because filenames are expected to stay aligned. Godot’s web export also requires browser support for WebAssembly and WebGL 2.0.

AI-Assisted Tools for Beginners Building a Pac-Man-Style Game in Godot

Prices and plans change often, so verify before publishing. The notes below reflect official pages checked on March 21, 2026.

Code and Implementation

Windsurf

Great when a small change ripples across multiple files. Official docs list Pro at $15/month and Teams at $30/user/month.

Best for: Advanced users

Cursor

Strong for agent-style coding and faster implementation loops. Its public pricing page lists Hobby Free, Pro at $20/month, and Teams at $40/user/month.

Best for: Advanced users

GitHub Copilot

Still one of the easiest starting points for beginners. GitHub currently lists Free, Pro at $10/month, and Pro+ at $39/month for individuals.

Best for: Beginners

Replit

Less relevant if you fully commit to Godot, but still useful if your real enemy is environment setup. Replit’s public pricing currently shows a free Starter tier, Core at $20/month billed annually, and Pro at $95/month billed annually.

Best for: Beginners

Engine-Integrated Help

Godot AI Assistant Hub

This is the most on-theme tool for this stack. It can read highlighted code, write code or docs directly inside Godot’s editor, and connect to local or hosted model providers.

Best for: Beginners

Unity AI

Not the right engine for this article’s main route, but worth mentioning as a comparison point. Unity describes Unity AI as a suite of editor-integrated AI tools, currently in beta, and says it is free during the beta period.

Best for: Advanced users

Planning and Pre-Production

Ludo.ai

Very strong for idea shaping, game concept work, and market-aware pre-production. Official pricing shows Indie at $15/month billed annually and Pro at $35/month billed annually.

Best for: Beginners

Art and Asset Flow

Scenario

Best thought of as a consistency machine. Scenario emphasizes training custom models on your own references to keep outputs aligned with your visual style, and its public pricing information shows a free tier plus paid plans.

Best for: Advanced users

Promethean AI

Less central for a tiny 2D game, but interesting if you grow into more asset-heavy workflows. Its pricing page says it offers a free version with AI asset management and some AI functionality.

Best for: Advanced users

NPC and Character Systems

Convai

Overkill for a first Pac-Man-style project, but valuable if you later pivot into NPC-driven experiences. Convai’s pricing page currently presents plan-based access starting from a Creator tier.

Best for: Advanced users

Coding Support Levels for Beginners

For this project, Godot is the default engine and GitHub is the default home for your project.
What changes is how much coding support you want.

Mode	Tools	Best For	What You Gain	Trade-off
Hard Mode	Godot + GitHub	People who want to write more by hand and learn through repetition	Deeper understanding of the basics	Slower progress and a higher chance of getting stuck
Normal Mode	Godot + GitHub + Godot AI Assistant Hub	Beginners who want help inside Godot without overcomplicating the workflow	Easier implementation inside the engine	More of the cross-file connection work still falls on you
Easy Mode	Godot + GitHub + Godot AI Assistant Hub + GitHub Copilot	Beginners who want stronger help with implementation, fixes, and code connection	Less manual coding and smoother debugging	Slightly more tool dependency
Advanced Power Mode	Godot + GitHub + Windsurf or Cursor	Beginners who want maximum AI coding support, or faster builders who are comfortable using more powerful tools	Strong multi-file editing and faster iteration	Powerful, but easier to lose control of if you are not careful

GitHub Pages comes later, at the publishing stage.
Use it when you want to turn your finished web export into a playable public page.

This guide is not a single path. It is a set of workable routes. If one route feels too hard, change the difficulty, adjust your tools, and try again.

The 100-Hour Roadmap

| 0 – 5 Hours: Lock the Shape

• One maze
• Two enemy types
• Start screen, game screen, result screen
• Grid movement plus turn buffering

| 5 – 20 Hours: Make Movement Feel Good

This is the soul of the game.
If turning feels bad, everything feels bad.

| 20 – 40 Hours: Add Pressure

• Enemy A: choose the direction that gets closer at intersections
• Enemy B: random turns at intersections
• Contact = lose a life

| 40 – 55 Hours: Add the Win Condition

• Dots
• Score
• “All dots collected” = clear

| 55 – 70 Hours: Make It Feel Like a Game

• Title screen
• UI
• Lives
• Sound effects

| 70 – 90 Hours: Tune the Fun

• Enemy speed
• Pause length
• Movement rhythm
• Retry flow

| 90 –100 Hours: Publish Like It Matters

• GitHub Releases for downloadable builds
• GitHub Pages for a browser build if your web export works

That final stretch is not “extra polish.”
It is the moment the project becomes real.

How to Publish Your Godot Game on GitHub Pages

This is the part that changes how the project feels.

A GitHub repo is nice.
A browser link is magic.

If you can send someone a link and they can instantly try your game, your first project stops feeling like homework and starts feeling like a real game.

A clean beginner structure looks like this:

• Repository root
  • README.md
  • screenshots
  • controls
  • “Play Now” link
• /docs
  • exported web build

That structure works especially well because GitHub Pages can publish from a /docs folder on a chosen branch.

And do not forget the README trio:

• Play now
• One screenshot
• How to play

That alone dramatically increases the chance that someone actually clicks.

Three Prompts That Keep Beginners Unstuck

Grid Movement

“Help me implement player movement in Godot for a Pac-Man-style game using grid movement, wall checks, and turn buffering so the player can queue a direction before reaching a corner.”

Enemy AI

“Write simple enemy movement for a Godot grid-based maze game. One enemy should choose the direction that gets closer to the player only at intersections. Another should choose randomly at intersections.”

Dot Clear Logic

“Help me build a dot collection system in Godot where the level clears when all collectible dots are gone, and the game updates score and UI accordingly.”

Tiny prompts beat huge prompts.
Every time.

The Traps That Kill First Projects

Trap 1: Trying to Recreate the Original Exactly

That is not discipline.
That is scope suicide.

Trap 2: Ignoring Feel Until the End

In this genre, movement feel is not polish.
It is the game.

Trap 3: Adding More Levels Too Early

Every new level multiplies testing, collision checks, spawn issues, and tuning time.

Finish one level first.

Always.

Final Line

If a beginner spends 100 honest hours building one small Pac-Man-style game, puts it on GitHub, and sends one link that says:

“Hey—play this.”

That is already a win.

Not because it is perfect.
Because it is finished.

And finished work changes what you believe you can build next.

One game becomes two.
Two become a shelf.
And one day, your GitHub stops looking like a code host and starts looking like a game cabinet.

That is the real prize.

Choose Your Next Step

Want another small 2D game idea to study by playing?

If this Pac-Man-style project made you want to build another compact arcade-style game, try this one first and look at how its core loop feels in action.
Play it as a development reference: Smackm — a 2D action tap game

Want a modern 3D reference for collect-and-run gameplay?

If you are curious about how maze-like movement and collection mechanics can evolve in 3D, play this as a reference and study how it handles speed, space, and player flow.
Play it as a development reference: Steam Runner

Want to build your own version next?

Go back to the roadmap, choose your coding support level, and make your own small game—one level, one clear goal, and one finished build.

FAQ

Can a beginner really make this in 100 hours?

Yes—if the scope stays small. One maze, two enemies, dots, score, lives, and a clean publish target is realistic. The impossible version is the “arcade-perfect” version.

Should I use Godot or Unity for this?

For this exact beginner-friendly web-publish route, Godot + GDScript is the cleaner fit. Godot officially supports web export, while Godot 4’s C# projects still cannot be exported to the web.

Can I publish a Godot game on GitHub Pages?

Yes. GitHub Pages can publish static files from a repo, and Godot can export for the web. You just need a working web export and a clean publish source such as /docs.

Should I also create a downloadable build?

Yes. Pages is great for instant play, but Releases is ideal for downloadable binaries and versioned updates.

Primary Sources

GitHub Publishing and Distribution

GitHub Pages: What It Is

URL: https://docs.github.com/en/pages/getting-started-with-github-pages/what-is-github-pages
Summary: Official explanation of GitHub Pages as a static hosting service that publishes HTML, CSS, and JavaScript files from a repository. (GitHub Docs)

GitHub Pages Publishing Sources

URL: https://docs.github.com/en/pages/getting-started-with-github-pages/configuring-a-publishing-source-for-your-github-pages-site
Summary: Official guide explaining that GitHub Pages can publish from a branch, the repository root, or a /docs folder, and can also use GitHub Actions. (GitHub Docs)

GitHub Releases

URL: https://docs.github.com/en/repositories/releasing-projects-on-github/about-releases
Summary: Official GitHub documentation showing that Releases can package software with notes and binary download links. (GitHub Docs)

Godot Web Export and Browser Publishing

Godot Web Export Docs

URL: https://docs.godotengine.org/en/latest/tutorials/export/exporting_for_web.html
Summary: Official Godot documentation for browser export, including the current note that Godot 4 C# projects cannot be exported to the web. (Godot Engine Documentation)

Godot 4.3 Web Export Progress Report

URL: https://godotengine.org/article/progress-report-web-export-in-4-3/
Summary: Official Godot article explaining improvements to the single-threaded web export path and why it reduces COOP/COEP-related deployment issues. (Godot Engine)

Godot Export Filename Guidance

URL: https://docs.godotengine.org/ja/4.3/tutorials/export/exporting_for_web.html
Summary: Godot documentation recommending index.html for web export and warning that renaming exported files after export can break the build. (Godot Engine Documentation)

Godot AI Integration

Godot AI Assistant Hub on GitHub

URL: https://github.com/FlamxGames/godot-ai-assistant-hub
Summary: Repository page describing the plugin as a Godot editor integration that can read and write code and connect to model providers such as Ollama. (GitHub)

Godot AI Assistant Hub in the Godot Asset Library

URL: https://godotengine.org/asset-library/asset/3427
Summary: Asset Library listing confirming the plugin’s core features and MIT license. (Godot Engine)

AI Coding and Development Tools

GitHub Copilot Plans

URL: https://docs.github.com/en/copilot/get-started/plans
Summary: Official GitHub plan comparison page for Copilot Free, Pro, Pro+, Business, and Enterprise. (GitHub Docs)

Windsurf Pricing

URL: https://docs.windsurf.com/windsurf/accounts/usage
Summary: Official Windsurf documentation listing current Pro and Teams pricing and included credits. (Windsurf Docs)

Cursor Pricing

URL: https://cursor.com/pricing
Summary: Official Cursor pricing page showing Hobby, Pro, Pro+, Ultra, and Teams tiers. (Cursor)

Replit Pricing

URL: https://replit.com/pricing
Summary: Official Replit pricing page for Starter, Core, Pro, and Enterprise. (Replit)

Planning and Asset Creation Tools

Ludo.ai Pricing

URL: https://ludo.ai/pricing
Summary: Official Ludo.ai pricing page showing Indie and Pro plans and positioning the product around game research and design support. (Ludo.ai)

Scenario Pricing

URL: https://www.scenario.com/pricing
Summary: Official Scenario pages describing style-consistent asset generation, custom model training, and the current free and paid plan structure. (Scenario)

Promethean AI Pricing

URL: https://www.prometheanai.com/pricing
Summary: Official pricing page stating that Promethean AI offers a free version with asset management and some AI functionality. (Promethean AI)

Convai Pricing

URL: https://convai.com/pricing
Summary: Official pricing page presenting its plan-based structure beginning with a Creator tier. (Convai)

Engine-Level AI Reference

Unity AI

URL: https://unity.com/features/ai
Summary: Official Unity page describing Unity AI as editor-integrated tooling that is currently in beta and free during that beta period. (Unity)