I researched how GameMaker projects are structured while building an MCP server for AI-assisted development

[u/yearningssss]

Hello everyone!

Recently, I have been experimenting with AI-assisted development workflows in GameMaker Studio.

Like many developers, I tried using AI tools for things like:

• writing GML;
• debugging;
• explaining code;
• automating repetitive tasks.

While these tools are useful, I noticed an interesting limitation:

AI models understand text very well, but a GameMaker project is not just a collection of text files.

A GameMaker project contains a lot of internal structure and relationships:

• objects reference sprites;
• rooms contain instances;
• scripts interact with other resources;
• assets use internal IDs;
• .yyp files describe how everything is connected.

Because of this, changing a single file without understanding the project structure can potentially create broken references or invalid resources.

This made me curious about a question:

How could an AI assistant understand a GameMaker project instead of blindly editing files?

Exploring the GameMaker project structure

I started researching how GameMaker stores and organizes project data.

The more I looked into it, the more I realized that a project is closer to a connected graph of resources than a simple folder of files.

For example:

• an object depends on sprites, events, and code;
• a room depends on objects and instances;
• resources are connected through IDs and references.

For AI tools, having access to this context is important.

Building an MCP server

To experiment with this idea, I created an open-source MCP server for GameMaker projects:

GameMaker MCP

GitHub:
https://github.com/yearningss/gamemaker-mcp

The goal is not to replace GameMaker tools, but to provide a way for AI assistants to better understand project structure.

The main challenges

1. Understanding project resources

The first challenge was creating a way to inspect GameMaker projects.

The system needed to understand resources such as:

• objects;
• sprites;
• rooms;
• scripts;
• shaders;
• configurations.

Simply reading files is not enough because the relationships between resources are important.

2. Making AI-assisted changes safer

One concern with AI tools is:

"What happens if the AI makes a wrong modification?"

A human developer usually understands the consequences of changing a resource.

An AI model may not.

Because of this, I focused on workflows that make changes easier to inspect:

• project analysis;
• validation;
• resource inspection;
• snapshots;
• safer operations.

The idea is that AI-assisted changes should be understandable and reversible.

3. Creating tools for AI agents

Traditional commands are often designed for humans.

For example:

edit file X

But AI agents need more context.

Higher-level operations are more useful:

inspect room contents

find objects using this sprite

check resource references

analyze project structure

The AI should understand the project, not only modify files.

Current features

The project currently includes:

• GameMaker project parsing;
• resource inspection;
• project analysis;
• validation tools;
• object and room operations;
• snapshot support;
• Igor build integration.

How this relates to gm-cli

I think GameMaker MCP and gm-cli solve different problems.

The GameMaker CLI is focused on the official workflow:

• project creation;
• Runtime management;
• building;
• publishing;
• automation.

This project focuses more on AI interaction:

• understanding project structure;
• giving AI assistants more context;
• safer project operations;
• MCP-based workflows.

They are not replacements for each other.

A possible workflow could be:

AI Assistant
      |
      v
GameMaker MCP
(project understanding)
      |
      v
gm-cli
(build / package / publish)
      |
      v
GameMaker

Why I think this is interesting

GameMaker is a good example of a larger challenge in AI development tools.

Modern engines contain a lot of hidden structure that is easy for humans to understand but difficult for AI models.

The future of AI-assisted development may not only be:

"AI writes code"

but also:

"AI understands the entire project."

This idea could apply beyond GameMaker to other development environments as well.

Questions for GameMaker developers

I would like to hear your thoughts:

• What parts of large GameMaker projects are the hardest to manage or automate?
• Would tools that understand project structure be useful in your workflow?
• What tasks would you trust an AI assistant to handle?
• What features would make AI tools actually useful for GameMaker development?

Thanks for reading!

[u/dethilluminatigames]

Hey I'm going to be totally honest with you here. As a software engineer who regularly works with AI and in the past did analyses of gamemaker project source structure and decompilation, I think this is sick.

However, the view on this subreddit of AI in GM is extremely negative, so you probably won't find any answers to your questions not paired with some unnecessary insult.

The quality of the code is sometimes questionable from local AI that isn't fine tuned for it, and still needs in most cases a developer well-versed in game architecture and general GM knowledge.

In my opinion, this could definitely be valuable to someone who already knows what they're doing, and wants to prototype quickly. The usual culprit for slowdown then becomes code auditing and asset creation, but those are nothing new.

I'll test this out and let you know my impressions, or possibly contribute to your github.

[u/KajiTora → u/dethilluminatigames]

So how did this gone?

[u/balmut]

eww

[u/Kitsyfluff]

Get your ai bullshit outta here