u/composingkeys

One easy mistake is treating music looping like a game-timing problem: watch audio_sound_get_track_position() in Step and seek back when it reaches the boundary. GameMaker's own manual warns that this cannot be accurate. The audio thread advances at 44,100 or 48,000 samples per second while the game normally updates around 60 times per second, so many samples can pass between the check and the seek.

GameMaker now has proper audio-thread loop controls:

audio_sound_loop_start(snd_music, 10.0);
audio_sound_loop_end(snd_music, 42.0);
var music_voice = audio_play_sound(snd_music, 100, true);

The start and end values are seconds. You can set them on the sound asset before playing, or on the returned sound instance while it is playing. When the playhead reaches the loop end, GameMaker performs the jump on the audio thread instead of waiting for Step.

This also gives you a clean intro / loop / outro layout in one file. Put the intro before the loop start, the repeating body between the two points, and the outro after the loop end. Start it with looping enabled. When the game is ready to leave the music state, call:

audio_sound_loop(music_voice, false);

The current pass finishes, crosses the loop end without jumping, and continues into the outro. No polling and no frame-timed seek. GameMaker supports one loop section per sound, but you can change the section by setting new start and end values.

There is still a second problem that loop points do not solve: the reverb tail. If the last chord is still ringing after the loop end, a one-voice jump discards that old pass while the fresh start begins. The timing can be sample-accurate and the seam can still sound like a hole.

The three practical options are:

1. Compose or render a genuinely dry boundary.
2. Render past the end, mix that tail underneath the beginning, then export only the repeating body. This makes a self-contained one-voice loop, although its first pass contains a tail from a pass that never happened.
3. Use two voices so the previous pass can ring out while the next pass starts. This is the most natural result, but it requires runtime scheduling and voice management.

This came out of implementing GameMaker delivery notes in Loopsmith, a looping tool I built. It reports the exact loop positions and can prepare folded-tail or two-voice deliveries. Mentioning that for disclosure; none of the technique above requires my tool. The relevant GameMaker manual section is Audio > Audio Loop Points.

Hopefully this saves someone from debugging a frame-timed loop that can never be sample-accurate. Happy to answer questions or test edge cases.

Problem 1 is whether the engine even reads your loop points. WAV keeps them in the smpl chunk, OGG uses LOOPSTART/LOOPLENGTH vorbis comments, and support is all over the place. Godot reads smpl natively. Unity actually reads it too, which surprised me (undocumented, and the default vorbis import wrecks it, which is why everyone says it doesn't work). Unreal ignores smpl but reads cue markers sample-accurately. RPG Maker reads the OGG tags. FMOD and Wwise don't care about the file, you loop inside the project.

Problem 2 is the one that gets you after the markers are perfect: the tail. The last bar is still ringing when the playhead jumps back. That decay gets chopped, and the dry attack of the loop start lands right where the ring-out should have been. Sounds like a gap even though the samples are contiguous. Loop points can't fix it because it's not a loop point problem, it's just what happens when one playhead wraps.

Two ways I know to deal with it. Run two voices, where the old pass rings past the loop end while the new pass starts. Wwise does this out of the box with post-exit audio on a music segment. FMOD can do it with a transition timeline and the tail as an async instrument, which FMOD's own QA has called not very discoverable. In plain Unity/Godot/web you schedule it yourself against the DSP clock. Or you bake the tail into the head of the file, so a plain one-voice loop carries its own ring-out. That works anywhere including RPG Maker and GameMaker, with the tradeoff that the very first pass plays a tail from a pass that never happened. Dense mixes hide it, sparse intros don't.

Happy to answer questions about any of these setups.

Posting this in case it saves someone the time it cost me.

Unreal does not read embedded loop points. If you have written smpl chunk loop markers into a WAV, which is what Godot and most samplers read, UE ignores them completely. The Looping flag on a Sound Wave just wraps the whole file.

What it does read is cue markers, sample accurately. That turns out to be the way in.

The setup that works for music with a reverb tail:

Two Wave Players on the same asset, not one. Voice A plays the pass, and at the loop point voice B starts the next one while A keeps playing so its tail rings out underneath. That overlap is what stops the seam sounding like a cut. A single looping player will always chop the tail off.

Drive the handoff from the audio's own sample clock, a looping Wave Player's On Looped, rather than a timer, so it cannot drift over a long session.

For stingers, quantize against cue markers baked into the file. The grid comes from the audio itself, so it can never drift away from the music.

Intro: give it its own player and fire the loop clock from its On Finished.

Musical ending: a Trigger Control gate that closes on an End trigger, so the current pass finishes and resolves at the loop point instead of cutting off wherever the player happens to be.

Cheaper than I expected to run: about 0.63% of a CPU core steady state in 5.8 with four stems plus intro, ending and a stinger, roughly eighteen wave players. The loop wraps themselves measured as free. The one cost is the first play, which peaked higher while the assets decompressed, so Prime On Load is worth setting if your music starts mid gameplay.

I build a tool that generates this whole setup (Loopsmith), but everything above is reproducible by hand and worth knowing either way. Happy to go into any part of it.

If you've ever put music in your own game, you've probably hit this: a track that sounds perfect start to finish clicks or gaps the second it loops, especially anything with reverb or a pad tail. Fixing it by hand means zoom-matching waveforms in a DAW and grafting the reverb tail back in, and then doing it again for every track.

https://reddit.com/link/1umqt7l/video/9r4ol80o33bh1/player

I write music for games, so I built Loopsmith to handle the tedious part. You set the loop point (by ear, or snap it to the bar from the tempo), hear the exact seam before you commit, and export a clean loop with the reverb tail intact. It also writes the drop-in code for Unity, Godot, and the web, so you paste one line instead of wiring up the looping yourself. It does the adaptive stuff too: layered stems, switching tracks on a cue, and stingers that land on the beat.

Free demo (Windows): austinhaynes.itch.io/loopsmith

Built with AI-assisted code; the music in the demo is my own.