Introducción al Desarrollo de Videojuegos con GameMaker · Module 1: Introduction to GameMaker, Installation, and First Project
Welcome to GameMaker and Its Ecosystem
Lesson 1 of 60 · 45 min
Also available in: ES
Welcome to the Exciting World of Video Game Development
Video game development represents one of the most stimulating creative and technical disciplines of the digital age. It combines storytelling, visual design, software engineering, sound composition, and human behavioral psychology into a single interactive experience. However, for those first stepping into this field, the barrier to entry often feels overwhelming: concepts like linear algebra, graphics rendering pipelines, cross-compilers, and manual memory management in languages like C++ represent intimidating challenges that often frustrate early aspirations.
This is where GameMaker comes in. From its original conception, this tool was designed with a fundamental premise: to eliminate unnecessary technical friction so that ideas can take playable shape in the shortest possible time, without sacrificing architectural depth or performance. Throughout this comprehensive course, you will embark on a step-by-step journey where you will learn not only to master GameMaker from scratch, but to think with the structured mindset of a game developer, culminating in the complete creation of a retro-aesthetic 2D platformer title.
What Is a Game Engine and Why GameMaker?
A game engine is an integrated software development suite that provides creators with a pre-built technological foundation. Instead of writing low-level routines from scratch to communicate with graphics hardware (via DirectX, OpenGL, Vulkan, or Metal), decode audio files, detect keyboard input, or calculate elementary physics, the engine handles these infrastructural tasks. This leaves the designer free to concentrate on what makes their project unique: game rules (mechanics), player control, level design, and audiovisual response.
GameMaker stands out in the industry as an Integrated Development Environment (IDE) primarily specialized in two dimensions. While contemporary general-purpose engines like Unity or Unreal Engine integrate complex three-dimensional coordinate systems where 2D work is typically a flat projection inside a 3D space, GameMaker was born, matured, and optimized its mathematical and rendering core around the traditional two-dimensional Cartesian plane (horizontal X and vertical Y axes). This native specialization translates into more intuitive workflows, near-instant load times during the testing cycle, and predictable memory management.

History and Evolution: From Educational Tool to Indie Industry Standard
To understand GameMaker's current robustness, it is helpful to review its unique historical trajectory. The software was originally created in 1999 by Dutch professor Mark Overmars under the initial name Animo. Its initial goal was not to establish a commercial standard, but to provide his university computer science students with a visual tool that would facilitate computer graphic animation and event-driven programming without the syntactic roughness of the era's compilers.
With successive versions throughout the 2000s, the user community grew exponentially, pushing the tool toward productions of increasing complexity. In 2007, the company YoYo Games was founded to take over the continuous professional development, technological modernization, and commercial support of the platform. The arrival of key versions like GameMaker: Studio in 2012 marked a radical turning point: a cross-compilation architecture was introduced capable of exporting projects to Windows, macOS, Linux, iOS, Android, HTML5, and commercial consoles from a single codebase.
In January 2021, technology company Opera acquired YoYo Games, integrating GameMaker into a broader ecosystem focused on independent creators and community distribution via the GX.games platform. Under this leadership, the engine moved away from traditional major version numbering (such as GameMaker Studio 2) to adopt a continuous versioning scheme aligned with the year and month of release (for example, GameMaker 2024.x), accompanied by substantial improvements in the compiler, interface, and access model for the global community.
Success Stories: What Can You Really Achieve with GameMaker?
There is often an unfounded prejudice that tools accessible to beginners lack the power for high-caliber commercial works. The history of independent video games categorically proves otherwise in GameMaker's case. Several of the most critically acclaimed, internationally awarded titles with millions of copies sold worldwide were programmed and designed entirely within this environment:
| Title | Developer / Studio | Highlighted Genre | Technical Relevance and Impact |
|---|---|---|---|
| Undertale | Toby Fox | JRPG / Narrative Bullet Hell | Demonstrated GameMaker's power to handle complex dialogue branching, precise dodging mechanics, and persistent states. |
| Hotline Miami | Dennaton Games | Fast-paced top-down shooter | Genre reference for its breakneck pacing, unforgiving control response, relentless artificial intelligence, and stellar retro aesthetic. |
| Forager | HopFrog (Mariano Cavallero) | Incremental Adventure / Crafting | Showcase of massive active simultaneous instance management, dynamic inventory systems, and save persistence. |
| Spelunky (Classic) | Derek Yu | Platform roguelike | Cornerstone of the indie renaissance, based on procedural level generation using algorithms written in GML. |
| Katana Zero | Askiisoft | Neo-noir Action Platformer | Masterclass in fluid animation, choreographed cinematics, slow-motion mechanics, and precise response. |
These titles demonstrate that technical restrictions rarely lie in the engine, but rather in the conceptual clarity, algorithmic discipline, and aesthetic coherence of the development team. Everything that makes these games great—the interaction loop, the tight control response, and the visual fluidity—is built upon the exact same logical blocks we will build class after class in this program.
The GameMaker Ecosystem: IDE, Resources, and Execution Cycle
GameMaker is neither a simple source code editor nor a mere graphic editor: it is a cohesive Integrated Development Environment. To orient yourself effectively from this first contact, it is essential to distinguish the key components that structure any project within its ecosystem:
1. Asset Browser: This is the organizational panel usually located on the right side of the interface. It stores and hierarchically categorizes all the elements that make up the game: sprites (graphics and images), objects (logical entities with code), rooms (stages or levels), sounds, scripts, fonts, and shaders.
2. Sprites: Static or animated graphic representations composed of one or more frames (sub-images). Sprites by themselves have no intelligence or physics; they are the visible 'skin' that will later clothe the logical entities.
3. Objects and Instances: In GameMaker, there is a crucial entity-oriented design distinction. An 'Object' is the abstract definition, the template containing variables and behavior programming (for example, the player or enemy base class). An 'Instance' is the concrete, living materialization of that object placed within an interactive level at specific Cartesian coordinates. If you create the object 'obj_coin', you can place fifty independent instances of that coin in the same room.
4. Rooms: These are the spatial canvases where the action takes place. Every game in GameMaker needs at least one active room to run. Rooms configure stage dimensions, background layers, tilemap layers, and the placement of object instances.
5. Game Loop: GameMaker executes its world through a continuous cycle of frames per second (usually set to 60 FPS). In each of those 60 frames occurring in a second, the engine reads user input (keyboard, mouse, or gamepad), triggers logic and update events (Step), evaluates physical collisions, executes visual render events (Draw) to paint to the screen buffer, and finally plays the corresponding audio. Understanding this chronological sequence is the secret to avoiding conflicting code.
Programming Paradigms: GML Code versus GML Visual
GameMaker offers two main ways to structure project interactivity: GML Code and GML Visual (formerly known as Drag and Drop or DnD). Both operate on the same underlying engine principles, but present radically different methods of interaction:
GML Visual is a block-based visual programming system. It allows people with no prior code-typing experience to drag visual cards representing actions like 'assign variable', 'check if key is pressed', or 'play sound'. While friendly for a first few hours of introduction, it presents severe limitations in medium or large projects: visual reading becomes cumbersome, version control (Git) is extremely difficult to compare line by line, and the speed of logical structuring is considerably slower.
GML Code (GameMaker Language) is the engine's own textual programming language. It has a clean, intuitive syntax formally related to high-level languages like JavaScript and C. It allows millimeter control over data structures, agile refactoring, and the ability to express complex algorithms in a few readable lines. In this course, we will adopt GML Code as the primary vehicle language from the very first exercises, ensuring you acquire transferable programming skills and a professional understanding of game engineering.
GameMaker's Current Licensing Model
Access to GameMaker's development tools has evolved into an inclusive model that favors continuous learning. It is essential that you know the exact scope of your installation:
| License Type | Cost / Nature | Export Platforms | Intended Use |
|---|---|---|---|
| Free | Free download at no cost | GX.games (Web / Non-commercial desktop) | Complete learning, experimentation, prototyping, and open community web publishing. |
| Professional | One-time purchase | Windows, macOS, Linux | Development and commercialization of video games on desktop digital stores (Steam, itch.io, GOG, Epic Games). |
| Enterprise | Subscription (Monthly or annual) | Consoles (PlayStation, Xbox, Nintendo Switch) + Mobiles | Professional teams with development kits authorized by console hardware manufacturers. |
For the purposes of this entire course, the Free version of GameMaker is 100% sufficient and fully functional. There are no artificial limitations inside the editor: you have full access to the compiler, all GML Code functions, the particle system, room and sprite editors, and advanced debugging tools. You will be able to complete each module, program your game, and test it locally with total freedom.
The Cross-Cutting Project: Building a Retro 2D Platformer
Learning software development in a fragmented or purely abstract way often leads to conceptual gaps. Therefore, this course is organized around a cumulative core project: we will program a classic retro 2D platformer video game from scratch.
Through 12 modules and their 60 classes, we will progressively solve each of the real subsystems required by such a work:
- Modules 1 to 3: Project setup, structured creation of the asset browser, and mastery of foundational GML Code syntax.
- Modules 4 to 6: Character control via keyboard and gamepad, acceleration and deceleration physics, constant gravity, collisions with solid boxes and precision tilemaps, visual state machines to transition idle, run, and jump animations.
- Modules 7 to 9: Basic artificial intelligence for patrolling enemies, damage routines, lives, checkpoints, coin collection, on-screen user interface (HUD), and atmosphere with sound effects and particles.
- Modules 10 to 12: Smart follower camera movement, clean transitions between multiple rooms, interactive start and pause menus, performance debugging, and generation of the final distributable package.
First Conceptual Contact with Code: The Event Paradigm
Although we will dedicate the next chapters to setting up the software and breaking down the interface, it is useful to examine right now how GameMaker 'thinks' regarding programmed logic. Unlike a traditional console program in C++ or Python where the flow begins in a rigid entry function like main(), GameMaker operates driven by events that react to time cycles and system stimuli.
The three cardinal events that will govern our future platformer hero are:
- Create Event: Executes once at the exact moment the instance is born inside the room. This is the exclusive place where we define and prepare initial variables (for example, top speed, assigned gravity, or health points).
- Step Event: Executes continuously on every game frame (60 times per second). This is the beating heart of the entity: here we read if the user is pressing a key, update spatial coordinates, and evaluate collisions.
- Draw Event: Responsible for visually projecting the entity on screen. By default, GameMaker draws the assigned sprite automatically, but this event allows adding custom visual effects, drawing custom shadows, or rendering floating health bars.
💡 Methodological tip: Patience and attention to detail are a game developer's greatest virtues. Programming errors (bugs) are a natural part of the process. Throughout the course, we will learn not only to write functional code, but to calmly read compiler messages to diagnose and fix problems analytically.
Assimilation and Reinforcement Exercises
To consolidate the knowledge acquired in this first lesson, complete the following three conceptual and analytical activities:
1. 2D Genre Decomposition Analysis: Select one of your favorite 2D video games (either from those mentioned like Undertale or Spelunky, or any classic you know). Write down in a document or notebook a broken-down list with at least 4 key elements that make up its game loop: a) What does the main character do in the continuous Step event? b) Which stage elements represent solid instances? c) Which elements act as collectibles? and d) What information does its interface or HUD display permanently?
2. Conceptual Distinction Between Object and Instance: Explain in your own words the practical difference between an Object and an Instance in GameMaker using an everyday analogy outside of computer science (for example, a house blueprint versus houses built in a neighborhood, or a cookie cutter versus baked cookies). Why would it be a serious design error to create a new object for each of the 100 coins populating a level?
3. Game Loop Identification: If a video game in GameMaker is configured to operate at a standard speed of 60 frames per second (Game Speed = 60), calculate exactly how many times the code inside an enemy's Step event will execute over the course of one minute of uninterrupted game play. Check your calculation by multiplying 60 cycles per second by 60 seconds in a minute (3,600 executions per minute). Reflect: why is it critical that complex mathematical operations inside the Step event remain lightweight and optimized?
Summary
- GameMaker is a game engine and Integrated Development Environment (IDE) natively optimized for two-dimensional video games, eliminating complex low-level technical barriers.
- Born in 1999 by Mark Overmars and continued by YoYo Games and Opera, it has a proven industry track record with benchmark titles like Undertale, Hotline Miami, and Katana Zero.
- The engine ecosystem is structured around interconnected resources: Sprites (graphics), Objects (abstract logic), Instances (living entities at coordinates), and Rooms (interactive stages).
- GML Code is the engine's formal textual programming language; it offers high flexibility, portability, and clear readability, outperforming the GML Visual block system in the long run.
- The current Free license allows complete development, unlimited testing, and community publishing on the GX.games web platform, being fully functional for this entire training program.
- Throughout the course, we will develop a complete retro 2D platformer video game step by step, applying best practices in software architecture and gameplay design.
Practise what you learned
Exercise 1 · 1 point
What is the fundamental difference between an Object and an Instance in GameMaker's architecture?
Exercise 2 · 1 point
Match each component of the GameMaker ecosystem with its corresponding description:
- Sprite
- Room
- Asset Browser
- Instance
Exercise 3 · 1 point
Arrange in chronological order the steps GameMaker executes during each cycle of the game loop, from the start of the frame to the end:
- 1Playing the corresponding audio
- 2Evaluating collision checks
- 3Reading user inputs (keyboard, mouse, or gamepad)
- 4Executing visual rendering events (Draw) to paint the screen
- 5Triggering logic and update events (Step)
Sign in to save your progress — Sign in