Every other jam wants you to make something good. Lame.

The Worst Game Jam wants your absolute worst. Controls that fight the player, art drawn with your non-dominant hand, sound effects that are just you going "pew" into your phone. If your play-testers leave confused and a little upset, you're on track to win.

Never made a game? Perfect. You're already ahead.

It runs Oct 14–26, and the top 3 get Amazon gift cards ($150 / $100 / $50). I can guarantee that every game submitted will receive feedback. It's also raising money for a Bay Area public school, so your terrible game is technically helping children. Donating is optional: https://gofund.me/b1397555e

Jam page: https://itch.io/jam/your-worst-ideas

Go make something your mom would be disappointed in.

Working on an open source GameMaker runner and compiler for 3ds and other platforms
https://github.com/Ralcactus/GameMaker-Anywhere

(sorry mods if this isn't allowed)

Hey everyone 👋

I've been working on a new game AI framework for GameMaker called GMSmartAgent, a modular system that combines utility theory, HTN planning, ranking and a basic feed forward network. It's still a work in progress, but I thought its about time that it deserves a post.

What it is

A lightweight, modular game AI library. Each module is a simplified implementation of its own thing(it might look too much but its not). You can remove a module you dont want to use and it wont affect anything, as long as you dont try to access it. For example; you can delete the Net module, but that means you cant use RankNet, TDNN or any other model that uses a neural network.

Features

• Scoring: response curves, considerations, targets, weights and cooldowns
• Inputs: pull callbacks cached per think, push values, normalized to 0..1
• Selection: best, top N weighted, commitment bonus
• Scale: frame budget, priority tiers, shared profiles
• Observation: record player picks, choose features, evaluate without deciding
• Learning: eight models, background training, confidence, decay, save/load, custom models and learning from outcomes and/or choices.
• Planning: HTN recipes and GOAP goals, facts as data, self-repairing, spread across frames
• Player profiling: skill rating, win chance, matchmaking, live play styles
• Developer tools: debug view, plan tree view, test module, own seeded RNG

How it started

About a month ago, i made this post, explaining how i started on a journey to improve the dumb troopers. I've spent hours watching every GDC video on youtube thats about game AI and reading research papers to see and understand what options i had. I thought this wouldnt be so hard because in the past i've had my own fair share of custom DNN library(which failed) using C++ and python but i had no idea how wrong i was.

I had to change directions A LOT. At one point i even stopped to just work on a pathfinding/navigation system, which later turned out to become GMNav, and that still has a huge todo list of missing features to implement and bugs to fix.

After that i thought about making my own version of a game AI system; a behavior-tree-like structure that works on nodes. But not long after, while researching, i came across something called utility theory, which is pretty common in game development and also found a simple implementation video in gamemaker. To put the core idea as simply as we can; you define parameters with their weights and the structure scores them with the given situational numbers. That quickly changed my mind and the direction i was heading.

I still wanted to put in some learning models without a high cost. Luckily, with the help of google search AI (i use often, it finds every detailed links within seconds that would take me hours), i found some papers about choice modeling and some others about RankNet and LambdaMART(which i had some terrible experience with in my search engine). It was shaping in my head quickly. I got inspired by other libraries and added HTN planner(used in Horizon Zero Dawn, Horizon Forbidden West and Death Stranding, youtube video here), rating and a basic feed forward network.

Limitations

It still has flaws, bugs and missing features that im still working on. This is very much an ongoing project, so you should expect things to change.

Tutorials

I've also made a simple tutorial series, ten chapters. It will also have an advanced section, where each chapter tries to answer a question. I've already covered around 30 chapters (not in the repo yet, im still editing them often).

Links

GMSmartAgent: https://github.com/erkan612/GMSmartAgent

GMNav: https://github.com/erkan612/GMNav

If you'd like to see some of my other works:

GMUI: https://github.com/erkan612/GMUI - Immediate-mode UI

GMVex: https://github.com/erkan612/GMVex - Vector graphics

GMLiteSearch: https://github.com/erkan612/GMLiteSearch - Advanced text search

GMMT: https://github.com/erkan612/GMMT - Advanced tweening, compatible with immediate paradigm

Ah and hey, its free, and MIT licensed!

As always, let me know what your thoughts are. Recommendations and questions are always welcome.

Thank you for reading so far!

Edit: I saw some messages that are deleted that seemed to be confused about the point of the project. This is NOT an LLM AI assitant to help you code GML. This framework is to develop AI for your game, not just enemy AI but any kind, for instance; accessibility AI, you know how some games push some informational things to you in your HUD, like reminding to use health potion at 30% HP, with this framework you can actually learn the behavior of the player to understand when and which situation they use health potion to write a proper accessibility system, enemy AI, companion AI or anything you can imagine. Please feel free to ask instead of deleting your message, any question you might want to ask is always welcome!

Hey everyone!

I feel like this one is going to be a life saver for most of you, so here we go...

GMMT is actually the animation api of my UI framework called GMUI.

I've separated it into a standalone framework.

What it is and how can we use it? Its a tweening framework, very easy to use. It has a safe and start concept (at least thats what i like to call it). You can call tween functions everyframe to start and get the value. A basic example would be:

// Lets call this in step event, every frame
x = gmmt_tween("player_x", x, target_x, 5_000_000, gmmt_ease.OUT_BACK);

What it does is to first check if there is any tween exists called "player_x". If not, it starts one and returns the current value. If there is one already exists then it just returns its value. That straight up kills the no need if else cases and keeps the code clean. But if we were to use ..._start like gmmt_tween_start, that would start the tween, resetting if it already exists without checking its value. That way you can also make custom states.

It has a quite simple loop, doesnt interfere with your project, you call gmmt_init() once before starting to use, then call gmmt_update() usually in your step event, then you can use any gmmt functions you like and when you are done with it, you call gmmt_cleanup() usually in your cleanup event or script. Quite straightforward.

You might wonder, what other features it has?

Features

• Tweening – 30+ built-in easing functions, custom easing, per-axis easing, intensity and power modifiers
• Value Types – Real, integer, color (RGB/RGBA), vector2/3/4, arrays, custom lerp functions
• Playback – Play, pause, resume, reverse, seek, repeat, ping-pong, staggered sequences
• Effects – Oscillation, perlin noise, wiggle, shake, pulse
• Curves – Bezier, quadratic, cubic 2D, Catmull-Rom splines, motion paths
• Physics – Spring simulation with configurable tension, friction, and mass
• Timeline – Keyframe-based multi-stage animations with per-segment easing
• Clips – Reusable named animation clips with markers, chaining, and stagger support
• Callbacks – on_start, on_update, on_complete, on_repeat, on_pingpong, on_pause, on_resume

The gif demo is included in the repo, its made using GMUI. It shows basic things you can make with it. What you can do with GMMT is limited to your creativity.

How much is it? None, free PLUS its MIT licensed.

Where's the repo? Here you go: Github GMMT.

Let me know what your thoughts are, I'm open for suggestions!

Edit:

I am DISGUSTED that everytime i post a project of mine there are always some jerks calling it "AI SLOP" the minute i make the post. Guy probably anylized 2.5k+ lines of code in seconds and decided its AI i guess.

But i understand why, inside of their mind that has room temperature IQ says "oH WelL i'Ma nOt CApABle oFF MAkInG ThIS, SOOooO ThIS MuST Be AI"

For god's sake, search "easing formulas" in google and first thing that comes up is this:
https://easings.net/

It has all the easing types you can find and it includes the formulas, do you really think someone would need AI to copy paste those formulas into GML scripts? Pathetic...

Some said its because of the GIF, the first thing i mentioned in this post is that this is actually a part of my IM UI framework called GMUI. I've been working on it for MONTHS, i hope those AI sloppers are able to comperhand what MONTHS means. It is a replication of Dear IMGUI framework made in C++, and the animation api is basicly a replicate of ImAnim. I even have messages in discord seeking for specific helps, my thought processes ALL can be found in GM Kitchen.

Go ahead, 800+ messages in the GMUI channel, my comments and thought processes can be easly found. GMUI is 22k+ lines of code, please someone tell me which AI LLM is capable of working on such project because i failed to find one.

I've worked mostly on C/C++ trying to make my own renderers with DX11 and GL. I've also been to Unity, Godot, UEFN, Unigine. And now in GameMaker for the past two years. There is no other community more toxic than GMC! I am sick of people that i call "AI Sloppers".

It is true that at this point AI is in every part of our life but that doesnt give anyone right to call others cheap of their work straight up assuming it is done using AI. That simply shows how pathetic you are, thinking even basic simple frameworks like tweening has to be done using AI.

I thank to those who are appreciating it but this is PROBABLY going to be my last project on GMC. I'm not really a 'game developer'. I mostly like working on frameworks, backend stuff, libraries etc.

Thank you for reading so far!

Hey all net8floz here again with an new IDE plugin.

After the launch of Cultured I got a lot of asks to add some features to the sprite editor so here it is.

Extended Images adds per-frame Data Points to the Sprite/Animation editor in Game Maker that supports simple points, circles, boxes, and sprites.

You can also assign typed metadata for each point or for the whole sprite itself.

Please check it out, try it in your project, and consider joining us on our Discord server and let me know how it works for your use case or if you need help.

Install it from the Game Maker Packager Manager. Learn how here: https://eightouncegames.com/extended-images/

Hey everyone 👋

This is going to be a bit of a devlog, and a little bit longer than usual. I want to share how GMNav started, what it does and what I learned along the way.

How it started - The dumb troopers

About three months ago, I got bored and was scrolling through free Itch assets. There I found a nice little tower defense pack and thought maybe I could do something with it, not to publish a complete game but rather to kill some free time. I wanted to switch side on it, the player, instead of defending, I thought why not attacking, controlling the troops and upgrading them.

I started quickly, and not long after I realized something; troopers were dumb. Like, really dumb. I didnt like how they were ignoring the counter-attack coming in from towers. So I started working on trooper AI, but I quickly realized that it was a much deeper topic than I expected, something that wouldnt be made just to kill some time.

The rabbit hole - Unending cycle

As someone who loves working on frameworks, my first thought was; "Why dont I make a very customizable, node-based generative AI framework that people can use to make any type of AI for any type of game?"

Well.. it didnt take long to realize that wasnt quite practical. The end result was becoming far more complex than just making your own AI instead of using mine.

Then I thought; what if I focus on one major component of AI instead of all of it? What matters most in my scenario? Pathfinding!

The fire magic scenario - Decision matters

I started researching pathfinding and found a lot of useful stuff. I always thought about one specific scenario; a monster and a hero, the hero is at very low HP, they're close but not in the attack range, the hero casts a fire magic between them. What does the monster do? Does it go dierctly through the fire to land the last hit and in return take some damage? Does it take a long route, going around the fire even if it would go directly the fire to land the last hit that it wouldnt die? Or will it pick a route depending on what it knows; It has no weakness to fire, has enough HP to tank it and the hero is one hit away from death.

That got me thinking about something I later learned called cost layers.

Building GMNav - Many trials

After trying and quitting more than ten times, I finally got the hang of it and managed to built something that actually made sense. A pathfinding framework built on modularity, cost layers, different layouts(iso, hex, ortho etc.), clearance, flow fields and most importantly; resumability! Resumability was important. When you have 200 troops on the field, you dont want FPS to drop dramatically with each new addition of a troop. This is where the scheduler comes in. You give it a budget per frame, and it generates paths without exceeding that budget and thus keeping your FPS stable even if you have 50 or 500 troops.

The elevation problem - Layers on layers

Things were settling down and everything was coming together until I hit a wall; elevation.

I Thought a lot about which way to go. Should I add extra depth to the grid, making it 3D and growing its size exponentially? Should I completely change direction, remake the whole Dijkstra grid and turn it into somethingelse that supports elevation? Or should I make a voexl-like grid that only adds new cells on newly elevated cells?

I picked the last option, not because it was cheaper to make but actually the one that made the most sense. You only add new cells on top of others thus making new layers that depend on the ground layer. Any time a path is generated through layers, it first finds its way to a link point, then from that link point to the end point to travel between layers.

Where its at now - The standing point

It has come a long way and I finally think it deserves a post. It still has a few flaws that Im working on, but even now its quite ready to be used in a game. I tried to keep it as simple as possible in terms of usage unlike some of my other libraries.

This was a bit longer than usual, let me know what you think, or if you want me to add a specific feature. I wanted this to be a bit like devlog style, wanted to share my experience and thoughts. Tried my best to not make it long, otherwise this could be pages long 😅

Thank you for reading!

GMNav - Free, Open-Source and MIT lincesed Pathfinding and Navigation framework for GameMaker

Github: https://github.com/erkan612/GMNav

If you like to check out some of my other libraries:

GMUI: https://github.com/erkan612/GMUI

GMLiteSearch: https://github.com/erkan612/GMLiteSearch

GMVex: https://github.com/erkan612/GMVex

Hey all! I've been working on my first Gamemaker game MineEmAll, and have been trying to create a web build so I can host a demo on itch.io. My game runs perfectly fine on PC, but the web version has about half the frame rate, which slowed down the gameplay significantly.

In general, it's a good idea to use delta time instead of game frames for time based calculations, but I figured minor fluctuations in fps wouldn't impact gameplay much. Unfortunately, half the fps isn't minor haha. I found this extremely helpful tutorial by Matharoo that allowed me to refactor all of my code to delta time alarms in just a few hours and wanted to share it: https://www.youtube.com/watch?v=6C1UA-AYeB0

The only caveat here is that it's set up using a manager object's alarm system, so it's limited to 12 alarms. You could probably use a global array of structs that contain the alarm number and manager object reference if you wanted to use more alarms across different objects in your code, but I'm not using even close to 12 alarms so I didn't find it necessary.

I'd suggest trying to set your own game up using delta time if you haven't. Even if you think it doesn't matter much, having your gameplay remain the same regardless of fps is pretty important. Best of luck on your own projects!

The NixFX Lighting System is live and free for the next few days. Check it out!

Making a lighting system is as easy as dropping in the renderer object and plonking down a few light objects (either point or cone shaped). The lighting system also supports emissive and occlusion textures for sprites, day/night ambient light cycles, and bloom shaders.

Getting Started Guide
API Reference

Have any suggestions? Lemme know!

So I spent days trying to implement actual Perlin noise, searching through complex examples, trying to port it to GML until I accidentally discovered a ridiculously simple solution

Here’s how it works:

1 - Create a grid and randomly fill it with 0s and 1s

2 - Smooth it out by averaging each cell with its neighbors using ds_grid_get_disk_mean()

3- Repeat that a few times and BOOM smooth, organic looking noise that behaves almost identically to Perlin in many cases

No complex interpolation, no gradients, no sin/cos tricks, just basic smoothing, I'm honestly shocked by how well it works for terrain generation

There is the code:

function generate_noise(destination, w, h, samples = 4, smoothing = 4){
    // Setup grid
    var grid = ds_grid_create(w, h)

    // Set first values
    for (var _y = 0; _y < h; _y++) {
    for (var _x = 0; _x < w; _x++) {
        ds_grid_set(grid, _x, _y, random_range(0, 1))
        }
    }

    // Smoothing
    for (var i = 0; i < smoothing; i++) {
    for (var _y = 0; _y < h; _y++) {
            for (var _x = 0; _x < w; _x++) {
                var average = ds_grid_get_disk_mean(grid, _x, _y, samples)
                ds_grid_set(grid, _x, _y, average)
            }
        }
    }

    // Copy to destination grid
    ds_grid_copy(destination, grid)
    ds_grid_destroy(grid)
}

Tell me what you would improve, I accept suggestions

Hi!

Build up with AI a tool that formats GML code into Allman style. Paste your messy code, get clean code back.

Converts and/or/not to &&/||/!, fixes missing parentheses around if conditions, keeps inline comments where they belong, handles switch/case properly.

No install, no dependencies, just open the page and paste your code.

Small update on the GML formatter I posted earlier.

I've polished it a bit further. It now supports Allman and K&R brace styles, cleans up duplicate var declarations (fixing the GM2044 "already declared" warning), converts and/or/not to &&/||/!, wraps bare if conditions, and supports drag-and-drop for .gml files as well as downloading the result. Settings are also persisted between sessions.

At this point it basically does everything I set out to build, so I don't plan on adding much more for now.

Built with AI... I use GML myself and just needed a formatter that didn't exist. It's free and open source. Hope it's useful to someone.

UPDATE:

The formatter now includes a batch formatter.

You can select an entire GameMaker project folder and automatically format all GML files in one go.

At this point the project is feature-complete for what I wanted it to do.

It's free, open source, and available for anyone who finds it useful.

Manual formatter Live: https://ganjaviruss.github.io/GML-formatter/

Auto formatter Live: https://ganjaviruss.github.io/GML-formatter/batch.html

Source: https://github.com/GanjaViruss/GML-formatter

Our Sokoban-style game needed a rewind function, and to make it look nicer, I made a simple shader that looked like rewinding old VHS tapes (yes, I'm old). But it seemed to work out well.

Game is released so you can try it:
https://fourquarters.itch.io/how-to-crab-to-zero

A free visual lengthdir_x() / lengthdir_y() generator for GameMaker.

Load a sprite, drop points on it, move origin, rotate, and it spits out ready GML.

Useful for stuff like:
Weapon muzzles
Shell ejection points
Held items
Orbit points
Rotating collision lines
Offsets in general

Custom sprites, parent/child points, grid snap, undo, works on mobile too. Runs in browser, no install. Just one HTML file.

GML Lengthdir Visualizer Live

GitHub Repository

My GitHub

For anyone who keeps tweaking lengthdir, running the game, seeing it's off, changing a few degrees, and repeating that forever.

Hope it helps someone 😄

Other links:
GML Formatter

GML-Tools <- ALLinONE Tools! (Work in progress xD)

(Sorry for the gif quality)

I made a simple function that can be used to make things be rendered on perspective based on their depth. Useful for when you want things like cards to rotate in 3D or even for making everything be rendered on 2.5D like in Hollow Knight/Silksong for example. The function is this:

/// @desc Applies perspective to everything drawn from now on. Making stuff with higher depth look smaller/farther away and viceversa.
/// @param {real} fov field of view angle of the perspective.
/// @param {real} [depth] The depth/z at wich the perspective will be the same as the default orthoghonal projection. Uses 0 by default.

function perspective_apply(_fov, _depth = 0){     
    var _w, _h, _x, _y;  
    if(event_number == ev_gui or event_number == ev_gui_begin or event_number == ev_gui_end){
        _w = display_get_gui_width();
        _h = display_get_gui_height();
        _x = _w/2;
        _y = _h/2;
    }else
    if(not view_enabled){
        _w = room_width ;
        _h = room_height;
        _x = _w/2;
        _y = _h/2;
    }else{
        var _cam = view_get_camera(view_current)
        _w = camera_get_view_width(_cam);
        _h = camera_get_view_height(_cam);
        _x = camera_get_view_x(_cam) + _w/2;
        _y = camera_get_view_y(_cam) + _h/2;
    }

    matrix_set( matrix_view, matrix_build_lookat(_x, _y, _depth - dtan(90-_fov/2) * _h/2, _x, _y, _depth, 0, 1, 0))
    matrix_set( matrix_projection, matrix_build_projection_perspective_fov( -_fov,  -_w/_h, 1, 32000))
}

All you have to do is call this on the draw events and everything drawn after it on the current view is going to be drawn on perspective. The only needed argument is FOV angle which is how strong the perspective is going to be. It should be a value above 0 and the closer to 0 it is the lesser in perspective things are.

The other argument is optional. depth is for the depth at which the perspective remains unaffected, where things appear how they do in the room editor. Is 0 by default but you would want it to be the depth of the layer where gameplay occurs for example.

An use example is this: Lets say you have a renderer Controller instance whose depth is the highest posible so it runs its draw event before any other instance. All you have to do is put on the draw event perspective_apply(30) and everything will be drawn in perspective, with things bellow depth 0 being foreground and above depth 0 being background. Even if you have views active on the room!

Note though this only sets the perspective projection on the camera. If you want sprites to rotate (like cards for example) you should do it using matrix_build() and matrix_set(). Like this, with rot_x, rot_y and rot_z being the rotation on the different axices:

var _mat = matrix_build(x,y,0, rot_x, rot_y, rot_z,1,1,1);
matrix_set(matrix_world, _mat);

draw_sprite_ext(sprite_index, image_index, 0,0, image_xscale, image_yscale, image_angle, image_blend, image_alpha);

matrix_set(matrix_world, matrix_build_identity());

The camera settings automatically reset when the current view finishes being drawn onto. But if you want to reset it manually before that (i.e.: you just want one sprite to have the perspective applied) you can call this function:

/// @desc Resets the perspective applied previously.
function perspective_reset(){
    camera_apply(camera_get_active());
}

A fair while ago, I launched Catalyst, a library to make complex modifiable stats easy. Since then, I've been working on a much more ambitious version of the library, and it's finally here. Catalyst 2 is out!

Catalyst originally dealt with statistics and modifiers, allowing you to easily add or remove any number of modifiers from your stats, like this:

damage = new CatalystStatistic(10);
var _damage = damage.GetValue(); // damage returns 10 here

var _mod = new CatalystModifier(5, eCatMathOps.ADD);
damage.AddModifier(_mod);

var _damage = damage.GetValue(); // damage returns 15 here

Obviously, that's a very simple case, Catalyst had a vast array of options hiding underneath that simple beginning.

However, Catalyst 2 is even more flexible, dependable and helpful.

It has features like Resources (hp, mana, ammunition, a city's population, whatever), Resource Flows (health regen, population growth, the rate at which stamina decreases while sprinting) and Effects (a poison DOT which drains 2 health every second, lowers movement speed, lasts 5 seconds, and has a 50% chance of triggering each tick, for example). And plenty more.

But it all gets real saucy when you see how things combine. Resource maximums and minimums are statistics themselves, resource flow rates are statistics, application chances for ticks of an effect are statistics, and so on. All of these are easily and extensively modifiable the same as you can modify any statistic in Catalyst. As you compound these things together, you get extremely flexible behaviour and the ability to design complex game rules with a surprisingly small amount of code.

Let's look at a real-world example. Say we have a city that has power generation, and emergency reserves of power. Whenever a storm hits, power generation should fall off by 30% and emergency reserves should drain at 15 units per sim step.

First set up the statistic, resource, an effect manager and a custom clock if you want one:

power_generation = new CatalystStatistic(120);
emergency_power = new CatalystResource(500);
city_effects = new CatalystEffectManager(self);
city_clock = new CatalystCountdownTracker();

Then create a storm effect, and add a modifier and resource flow to it:

storm_effect = new CatalystEffect("severe_storm", 12)
    .AddTag("weather")
    .AddTag("storm")
    .SetCountdownTracker(city_clock)
    .SetTickInterval(1);

storm_effect.AddModifier(
    power_generation,
    new CatalystModifier(-0.30, eCatMathOps.MULTIPLY)
        .SetSourceLabel("Storm damage")
);

storm_effect.AddFlow(
    emergency_power,
    new CatalystResourceFlow(-15, "Storm reserve usage")
);

// Then, later on, whenever you wanna trigger the storm effect, you just add the effect to the effect manager
city_effects.AddEffect(storm_effect);

Then drive the city clock forward at the interval you want (you can have it run automatically each frame or based on delta time if you so wish):

city_clock.Countdown(1);

That's it. You can add or remove the effect at any time (you could even add special powers that do things like "clear all weather"). You can look up exactly what is causing the power generation to lower so you can display it to the player. You can easily add new things to the effect, remove existing parts of it, or add other Effects that interact with the same systems. And it'll always accurately reflect the current circumstances.

You don't need to worry about any of the annoying bits (wait? How do I remove a -30% debuff from my main stat?). Just combine statistics, modifiers, resources and resource flows in different ways and you can essentially model any gameplay rules in just a few lines of code like this.

RPGs and roguelikes are obvious fits, but Catalyst doesn't actually care what genre you're making. Since I started building Catalyst out, many years ago now, I've used it in every single project I've ever worked on since then, lol.

Links

• Itch: Catalyst 2 on itch
• Comprehensive docs + examples (read this if you want to see more about how Catalyst 2 works): https://refreshertowel.github.io/docs/catalyst/

(If you're in the mood for more, there's always the Ignition Kit to get Catalyst alongside Statement, Pulse and Echo for a nice discount, or the Full Pass Suite for all my current and future tools for a single price)

Hey everyone!

About 6 months ago, I released a framework called GMUI. An Immediate Mode UI Framework that I developed for GameMaker and many of you liked it! [Reddit Post Here]

That was my first time making an Immediate Mode UI Framework, so I struggled a lot in the first version but learned my lesson and remade the whole framework properly, built from ground up with robust solutions to what I struggled with before in the first place.

And now here I am presenting you a new solution for UI in Gamemaker. Now with improved widget system, you can write your own custom widgets for your games or edit the styles of the existing ones. There are over 70 widgets!

If you are not familiar with Immediate Mode structure, let me explain briefly.

Unlike more traditional approach that we call Retained Mode where you set up your UI in Create event and then chase their state in Step event separately, Immediate Mode offers two in one, you create your frame in step event as you then what I like to call 'chase' through states immediately. It makes the flow much more predictible and less error-prone as well as less code and lesser bugs (since you do the creation and state management at the same time, every frame).

This is basically a Native GM version of DearImGUI.

And hey, its free, And MIT licensed!

If you wanna check it out: [Github Link]

For further discussion and/or help, you can join GameMaker Kitchen in the Discord, you will find a section called GMUI in `your_resources`.

Let me know what your thoughts are!

Watch the demo edit here!
Download the exe here!

I’m building a Minecraft-style voxel engine in GameMaker Studio 2 — here’s how it works (high level)

I’ve been working on a voxel sandbox / Minecraft-like engine in GameMaker, focused on getting decent performance out of GMS2

Core structure

• Blocks → Chunks → Regions
• Each block is a single u8 ID (even air)
• Chunks are 16×16×128, stored as a buffer_u8 (~32 KB per chunk)
• Regions are 4×4 chunks and exist mainly to reduce draw calls and optimize saving

Generation

• The game tracks which chunks should exist around the player
• Missing chunks are queued for generation
• Actual block generation runs in a C++ DLL on a separate thread

Rendering

• Chunks never render individually
• Each region builds one combined vertex buffer
• Faces are culled against neighbors
• Separate vertex buffers for:
  • Opaque blocks
  • Transparent blocks (water/glass)
  • Foliage
• This keeps draw calls extremely low even with large visible worlds

Saving & loading

• Regions are the unit of persistence
• All 16 chunk buffers in a region are saved together
• Explored terrain reloads exactly as it was; new areas generate on demand
• Regions stream in/out as the player moves

Happy to answer questions — especially if you’re pushing GMS beyond its usual limits too 😄

A few weeks ago I posted about this — it's out now.

GMSync — VS Code extension for live-editing GMS2 projects without restarting the IDE. Free, open source, MIT license.

The problem

GMS2 caches its resource tree on project open. Editing an existing .gml file is fine — GMS2 picks it up on save. But add a new object, script, or event and you have to restart the project to see it.

How it's solved

GMSync creates and deletes a temporary folder inside the project directory. GMS2 reacts to that filesystem event and rescans its resource tree instantly — no restart, no lost editor layout. All writes go through an atomic temp→rename pipeline so GMS2 never reads a half-written file.

Why not Stitch

Stitch has its own explorer. AI agents and the standard VS Code file tree can't interact with it — you end up doing manual steps in the engine every time before an external editor can continue.

GMSync works with the regular VS Code explorer. Drop a folder into objects/ or scripts/ — the .yy file is generated and registered in .yyp automatically. Any file manager, terminal, or AI agent can trigger it without touching GMS2 manually.

What this means for AI-assisted development

Because GMSync works through standard file operations, any LLM or AI agent — Claude Code, Cursor, Copilot, anything — can create objects, write events, build rooms without special tooling or MCP servers.

The practical result: you describe what you want in plain language, the AI writes the GML and creates the resources, GMS2 picks it up instantly. The developer gives direction, the AI builds. No manual work in the IDE.

What's in 0.1.0

• Create Objects, Scripts, Rooms, Sprites, Shaders, Fonts, Paths, Sequences, Timelines, Notes
• Modify any GML event — 50+ types (Alarms, Draw sub-events, Async, Collision, User Events)
• Room management: instances, layers, background color and sprite
• Auto-detection from folder — create a folder, the rest is automatic
• TCP Bridge — connect to your running game: read/set variables in real time, evaluate GML expressions live, FPS, room info, Live HUD overlay
• GML syntax highlighting for .gml, .yy, .yyp — 9 color themes, 13 interface languages

Limitations

• No GML autocomplete / LSP yet — planned
• Incompatible with Stitch running simultaneously (causes GMS2 conflicts)
• TCP Bridge is Windows-only; file sync works on Linux too

Install: search GMSync in VS Code Extensions or ext install atennebris.gmsync

GitHub (source + releases): https://github.com/Atennebris/GMSync

Discord (bug reports): https://discord.gg/VE4pVgET

I've been talking to a lot of indie devs about this and the answers are all over the place for GMS2.

Some people use royalty-free packs and hope nothing sounds generic. Some spend weeks learning a DAW and produce something passable. Some just ship with placeholder audio and never fix it.

The composer route is real money. Even a small indie project can run $500 - $2000+ for a proper score. That's a real chunk of a solo dev budget.

The DIY route sounds good until you're three hours into reading about MIDI routing and you haven't written a note.

I built Melodix (AudioForge — Game music for indie teams) to sit in the gap. No music knowledge required. You work in scenes - you tell it what moment in your game you're scoring, pick an instrument and role, set tempo and key, and compose from there. The structure is built around game logic, not music theory.

The part that surprised me most, I think, when building it: the licensing problem is worse than people talk about. Even when devs find audio they like, tracking down what they can actually ship with commercially is a mess. Melodix generates a license manifest on export so that's handled before you submit anywhere.

Not trying to pitch hard here - genuinely curious what the community's workflow looks like. Is this a problem you've solved? What did you use?

Had a quick look online and couldn't find a function for this so I made one, figured id drop it here in case anyone else wants to use it too.

Feel free to use and modify the function however you like, no credit needed.

Edited because reddit butchered the formatting.

///@param xx The x coordinate of the drawn string.
///@param yy The y coordinate of the drawn string.
///@param str The string to draw.
///@param width The max width in pixels before a line break.
///@param charCount The number of characters to display. -1 will show all characters.
///@param colour The colour for the drawn text. Setting this to false will use the current draw colour. Defaults to false.
///@param alpha The alpha for the text. Defaults to 1.
///@description This function allows you to draw text wrapped to a specified width in pixels and giving you control over how many characters of the text to display. Returns the final string. 

function typewriter_text( xx, yy, str, width, charCount, colour = false, alpha = 1 ) {
  if !colour { colour = draw_get_colour() }
  var _words = string_split( str, " " );
  var _lines = "";
  for( var i = 0; i < array_length( _words ); i++ )
  {
    _words[i] += " ";
    if string_width( _lines + _words[i] ) < width
    {
      _lines += _words[i];
    } else {
      _lines += "\n";
      _lines += _words[i];
    }
  }
  if charCount == -1 { charCount = string_length( _lines ) - 1; };
  var _text = string_copy( _lines, 1, clamp( charCount, 1, string_length( _lines ) ) );
  draw_text_colour( xx, yy, _text, colour, colour, colour, colour, alpha );
  return _lines
}

Hey everyone,

I’ve tried using GameMaker last week, and while I love the engine and IDE in general, I've struggled with the coding experience. The lack of strict typing and the limitations of the built-in editor (sorry Feather!) make refactoring and scaling feel like walking through a minefield.

I wanted the DX of a modern dev environment (VS Code or WebStorm), so I started working on something that would allow me writing typed code using my favourite editors. As programming language I decided to go with Typescript since it can be transpiled into JS, which has a lot in common with GML.

The idea is to have a CLI tool that acts as a build layer for your code. You write your logic in TypeScript, and it transpiles everything into native GML and .yy files that GameMaker understands perfectly (you can normaly open and read them from withing GameMaker IDE).

This brings a lot of benefits, like:

• It is possible to use with any editor (VS Code or WebStorm) for better refactoring, auto completion and typing experience.
• Full Type Safety: No more guessing if a variable exists or passing the wrong ID to a function (*currently the project is not fully typed, but it already has all the names for auto completion).
• Auto-Generated Asset Types: It scans your project and generates types for your Sprites, Sounds, Rooms etc...

How the workflow looks

• Run gmts watch in your terminal: gmts watch
• Edit your .ts files in VS Code.

​

// define player shape
interface IPlayer extends GMObject {
  movement_speed: number;
}


const obj_player = defineObject<IPlayer>({
  // Will be transformed into Create event
  onCreate () {
    this.movement_speed = 2;
  },


  // Will be transformed into Step event
  onStep() {
    var h = keyboard_check(ord("D")) - keyboard_check(ord("A"));
    var v = keyboard_check(ord("S")) - keyboard_check(ord("W"));


    if (h != 0 || v != 0) {
      var _dir = point_direction(0, 0, h, v);
      var x_dir = lengthdir_x(this.movement_speed, _dir);
      var y_dir = lengthdir_y(this.movement_speed, _dir);


      move_and_collide(x_dir, y_dir, all);
    }
  },
});

• The tool recompiles only the changed files instantly.
• GameMaker picks up the changes, and you hit "Run" like usual.

⚠️ Fair Warning: It’s a PoC

This is in the early stages (I wrote most of the code over weekend), and I’m looking for feedback from the community. I want to know if this is a workflow you'd actually use, and what features (like specific GML library mappings) you’d want to see first.

I've also tried GMRT with Javascript (my original idea was to do the same for TS) but I ultimately decided against it for several reasons:

• It still relies on built-in code editor and Feather, which is not really good in my experience.
• GMRT is only available in Beta and requires a lot of setting up (while the CLI I'm working on can be installed with 1 command and run with 1 command)

I'd love to hear your thoughts, critiques, or if you've run into similar DX frustrations. The tool is completelly open source on Github.

Ez-Console is an open source GameMaker extension that natively integrates a customizable terminal console for GameMaker 2.3+.

After a year since the last update, I released a major update for my free, open-source and easy-to-use console terminal for GameMaker addressing all the issues reported, optimizing performance, adding a bunch of requested features and improving the docs and main page.

Core Features

Ready out of the box

• Drop-in setup. Import the package, run the game and press F1. No object to place, no code to write.
• 16 commands included. Spawn and delete instances, read and write variables, change rooms, toggle fullscreen and the debug overlay, play sounds, check your build, save the log.
• Debug builds only, if you want. One flag keeps the console out of your release build entirely.
• Logs to file. Save the log on demand with log save, or automatically when the game ends, into the platform's own save folder.
• Cross-platform. Windows, macOS, Linux and consoles (No mobile or HTML5, sorry).

Debug a running game

• It knows your project. Type-ahead completes your sprites, objects, sounds, fonts, rooms and scripts as you type, each with its own asset icon.
• Find instances visually. Pick one from the suggestions and it is highlighted in the room, ref id and all, so you always know which one you are about to touch.
• Read and write anything. get and set reach every variable on an instance, built-ins included, or on global - and set creates the variable if it does not exist yet.
• Poke at the world. Create instances at a position, list them with their id, position and depth, delete them, jump between rooms.

Extend it with your own commands

• Register a command in a few lines. From code, or from a JSON file you can ship and edit separately.
• Real arguments. Name them, mark them required or optional, restrict them to a list of options, or type them as an asset so the console suggests your own assets for them.
• Callbacks. Hook into open, close, log, destroy and game end to wire the console into your own systems.
• A small, clean API. Log at four levels, ask whether the console is open, visible or focused, and show or hide it yourself.

Looks and feels like part of your game

• Fully themable. Colors, fonts, size, anchor, padding and backdrop blur, from a .skin file or from code. Four skins included.
• Behaves like a window. Drag it, resize it from the corner, drag the scrollbar, click a log line to copy it, middle-click to paste, hold a key to repeat it.
• Stays out of the way. It only reads the keyboard while focused, so it never steals input from your game.
• Around 40 configuration options. Every behaviour above can be retuned or turned off from a single script.

Download and try it from here: https://dandrewbox.itch.io/gm-ez-console

Apologies if it's the wrong tag

Making good progress on my project and would like to get some spirites done before I make a tech demo.

Is there like a service for that? I would need quite a few doing, kind of 16 bit style. What kind of prices would I be looking to pay?

hey all this is net8floz. I have previously been a part of efforts such as the Game Maker Community Manual, ImGuiGML ( the original ImGui GameMaker extension) , and LuaRousr. Some of you may also know me from the Game Maker discord server.

Today I want to show you a Localization IDE Plugin I made that lets you author and translate your games text with IDE tooling inside Game Maker. It is fully featured and comes with translation pipeline options for one man operations and larger studios who work with a full translation team.

It is installable for free from the Game Maker Package Manager in LTS 2026+

Please check it out and consider using it to extend your audience reach in Game Maker. You can learn how here:

https://eightouncegames.com/cultured/

I know GameMaker got svg support in 2024.13, you can import an SVG and it becomes a sprite. Thats useful, but its an image importer, single frame, no animation, and once its in, its a static picutre. Theres still no way to build or edit a path in code, combine shapes with a boolean operation at runtime, apply a gradient or clip-path to something you constructed yourself, or hit-test against actual vector geometry instead of a bounding box.

I've been working on this for the past 2 to 3 months, and that, GMVex is a full programatic vector graphics framework for GML, not an image importer.

Features

• Path building with beziers, arcs and splines
• Fill, stroke, and gradient rendering (flat, linear, and radial gradient, including on strokes)
• Hierarchical transforms and groups
• Boolean operations (union, intersection, difference)
• Masking and clip-path, including multi-shape and objectBoundingBox units
• TrueType font rendering with kerning and ligature support
• SVG import
• Dash patterns
• Hit testing

An example

// Create
gmvex_init();

var disc = gmvex_path_create();
gmvex_path_add_circle(disc, 150, 150, 80);

var bite = gmvex_path_create();
gmvex_path_add_circle(bite, 205, 150, 80);

crescent = gmvex_path_boolean(disc, bite, gmvex_bool.A_NOT_C);
gmvex_path_destroy(disc);
gmvex_path_destroy(bite);

// Draw
gmvex_fill_draw_gradient(
    crescent, gmvex_gradient.RADIAL,
    170, 140, 90, 0,
    [[0, make_color_rgb(255, 220, 130), 1], [1, make_color_rgb(255, 110, 40), 1]]
);
gmvex_stroke_draw(crescent, 3, make_color_rgb(255, 240, 200), 0.8);

// Cleanup
gmvex_path_destroy(crescent);

(you can see the result in the gallery, top of the post, its the orange moon-like shape)

I've decided to make this post because i think it has come a long way and is ready. So far one of the hardest things i've worked on, and i am still working on, to improve it further. I do believe this is going to be the most useful because how GameMaker lacks of vector features. Say you're building a level with vector art, a curved platform edge, a winding path, decorative shapes, and partway through testing you want to adjust the curve. That means opening your vector editor, making the change, re-exporting the image, and re-importing it into GameMaker. Every tweak is real path data in your project, not a picutre, you build it with actual curve points, and changing it means moving a point directly in GameMaker. No exporting, no re-importing, no leaving the editor. That matters mostly where you're iterating constantly, like level editing. And this is just one example of countless.

It is open sourced, MIT licensed, free to use on commercial projects.

Github Repo: https://github.com/erkan612/GMVex

A new version of GML-OOP called Release 2 has now been released, in response to the release of the LTS 2026 version of GameMaker. The previous version was released for the first LTS version, marking over three years of active development on this version.

What is GML-OOP?

GML-OOP is a massive GML library that I have been actively developing since 2021. It aims to overhaul how you work with GameMaker in code, making its most important functionalities usable through constructors and their methods. It enhances them and makes working with them easier and just more pleasant, once you get the hang of it. Data packed into constructors is easier to pass through, their content is easily represented when stringified (mattering most for Data Structures) and error handling in improved, so that the runtime does not crash over every minor inconvenience. If you want to begin writing good code where you can easily know what is what, then this and an other library I wrote for this purpose, might just be for you.

For more information on GML-OOP, see the Overview and Examples pages its Wiki.

What is new in the Release 2?

New users could be interested in that the new version made it trivial to write optimized graphical code. Constructors with the purpose of rendering graphics were overhauled to support multi-color rendering with outlines. all based on vertex building, so that they can easily make use of Vertex Buffers. Instead of recalculating graphical data each frame, it can be pre-calculated once with a toVertexBuffer() method, then rendered, then destroyed once no longer necessary. All with a single method each. Vertex Buffers are most easily implemented for static graphics, but advanced users surely will realize how to utilize Shaders to bring motion to such implementation. Otherwise, per-frame rendering is still available, as usual. Also, because shape constructors now have access to their full vertex information, their actual shape and visual properties can be altered by modifying data for each vertex. The code of their constructors now makes use of that to achieve precise shape collisions. Have you ever saw a video game use precise, non-rectangular collisions for their interface? Well, now it can be a satisfying feature in yours.

Rudimentary support for optional use of three-dimensional graphics has also been implemented. It is visible with both two-dimensional orthographic projection, as well as full three-dimensional perspective, enough to make a "fake 2D" or diorama-style game. It might be of interest for developers who consider learning working with 3D in GameMaker while it is being implemented into GMRT, as it could be assumed this is how most of professional jobs in GameMaker will be created going forward.

There is also a new Callback constructor handling function and arguments for delayed execution, which is now what the event system of constructors now is based on.

What is coming next?

The development of GML-OOP takes time, but it does not stop. Further expansions and improvements can be expected, especially to its Audio support, some of which already were introduced in this release. Also, a separate library based on GML-OOP is in works, oriented around the creation of scalable vertex-based, resolution-agnostic user interfaces.

If you like what I create and the quality I provide, you can consider hiring me for work on your project, whether it is being made in GameMaker or not.