GameMaker is a 2D-focused game engine and integrated development environment that combines a room editor, sprite tools and its own scripting language, GameMaker Language (GML), into one package for building and exporting games. Among game engines in gaming, it occupies the niche of fast, approachable 2D production: it is simpler than general-purpose engines such as Unity or Unreal Engine, yet capable enough to ship commercial titles on desktop, mobile and console platforms.
The tool began in 1999 as Animo and then Game Maker, created by Mark Overmars as a teaching aid, and was later developed by YoYo Games. Its long history explains both its strengths, such as a mature event model and a large tutorial ecosystem, and its quirks, such as legacy functions that remain for backward compatibility.
How GameMaker structures a game
GameMaker organizes every project around a small set of asset types that the engine connects at runtime. Objects hold behavior, sprites hold animated images, rooms are the levels or screens where object instances are placed, and scripts, sounds, fonts, tile sets, paths and shaders complete the asset tree.
Behavior is written as event-driven code. Instead of one central function, each object reacts to engine events such as Create, Step, Draw, Alarm and Collision. The engine runs its own game loop and calls these events in a fixed order every frame, so a developer writes what an object does at each moment rather than the loop itself.
The following table lists the core events and what they are typically used for.
| Event | When it runs | Typical use |
|---|---|---|
| Create | Once, when an instance appears | Initialize variables and state |
| Step | Every frame (begin, normal, end) | Movement, input, logic |
| Draw | Every frame, after Step | Custom rendering, health bars |
| Alarm | After a countdown in frames | Timed actions, cooldowns |
| Collision | When two instances overlap | Damage, pickups, blocking |
| Destroy | When an instance is removed | Effects, drops, cleanup |
Because the engine handles instance management, collision checks and drawing order through depth and layers, a beginner can produce a playable prototype within hours. The trade-off is that execution order between instances is not always obvious, which becomes a common source of subtle bugs in larger projects.
GML and GML Visual
GameMaker offers two ways to express logic: GML Code, a dynamically typed scripting language with a C-like syntax, and GML Visual, a block-based editor formerly known as Drag and Drop. Both compile to the same underlying actions, so a project can start visually and move to code as the team grows.
Modern GML, substantially revised from version 2.3 onward, added structs, constructors, method variables, exceptions and anonymous functions. These features allow object-oriented and data-driven patterns that older versions could only imitate with arrays and global scripts, and they make GML much closer to JavaScript or Lua in practice.
| Aspect | GML Visual | GML Code |
|---|---|---|
| Learning curve | Very low | Moderate |
| Expressiveness | Limited to provided blocks | Full language features |
| Version control diffs | Harder to read | Plain text, easy to review |
| Typical users | Students, first-time designers | Professional and indie teams |
| Performance | Same runtime actions | Same runtime actions |
Experienced teams rarely stay in GML Visual, because text-based code scales better with source control, code review and refactoring. The visual mode remains valuable in classrooms, where it teaches events, variables and conditions without syntax errors getting in the way.
Runtimes and export targets
GameMaker compiles a project for a chosen platform through one of two runtimes. The VM runtime interprets compiled bytecode and builds quickly, which suits daily testing, while the YoYo Compiler (YYC) translates GML into C++ and compiles it natively, which can make CPU-heavy logic run several times faster at the cost of much longer build times.
The engine exports to Windows, macOS, Linux, HTML5, Android and iOS, and licensed developers can also target PlayStation, Xbox and Nintendo Switch. Console export requires the developer to be approved by each platform holder in addition to the appropriate GameMaker license tier.
| Stage | Recommended runtime | Reason |
|---|---|---|
| Prototyping | VM | Fast builds and quick iteration |
| Debugging | VM | Full debugger and profiler support |
| Performance testing | YYC | Reflects release-level CPU speed |
| Final release | YYC where available | Faster logic, harder to decompile |
| Web builds | HTML5 or GX.games export | Browser-specific runtime |
Rendering is handled by a 2D-oriented graphics pipeline with sprites, tile maps, surfaces and GLSL ES shaders. 3D is possible through vertex buffers and matrices, but there is no scene editor, lighting system or physically based materials, so 3D work requires building most of the rendering pipeline by hand.
How GameMaker compares with other engines
GameMaker is best understood as a specialist rather than a generalist. Godot, Unity and Unreal Engine all support 2D, but they are designed around broader scene graphs or entity systems, while GameMaker optimizes the common case of sprite-based games with a minimal set of concepts.
| Engine | Primary strength | Scripting | Best fit |
|---|---|---|---|
| GameMaker | Fast 2D production | GML | Platformers, shooters, RPGs in 2D |
| Godot | Open-source, node-based scenes | GDScript, C# | 2D and mid-scale 3D |
| Unity | Broad platform reach | C# | Mobile, mixed 2D and 3D |
| Unreal Engine | High-end 3D rendering | C++, Blueprint Visual Scripting | Large 3D productions |
Its commercial track record is the strongest argument for the engine. Titles such as Undertale, Hyper Light Drifter, Katana ZERO and Pizza Tower were built with GameMaker, which shows that the tool does not cap quality; design and art direction decide the result far more than engine features in 2D.
Limitations and common mistakes
GameMaker has clear boundaries that teams should evaluate before committing to a long project. Most problems come from using the engine against its grain or from habits formed in small prototypes.
- Weak 3D tooling: no 3D editor, no built-in lighting, so ambitious 3D projects belong in another engine.
- Global state overuse: relying on global variables and
withstatements makes large codebases hard to reason about. - Unclear instance order: logic that depends on which instance runs its Step event first breaks unpredictably.
- Pixel scaling errors: ignoring view, camera and application surface settings produces blurry or uneven pixel art.
- Licensing assumptions: platform export rights depend on the current license tier, which has changed several times.
The engine also depends on a single commercial vendor. Pricing and licensing have shifted over the years, from perpetual licenses to subscriptions and, since 2023, to a model with a free non-commercial tier and a one-time commercial license, so long-term projects should track these terms carefully.
A plain-language summary
GameMaker is a program for making video games, especially two-dimensional games where characters and scenery are flat pictures. You draw or import images, place them into levels, and tell each object what to do when something happens, such as a key being pressed or two things touching.
Think of it as a well-equipped workshop for 2D games. It does not try to do everything, but the tools it has are quick to learn, and many popular independent games were made with it.
An example from practice
A two-person independent studio plans a pixel-art action platformer for PC and Nintendo Switch with an eighteen-month schedule. The programmer chooses GameMaker because the team already knows GML and the game needs no 3D. Levels are built in the room editor with tile layers, enemies are objects with Step and Collision events, and player physics are written in a single movement struct reused by every character.
During development the team tests with the VM runtime for quick builds and switches to YYC for weekly performance checks, where a crowded boss stage rises from about 45 to a stable 60 frames per second. After approval by the platform holder, they export the same project to Switch with the console license. The result is a single codebase shipping on two platforms, with most engine-specific effort spent on input mapping and resolution scaling.