Protect your radio station. Build towers only within the signal zone that follows your cursor.

👉 Play RADIO CORE: Last Signal

Hey Ya'll,

Crazy how time flies and it's almost 2 weeks ago that we were eagerly waiting to hear what the Theme would be. I had a feeling it might be Signal, and I'm thrilled with how our project turned out. @snowdrama put a bunch of great work into it and brought everything to life. Thank you to everyone that's played and rated our game so far - super chuffed we reached 30+ ratings recently.

If you haven't checked it out yet and have < 3 minutes to spare - check it out!

How are you guys feeling about this Ludum Dare? Is there something you will change next time round?

Link to our submission: https://ldjam.com/events/ludum-dare/59/signals-shift

Happy gaming this weekend! (And enjoy the extra day off on monday if you're also in the UK!)

:heart: :heart: :heart:

If you have a couple of minutes, we’d love for you to try Barely Edible and leave a rating (or some feedback) so we can enter the scoring phase :)

Play Barely Edible

Send your game our way too, our team is happy to rate back!

TLDR: added music, fixed the annoying coin sound (no more stacking spam), and added an endless mode. Got quite a bit of feedback, which surprisingly motivated me to improve the game a bit and just practice iteration. First thing is the endless mode. A lot of people said it fits the game perfectly, and yeah, I agree. Second big thing is leaderboards. No explanation needed, just try to beat me. A friend of mine made a really great track, it doesn’t get annoying, fits the pacing and gives that feeling of grinding through enemies. Also yeah, it just slaps. Coin sound is fixed too, before it stacked like crazy and was unbearable. Also a bunch of small stuff you probably won’t notice: pixel perfect camera, small tutorial rework (not sure it’s better), tweaks to core mechanics and balance, a couple of new upgrades and other small things.Also added a Windows build. Don’t worry, you can still play the old build on the LDJam page, and it’s also saved on itch if you want to download it.

Play new version

https://ldjam.com/events/ludum-dare/59/dragonia-siege

java - . .-. -- .. -. .- .-.. / - .-. .- -. ... -- .. - - . .-. / -.... ----- ----- ----- / .--. .-. --- .--. .- --. .- - . ... / .- -. -.. / -.-- --- ..- .-. / . .- .-. / .-. . -.-. . .. ...- . ...

:satellite: :signal_strength: :ear:

.--. .-. --- -.-. . . -..

We are over 20 ratings now! Thank you to everyone who has played our game and offered feedback so far.

As thanks, we are sharing a collection of handdrawn assets and planning sketches made during the jam. We've included most of the them.

The GUI changed quite a bit - the signs unfortunately overlapped in these early versions, making gameplay quite difficult!

If you need some ratings send me your games in the comments and Ill do my best to play and rate them :)

And If you'd like to check out mine I would be very grateful!

https://ldjam.com/events/ludum-dare/59/u-p-l-i-n-k

Thank you so much for all the incredible feedback - we've been reading every single comment!

We uploaded a post-jam version of the game on itch!
There is a lot of bugfixes, polishing, QoL - everything that we didn't have time to implement properly during the jam.

Important bugfixes:

• Issue with 2K and 4K displays
• UI scaling issues
• Sound issues when leaving browser tab

You can check new version here: https://sobigdrasil.itch.io/jims-quest-for-birthday-present
Original jam build is still available here: https://ldjam.com/events/ludum-dare/59/jims-quest-for-birthday-present

Hi guys! I'm happy that other people are enjoying my game. The comments and feedback motivate me to continue developing the game. I've noted in my TODO.txt some things I could add and things to fix. If you want to know how the game continues with more levels and mechanics, follow me on my Itch.io page to stay updated. Thanks and have a great day everyone!

https://memoloop.itch.io/propagation

https://ldjam.com/events/ludum-dare/59/propagation

Playrating period is not over yet. While waiting for that, I'm updating Sigul Signal and adding missing stuffs. Here are some shots from the update:

Thank you to everyone who has played our JAM entry so far and given feedback :heart:

We would love to have a couple more people give it a try and share their thoughts.

So maybe if you like puzzle games give it a shot: https://ldjam.com/events/ludum-dare/59/red-rat

If anyone has the time and desire, please rate our Jam game, we currently have 16 ratings and we would really like to go to the evaluation area. This is very important for us, a lot of effort has been put into the game. Thank you very much in advance!

https://ldjam.com/events/ludum-dare/59/tune-silence-87-5-mhz!

Thanks to everyone who voted and supported us! https://ldjam.com/events/ludum-dare/59/wavelatro

This was my first jam, and I had no idea how fun yet brutal it would be. 72 hours of development, only 9 hours of sleep in total... wow... But the most interesting part happened closer to the end.

With just a few hours left before the deadline, the game was critically missing sound. My old hobby suddenly became a lifesaver.

The thing is, I don’t compose music in the traditional sense. I program it in Sonic Pi (there are browser-based alternatives too). It’s an application/tool where you can write music using commands. It sounds like torture, but once you get into it, it’s actually quite simple plus there are plenty of tutorials on YouTube, a couple of lines of code, a bit of logic, and you already have a melody playing. I’ve been tinkering with it for a long time, creating 8-16 bit tracks from time to time, just for myself, for fun.

The funniest part is that I also made the sound effects in Sonic Pi. So literally the entire audio part of the project was created in this app, where I usually just relax and experiment with pixel beats. In the end, what I considered a useless hobby saved the entire audio component of the jam during the final hours before submission.

i think this game’s worth ur time, i rlly tried to polish it, so if u dont hate sokoban give it a shot

game https://caffeinetrip.itch.io/rescue

We have released a post jam version of our game on Itch.io. It fixes the controls, adds quality of life features, improves the gameplay loop, and more!

The Jam version is still playable on the ludum page and available for download.

You can try the game here!

(Screenshots form the post jam version)

Woke up the next day after deadline, checked the dashboard — no CTR. Zero. Wrote to support.

A week later — indexed. Feels good.

The end of the voting period is approaching. Here in Europe, people are enjoying the first summer weekend of the year. However, there is still an important task to complete: vote for the games that have not yet reached 20!

To give you some inspiration, here are three games with a rather unusual approach that I think deserve more attention.

• Fission Quest: A point&click adventure with live-action footage.

• I HAVE NO BRAKES AND I MUST VROOM: A game that you control using your voice.

• Exegenesis: A complete tabletop RPG.

Feel free to share some other interesting games that are missing votes in the comments!

Hello! Thanks to everyone who tried my game so far.
I wanted to showcase the various techniques I used in this jam to create this little train game with a day/night cycle.

Why

When I got the idea of using speed limit signals to fit the theme, I immediately went with those old trains as I like the sound they make as they go and their whole aesthetic. I thought it fit the vibe of the little world I'm slowly creating.
Thus, I needed a way to easily loop a texture over, and this is why I decided to go with a shader to give an illusion of depth and movement. By shifting the UV depending on the train's movement, I could easily create an illusion of perpetual movement.

How

The game is composed of several overlayed sprites.
The background is entirely rendered by a shader, including the stars, the sun and the mountains.
The train is composed of, overlayed in this order: a base sprite, Meina's left side, the train's right side sprite, and Meina's head and right side. This allowed me to only change the sprites of Meina's right side to animate her.
A combination of scaling and lerps between anchor points was used to make the speed signs and other things pass by on the side as you keep cruising.
Finally, the rails used a base texture that was carefully deformed to give this effect below.
The goal was to be able to place the train on the left to have space on the right for various objects passing by.
The coord variable here is the train's position in the world.

Sound

I got some comments praising the sound aspect of the game. I did originally plan to add subtle music, but didn't because of time constraints. I spent a lot of time tweaking the sounds of the train. I used a looping engine sound with modulating volume depending on the situation, as well as 5 very short rail "clunk" samples from one long sound, which play at a slower or faster rate depending on the speed. Both of those are from Pixabay, which is why I've opted out of the Sound category. I did not compose anything.

Future of the game

I've received a lot of ratings and feedback, and I'd like to thank again everyone who played my game! I've released the first bigger update which is mostly refactoring and polishing. For the initial version, I was manually passing the time and train position parameters to every sprites' shaders to achieve the tint effect on assets, but I discovered Godot's RenderingServer class which allows me to set global parameters, as well as the "Use parent's material" toggle.
RenderingServer.globalshaderparameter_set("time", time)
This should make future development easier, as I'm certainly planning to add more varied encounters, gameplay elements, an actually coherent small world to explore with still some random generation in object placement, weather effects, and calm, soft or atmospheric music. The goal is to make the game more interesting while keeping its cozy charm. The only reason the current game did not end up with a lot of content is because of time constraints. I added an actual goal at the last minute!
Thank you for reading this post until the end! If you found this interesting, please give my game a try! I'll do my best to release a new version with more content before the end of the rating session. If you have any questions too, feel free to ask.

Hey jammers!

For LD59 our team tried something a bit chaotic and wanted to share the result. Instead of working together normally, we did a no communication, pass‑the‑game challenge with 5 devs over the 72 hours. Each person got a small time slot, worked alone, and then passed the project to the next dev without any communication.

The Video

We recorded the whole process and turned it into a video:

https://www.youtube.com/watch?v=MPMFWFSvN9E

If you’re curious about:

• How the project changed every time it switched hands
• How we tried to rescue “half‑baked” ideas from earlier shifts
• What worked and what really didn’t with the no‑comms format

the video walks through each day and each person’s shift.

We decided to call it the Hot Potato Challenge!

We’d love to hear:

• Whether you’d try a no‑communication format with your own team
• Ideas on how to make this kind of “hot potato” jam format fair and fun
• Any feedback on the game itself

You can play Router Wilds here: https://ldjam.com/events/ludum-dare/59/router-wilds

Thanks for checking it out, and good luck with your own LD59 entries!

What Went Wrong

The design of Signals Intelligence is overly elaborate, and has too many moving parts. Every part needs to work, and the parts that don't work drag down the core game loop. If the player doesn't like or understand one of the systems, the game suffers, and if the player can skip one of the systems, you might as well not bother. The scope wasn't all that ambitious, but it was ambitious for a 48 hour jam game built without an engine for turn-based games or genre-specific base code.

Programming

At least it runs now.

Spaghetti Code, 1970s programming

I wrote the whole program with one big main-loop and no abstractions. It's all enums, flags, (named) tuples, state machines, and one big loop. There were barely any classes or functions in the code. When I do this in a game jam, it's usually for more than one reason:

• I do not know yet which kinds of abstractions or data structures I actually need
• I cannot waste time on bottom-up functionality I might not need
• I do not have the time to refactor during the compo
• Once I have something running, I know what kinds of data structures I need

I never had the breathing room during the first 48 hours to sit back and refactor everything into OOP style, or at least OOP style where it made sense, so my whole code was just tuples, enums, and tables for data, and that really slowed me town. Still, I kept going, because I didn't have time to refactor, until the code reached 2200 lines, and then I really didn't have time to refactor, because it was so much code!

Rolling my own pathfinding

This was more or less an unforced error. I thought I could get away with a simple kind of pathfinding for enemy moves, some sort of greedy heuristics-based system that just tries a couple of moves in the right direction and returns when the solution is good enough. I should have used A* right away.

Unfortunately, I had already simplified the unit movement code to move only in a straight line, to simplify both the mechanics and the enemy AI. Later I had relaxed that to one corner turn by move action. I really liked how this made moves actions into more "chunky" decisions. If you move over a mountain, then your action is limited by the mountain movement range. This means I don't need to run A* on the player's turn. The movement is pretty deterministic, there are only two paths (with one corner) to check.

For the enemy movement, this turned a problem that could have been simplified or sped up into a problem that could be solved with A* or Dijkstra, but not any further! If only I had made the system use floating-point costs under the hood, so that "You movement range is 5 on fields, 8 on roads, and 2 on mountains" would translate into floating-point costs of 0.2, 0,125, and 0.5. That would have been easy! I could cache a lot. But with my system, I couldn't just cache the cost of moving over the mountain, because it really matters where you start. If you start on a road, you can stay on the road! In terms of game design, this is great! In terms of performance and caching, it is horrible. It wouldn't have been a problem if I hadn't written this all in Python. Maybe somebody in the comments can tell me why and how I could do JPS (jump point search) anyway, but it wasn't obvious to me, and I boneheadedly tried to do something weird instead, and that didn't work at all.

I only fixed this in the post-jam bugfix version, with the drawback that the game now freezes during the enemy turn. I can't stress enough how bad of an idea it actually was to do greedy depth-first pathfinding, and how correct it felt at the time, because A* was slow, and I couldn't do JPS!

To illustrate the problem some more, here's an example of a tank that can move two spaces over mountains, and four over open terrain. Although the top path and the bottom path contain the same amount of mountain tiles, the bottom path takes one less action.

If you try to find the optimal path over multiple moves, this leads to quite complex pathfinding situations like this one.

Procedural Generation

This is also an unforced error, but not as bad. I thought I didn't have time to design a map, so I used Perlin Noise to generate the outline of the map, more Perlin Noise to place mountains, and some greedy iterative process (I never learn!) to route two roads through the map. And then I also needed to place the units! The maps are all samey, and there is no reason I couldn't just have drawn a static map and shipped it with the game. There was no upside to this, apart from saving myself the time to write something that loads the level from an ASCII art map, but that would still have been faster than the code that randomly places units. It's not like there isn't already a python module for loading TMX maps!

Broken State Machine

I really lost hours of time on my game because I didn't properly do the state machine the first time. Now using a state machine in the main loop was itself not the error. You can achieve the same goals with OOP, and make one subclass for every state, with judicious use of design patterns like "Template Method" and "Subclass Sandbox", but realistically, a state machine like I ended up with is a better fit. There is a lot of overlap between different states: In every game state, the map needs to be drawn, and in most states, the game needs to read inputs. If you wanted to mirror this with a class hierarchy, you would end up with multiple inheritance, mixins, or questionable is-a relationships. Instead of one big switch statement, there are all kinds of conditionals for different things that happens in different states. The problem here was that a) I didn't use enough states, and b) I switched states in the middle of my game loop, inside the game loop logic. ```py while gameloop: if state==State.ENEMYTURN: ... planmovements() ... state=State.PLAYERSTURN if state==State.UNITMOVING: ... if state==State.PLAYERSTURN: ... if clickedendturnbutton(): state=State.ENEMY_TURN

# THERE IS NO COMMON GAME UPDATE LOGIC HERE
# BECAUSE THE GAME DOES NOT UPDATE EVERY TIME
# IT IS TURN BASED

calculate fog_of_war()
draw_map_and_units()
draw_particle_systems()
if state==State.UNIT_MOVING:
    draw_unit_path()
    ...
if state==State.PLAYERS_TURN:
    draw_UI_buttons()
    ...
update_screen()

``` The correct way to do it is this:

```py while gameloop: state=checkswitchstate()

if state==State.ENEMY_TURN:
     next_move=planned_movements.pop(0)
     ...
     if empty(next_move):
         switch_state(State.PLAYERS_TURN)
if state==State.ENEMY_TURN_PLANNING:
     plan_movements()
     ...
if state==State.UNIT_MOVING:
     ...
if state==State.PLAYERS_TURN:
     ....
     if clicked_end_button():
         switch_state(State.ENEMY_TURN)

# NO COMMON GAME UPDATE LOGIC HERE AGAIN

calculate fog_of_war()
draw_map_and_units()
    if state==State.UNIT_MOVING:
    draw_unit_path()
    ...
if state==State.PLAYERS_TURN:
    draw_UI_buttons()
    ...
update_screen()

```

I had to add a system to transition states between frames, and I added more states to better mirror actual gameplay in the bugfix version. Now the "switching-during-game-logic" thing would never have been possible with the OOP approach. Every state has a draw() method, an update() method, and maybe additional methods for input handling and UI drawing, if you want to make it more fine-grained. But all I really needed to do was to switch in defined places, and not let the player press a button to switch from "enemy turn" to "player's turn". That led to a lot of crashes.

Project/Time Management

Originally, I wanted to participate in the compo. That's how far off I was.

Scope

The game idea sprung out of Zeus's head in full plate armour – some time around 2013. I have to admit, I wanted to do a game like this for a long time: A war-game where you are limited by the fog of war. The idea in my head was considerably more elaborate, and instead of grid-based and turn-based, it was active-time battle, or real-time with pause. I keep a notebook (paper!) with my old game ideas I want to get around to, and this idea was waiting for me.

The design I went with was much more Advance Wars and much less Company of Heroes. Still, it was too big of an idea: Supply lines, pathfinding, turn-based fighting, enemy units who autonomously counter-attack when attacked, spotting for artillery, fuel, ammunition, food, fog of war, all these feel non-negotiable.

Sprites First

I started with the game's artwork. Since I had a pretty good idea of what I wanted the final game to be, I started by drawing all the sprites for the game's map tiles and units. This was kind of a mistake, because it committed me onto a path where I would use all these tiles and sprites, or my work would be wasted.

This didn't just commit me to a fixed scope, it also committed me to a certain design. I hadn't started with grey boxes or programmer art. On the other hand, I also didn't really have time to make the pixel art bad first, and then good, and it didn't take that long to get it right the first time.

No design iteration

Since I was running out of time, and since I had already committed to all these units and mechanics, I had no time to iterate on the basic design. I could have started with the idea of decrypting intercepted messages, and made that an integral part of a different kind of game, maybe some sort of rogue-like where you need to interpret scrolls you find on the floor, or a first-person Myst-style puzzle game. The connection to the theme "Signals" was always set in stone though, so I kept the military theme.

There was also no time for play-testing iteration. I didn't show the working game to anybody before I submitted it. My normal philosophy is to have something that is playable (if not winnable) during the first day.

Non-Core Systems

Even worse for time management, I started with the systems that were core to the theme, not the systems that were part of the core loop, so I started with the map and units, message decrypting, coordinate scrambling, and fog of war. Then I wrote out all the unit stats, and then I actually implemented unit movement. In the middle of day two, I decided not to add a certain feature to the signal decoding (you won't know what is missing because I am not telling you). At the end of day two, I finally had player movement. I added a day, and in the evening of day three, I had the enemy player working, if only barely.

The deeper cause of the problem wasn't the design, but the fact that programming little systems and mechanics is fun, and there is little relationship between how much fun something is to code, and how much fun it is to play, or how vital it is to the game design. You can get lost in endless rabbit-holes with tangential game mechanics, or you get get carried away implementing engine features, just like you can get lost polishing your UI at the expense of game content.

Game Design

The design of Signals Intelligence was too rigid, too elaborate, and had too many moving parts. But more than that, I think I can determine a number of problems that aren't just described by "complexity". These are mistakes other people can learn from!

The Slow Death

The design of Signals Intelligence originally included some kind of "raw material" resources, but I quickly settled for a "money" resource, and then I didn't even do that, because fo time constraints. I thought it would be kind of funny if the GODLESS COMMIES didn't use money, and all their production was based on materials like "oil", "iron", "wood", "copper" and "potatoes", whereas the FREE WORLD uses the almighty dollar.

The version that exists now has some element of inevitability, because there is no way to build or buy new units. The main problem with this is that you can get to a state where you know you are going to lose, because you ran out of units, but the game doesn't know it, yet. I should really have added a "give up" or "try again" button, a menu, or a main menu to return to.

Anti-Pattern: Enemy AI, Level Design, Balance

Certain genres of games live and die not with their design or game mechanics, but with their content. In the case of both single-player strategy campaigns, and single-player stealth games, the content is the "enemy AI" and level design. AI is such an overhyped concept these days, but let me be clear: I don't mean LLMs, and I also don't mean alpha-beta search or GOAP. By AI, I basically mean "scripted behaviour". I think "AI" is a misnomer, but that's what it is called.

In both stealth games and single-player strategy campaigns, you don't want the computer to think through all the options. You want the computer to present a highly predictable challenge, almost a puzzle, so that the player can slowly overcome it. You don't want to play the campaign of StarCraft, Command & Conquer, or Age of Empires against a computer who is actively trying to in. You want to play against a computer who is beatable, again and again, in varied scenarios. In stealth games, you don't want to play against enemy lookouts who go out actively looking for you. You want them to say "It's probably just the wind" until it's too late.

This is really difficult! A good single-player strategy campaign is based on varied levels, with custom scripted behaviour, and that's a lot of work for a game jam. It's even more work to build a game AI that actively tries to win, because that's not only hard to program, it's also a complete nightmare to balance. It's easy to go from "Enemy AI that always glitches out" to "Enemy AI that always wins". Balancing an enemy that always tries to win is hard.

At this point, I usually start to hear the siren song of multiplayer, and I think "This could all be solved by making this a two-player game". Just imagine all the NPC AI/design/scripting/coding work Chris Hecker avoided by making Spy Party multiplayer!

It's not a good idea, of course. Sure, if instead of inventing a new chess AI for your new chess variant, you just let players play against each other, you only have to implement the game mechanics. Sure, if you get players to play against other humans, they will have fun figuring out the game together, even though they wouldn't have fun alone. But it's usually a bad idea during a game jam. Players won't have another jammer to play with at home, and they will be unlikely to rate Ludum Dare entries against their romantic partners, non-gamedev friends, or family. By making a multi-player game for Ludum Dare, I cut my player base down by a factor of 20 to 100, and I run the risk of getting comments that just say "looks interesting. I had nobody to play with so I played against myself".

The best case scenario is to implement online multi-player with matchmaking, so players have somebody else, but in the case of a game jam, that someone else will be rushing through 20 games to rate, and they won't all be online at the same time. That is, even if I could just snap my fingers and implement online multiplayer for Signals Intelligence, it wouldn't actually help the player experience.

If I make the game a two-player affair, I will have to make some concessions, and I would probably have to replace the "Signals Intelligence" gimmick, or at least tone it down. I can't expect the red player to actually have his units wait half a turn before attacking. Also, I would need to implement some sort of two minute turn timer.

Game Design Anti-Pattern: The Gimmick

If your game can be described as "$GENRE but with a twist", there is always a risk: What if your twist is bad? What if your game is better without the twist? What if your game would be better if you just made a generic $GENRE game?

The standard game design advice is probably to ignore the negative feedback and to double down on the twist. If your game is a puzzle platformer with a gimmicky gravity mechanic, you should consider toning down all the platforming, and to focus on the gravity puzzling. If your game is a rouguelike with chess elements, and the players don't like the chess elements, maybe you should re-frame it as a chess game with roguelike elements.

In the attention economy, the gimmick presents both a problem and a solution. Without the gimmick, YouTubers and games journalists wouldn't know what to say about your game, or how to describe it to audiences, and they might not even play or review your game, because "just another decent entry in the genre" doesn't cut it.

If you just look at it from a game design perspective, and not from a marketing perspective, the best advice is often "kill your darlings". If the chess elements make the roguelike that much worse, and you are trying desperately to shoehorn them in, maybe cut them. Maybe cut the whole gimmick and just make a good game!

Signals Intelligence could probably be a more fun game if it didn't have the signal gimmick, the decyphering, but then it would not have an identity. It would just be a turn-based tactics game that lacks complexity.

Anti-Pattern: Hidden Complex Systems

I have made this mistake before, and I have identified it. I even wrote a post about it. If your game has complex systems, you have to expose them to the player. If there is an enemy AI that makes interesting plans, it has to inform the player. If there is a trading system and all the enemy factions trade with each other, the player must know this. If your world is populated with little critters who eat and sleep and reproduce, then you better show little thought bubbles with food or hearts or ZzzzZZZzzz to explain why the critters are doing what they are doing. Otherwise, you might as well not bother. If the system is hidden from the player's view, the actions might as well be random. In Signals Intelligence, I have implemented fuel and ammunition as a game mechanic, so you can cut off enemy units from supply. You can starve enemy artillery, if you are good at decyphering, you can confidently attack enemy tanks and artillery with infantry, because they are out of fuel.

Most of the time though, the focus on Fog of War and signals means that the player won't interact with these systems directly, and all the resupplying and resource management is invisible to the player. It might as well not be there. As the developer though, you often struggle to see it. To you, this is all obvious and transparent. You know what moves the enemy is making under the fog of war, or just outside the edge of the screen, because you wrote it. You don't interact with it as "the enemy makes a random move at a random moment", because to you, it's all there.

Anti-Pattern: Vertical Slices/Minigames

I have already learned that making a game out of half a dozen minigames is a bad idea during a Ludum Dare. It's tempting, but usually you can't make something like WarioWare or Mario Party or GameSoup or even McPixel during a game jam. It's just too much work, and you waste time on the weakest link, or on games you cut from the collection. Adding more content to the signal part of Signals Intelligence would have meant adding more screens, more minigames.

It might be fun to imagine an interrogation mini-game or a mini-game where you develop microfilm, or a minigame about numbers stations, or one where you analyse enemy newspapers. But once you solve these, they would all be dead weight, in the same way the coordinate de-scrambling is dead is boring once you figure it out, and the way the whole signals intelligence stuff is redundant when you have enough vision of the map.

What Went Right

Symbol Drawing

Isn't this fun? You decode the enemy symbols by drawing, MSPAINT style. This has to be worth something! It neatly sidesteps the question whether the game will tell you if "Artillery" is the correct answer. It obviously won't.

Mechanical Theme

I had considered something about Morse Code, smoke signals, or a dating sim where you have to spend as much time as possible speed dating without ever getting the people you're dating enough information to make a decision. Mixed signals, get it? Yeah, I'm glad I went with SIGINT as my theme, too. I thought it was kind of obvious, but I have seen multiple games about routing traces/signal wires on circuit boards, and not that many about intercepting messages. I really like the theme, and I like that my interpretation is mechanical, deeply integrated into the game and not just something I mention in the intro, not a stretch, but still straightforward.

Cold War Setting

At least nobody told me yet that it's offensive, so there's that.

Mouse-Only Controls

At some point I considered to add some things that require keyboard presses, but I decided to just use the mouse, and that made it possible to play the web version on an iPad. I hadn't even thought about it at the time!

PyGame-CE

I couldn't have made this game with an actual engine. I'm sure I could have made it with raylib or libGDX, and I'm sure there are turn-based game construction kits for Unity and Godot, just like there are RPG kits, and point-and-click adventure kits. PyGame-CE has all the stuff I needed, and some features that I used that the old pygame didn't have. I literally couldn't have made this like this game five years ago, because old pygame didn't have some features I rely on.

Pygbag and WASM

In the past, I have used certain game engines and libraries just because I wanted to let people play my game in the browser. I like making games by writing Python code. All I need is GNU Emacs and aseprite and I'm good. That doesn't mean I don't like Godot or Flixel or Unity, but a full-fat engine is not what I would choose in a game jam. Pygbag/pygame-wasm let me run my PyGame-CE code through WASM, and it just works. So next time, I won't have to choose between my old comfy shoes and having a version playable in the browser. I still might, if I want to make a 3D game.

Lessons Learned

I learned very little. To be honest, I already knew most of the lessons, and yet I persisted, against my better judgement. I ignored my own rules. I had a ton of fun, though.

Finally starting to get caught up on rating all tested games.

One thing that stood out amongst all of them - really fun experimentation in visuals! There were a ton of really unique and visually interesting looking entries this year!

I have released a small difficulty and bug fix update for my LD59 jam, Calller IDie. I listened to the feedback about how hard the game was, so I made a few adjustments!

Features

• Added a new finale to replace the old one
• Both Agent and player are faster

Balancing

• Speed upgrades give higher speed
• Agent stalls for longer after respawn
• Player life count increased from 3 to 5

Bug fixes

• The menu now has mouse capture turned off after running out of lives
• Fixed the cutscene not playing under certain conditions

Thanks to all who played it :)

Hi guys, I just wanted to share a little poster that our artist made for this project.

It’s my second LD, but this has become something of a tradition. We're making small, funny posters for our games and keeping them at home as a piece of history.

Cover art updated for the Newgrounds version of the game (frontpaged btw!) LDJam version preserved for authenticity

Play on Newgrounds (easier, has achievements and leaderboards)

Play and rate here! (slightly harder!)

I am live playing your LD projects!! There is a chance I won't be tomorrow. This could be my final stream before the deadline.

If you need ratings or just want feedback, I am your guy.

https://www.twitch.tv/gingybeardyguy

Just pass by and take a round of my game "RoboNET".

Play it HERE

I need to rate some more games but I can only play games with a web build. It's a bit hard to find without proper filters, so drop them in the comments and I'll play & rate them! With a focus on the games below 20 ratings.

Make sure to play each other's games too :)

If you want to play ours: https://ldjam.com/events/ludum-dare/59/super-signal (web build, of course!)

We need a few more ratings (currently 17). You are welcome to try a chill puzzle game c: Click to redirect

Go check out our game, Fallen Ties and let us know what you think!

https://ldjam.com/events/ludum-dare/59/fallen-ties

By the way, if anyone has ever wanted to chase a giant spider on horseback, I can recommend my game:

https://ldjam.com/events/ludum-dare/59/the-last-signal

https://limekamibear.itch.io/the-last-signal

If not, check out my game at https://ldjam.com/events/ludum-dare/59/world-of-gates (it has a web build)

I also made a timelapse:

https://youtu.be/WnbyzCf6F8Q

Have fun!

I've really enjoyed the games I've rated so far! This community keeps making games that are so diverse, fun and imaginative. I was inspired to make some fan art of the games and pose them all together. And here they are, 20 great games worth checking out:

Featuring:

Bird Man signal

Cadence of Glob

Dr. Cool Whale Against The Electronicles

Dragonia Siege

Exegenesis

G-VAUDAN

I Contact

Lock

Mixed Messages

Mixed Signals

Moon Moth

Nervous Climb

Piggybacker

Prospects

ROV-R

Synesthezoo

Tiny Signal Lost

Twilight Beacon

While You Were Here

Winnerman Scams a Game Show

I've loved playing everyone's games this jam! Just finished a session to round off the weekend :)

If you're playing some jam games today and like logic puzzles come give our Morse-code flavoured entry, Dot Dash Mash, a try!

I have been asked many times about my art and how I do it. Not only I can show you, I can actually teach you. I've been teaching pixel art for many years, I teach both kids and adults.

Feel free to contact me any time!

* - Email: brocekdavid@gmail.com*

* - Discord: davidbrocek *

Huge thanks to everyone who has played and rated my Ludum Dare entry!

The response has been way beyond anything I expected. It’s already reached 55+ ratings, and the amount of interest, comments, and demand for more content has been incredible.

So I made more. Should I do a full Steam release?

Play Demo

I’ve expanded the game into a longer itch demo with improved visuals, new mechanics, more automation, and over an hour of content. It’s a color-mixing automation incremental game — basically Factorio meets incremental games — focused on building, optimizing, unlocking, and watching your production chains grow.

I’m now trying to decide whether it’s worth turning this into a full Steam release, and I’d love your feedback.

In the meantime, feel free to send me your games too. I’ll gladly play them and leave feedback.

Thanks again to all the jammers who played, rated, and shared their thoughts. Your support has been amazing!

We would be very grateful if you play our game and rate it.

https://ldjam.com/events/ludum-dare/59/silentium

This game jam is filled with so many amazing and interesting games, and I'm incredibly happy that we took part and left our small contribution among such a huge number of games.

✨✨✨🚀✨✨✨🚀✨✨✨

I hope that every game in this jam finds its player — someone whose signals align with it, so that together they form a wonderful symbiosis.

✨✨✨🚀✨✨✨🚀✨✨✨

Stargazer Sigma is just now trying to find similar signals in the starry sky and piece them together into one whole — and you have the power to help him! We'll be glad to welcome every starry helper❤️

Game Link

I just released TimerTree 🌳

A simple tool to create procedural 3D trees in minutes.

No complex setup — just grow, shape, and export ready-to-use trees for your games.

My Profile: ldjam.com/users/hora-timer/ ✔ Real-time generation ✔ Game-ready GLB export ✔ Lightweight & fast

Perfect for game devs, prototypes, and stylized or realistic projects.

Visit my profile for more information 👉 Check it out: ldjam.com/users/hora-timer/

In my game you need to find optimal formation to counter enemies attack. Imagine “rock paper scissor” mechanism but much more fluid. For the ones looking for bigger challenge I released the post jam version where enemies can also unblock their based similar to players. You can play it here:

https://ldjam.com/events/ludum-dare/59/formation-tactics-line-breaker

Do you seek ratings and feedback?

Join me live and I will provide! 💪

▼ Links ▼

Youtube Twitch Kick

There are only 2 levels, it should take about a minute of your time.

https://ldjam.com/events/ludum-dare/59/signal-towers

I'm working on a more finished version with everything that didn't get finished in time that will be released at the conclusion of the rating period.

Hi ya'll. Haven't done Ludum Dare in a bit. Just read the latest News post & the relating discourse. Seems like I might have to do another one soon before it's too late...

Anyway, for those who care, I thought I might mention what I have been working on recently.

Which is, almost entirely: my custom programming language PonieScript. It doesn't quite work yet. But it is getting there. I have written what could be considered real games with it. Ludum Dare was always one of my number one inspirations for my hacky game engines and other projects -- I feel like I must participate in a Ludum Dare with PonieScript before, well, it's too late.

I am of course optimistic Ludum Dare will continue in one way or another. But nonetheless... despite all the jank, I have enjoyed a lot of my time on this current iteration of the website.

Malleus Gnomus became even more malicious!

We really like our new hellish roguelike and keep updating it after the jam. We fixed most known bugs, made more helpful pop-ups and added cool vfx! Our plans for the next updates: better tutorial, balance and progression

For now, go play and rate original version if you still haven't. Thanks for your feedback!

so far enjoying ths LD a lot! got many amazing feedback and tons of awesome games to play! Please feel free to drop your entry in the comments, i'll play&rate them in the remaining days.

feel free to try mine too! https://ldjam.com/events/ludum-dare/59/checkers-under-the-radar

The post-process shader people seemed to enjoy in my game got enough love that I figured I'd clean it up with help from Claude Code and release it as a standalone URP package.

• 4×4 Bayer ordered dithering
• Color depth quantization (2–32 levels)
• Pixelization
• Warmth shift, desaturation, darkness
• Animated film grain
• Radial vignette

Built for retro / lo-fi / PSX-style looks. Cheap enough for mobile and WebGL. Works with both Unity 6 RenderGraph and the legacy Execute path (URP 14+ / Unity 2022.3+).

Install via Package Manager → Install package from git URL:

https://github.com/Zimennik/bayer-dither-urp.git

Full setup, parameter reference and source on https://github.com/Zimennik/bayer-dither-urp. MIT licensed.

The best way to say thanks: Play my game

We fixed a lot of bugs and now the game is 99% closer to the result planned back at the jam.

>> THE GAME <<

Many people need some more ratings in the last 4 days of the rating period.

Send me your games and I'll play them and give a rating!

Come play my game if you're interested and I'd be forever thankful:

https://ldjam.com/events/ludum-dare/59/u-p-l-i-n-k

For me, LD59 was an attempt to accelerate my gamedev workflow using AI coding techniques, where my goal was to have my game code 100% AI generated, without losing control over the game design. I am interested in other LD entries that have mostly or fully AI generated code. As of yet I found only one game, called Codevibes, which is described as "vibe coded". So if you have an AI coded entry, please respond to this post and I will play your game!

This experiment is only about AI coding, as the graphics are hand drawn, and the (newly added) sound is generated using ZzFX (an SFXR variant). I managed to create 9 small games with 100% AI generated code in less than a day. These aren't very exciting from a gamer's point of view, but they serve to test my coding technique on different game mechanics.

Years ago did a similar exercise, where I created 8 games in a weekend, to test my (then newly updated) game library. The result is similar (I finished the games but they have some rough edges), but done in less time. So in that sense it was a success.

The rest of the LD period I adapted my game library to be more suitable for AI generation, while enjoying my vacation in Seville, which looks something like this:

Me having a vacation while the AI does all the hard work

Last week I tinkered some more with the games, ironing out some of the rough edges, and adding sound and particles.

>>>Play the original game and the postcompo here!<<

Now, about the technique I used. I did not use vibe coding, but instead, I use the AI as a 'compiler' to compile technical specifications into code. I split the game into components and then let AI generate each component. I used the WebCogs VS Code extension to specify component prompts via what I call 'prompt buildfiles', and also created a new VS Code extension for quickly generating sounds. The prompt buildfiles include overall technical specifications of the relevant game library functions, and for each component, a description of the component. I also instructed the AI to add configuration parameters (such as entity speed, fire rate, etc), so that each component can be configured by changing input parameters. I modified these manually to tweak the gameplay.

AI generated component types I now have are:

• map generators: these output maps with ASCII characters, which are converted to tiles and entities by the game library. Example prompt:

Create a function that generates a scramble type level. Each tile is either: wall (@), empty (.), rocket (!), UFO (u), or player (S). The level consists of a horizontal cave/tunnel, with varying position and height, with a minimum height of 6 and maximum height of 12. Rockets are placed randomly on the floor along the tunnel, and UFOs in the middle. The leftmost 20 tiles of the tunnel are straight. The player is positioned at the middle left.

• entities: describes the behaviour of each game entity after being placed on the map. An entity can spawn other entities, manipulate the tile map, collide with entities, etc. Example prompt:

Create an enemy that shifts slowly and smoothly around in a fixed pattern. Occasionally it swoops down in curved patterns until it encounters a wall, then flies back to its original position. When it swoops down, it shoots bullets towards the player, but only if the player is below or diagonally below the enemy. The enemy dies when it hits a player bullet. Bullets pass through player bullets.

• particle generators (newly added after the compo): generates particle effects given at a particular position and effect size, like smoke and explosions. Example prompt:

Create a particle generator that generates a flying fish firework effect. There are two types of particles: cloud and fish. The cloud particles are shown on top, are large and white, move slowly, and fade quickly. The fish particles first move away from the center, then veer away at random moments in random directions with angles up to 180 degrees. Choose 2 different saturated colors for every effect. Fish particles have either of these 2 colors.

The maps, entities, particles, and sounds are tied together into a game using a single javascript file with just configuration tables. This defines the ordering of the levels, the mapping between map characters and tiles/entities, and the available animations, and particle and sound triggers.

For example, a level is defined like this: { "name": "Space shooter", def: "stdlevel", "type": "galaga", "tilemap": { nrtilesx: 32, nrtilesy: 18}, bg: "levelbg", "wincond": () => { return JGObject.countObjects(null,enemy_mask) === 0 } },

Entities and tiles are defined like this:

// cave shooter "Q": {entity: function(tx,ty) {createEntity("caveplayer",false,tx,ty,player_mask,"caveplayer")}}, "C": {entity: function(tx,ty) {createEntity("caveenemy",true,tx,ty,enemy_mask,"caveenemy")}}, "&": {tile:4, mask: getTileMaskDef("wall"), onRemove: {particle: {type: "flame",size: 20,sprite:30}, sound: "dig"}},

And animations like this:

"caveenemy": {anim: {start:14,end:14,speed:0.2,always:false,vertical:true, dir:"nodir"}, onRemove: { particle: {type: "fisheffect",size: 40,sprite:30}, sound: "caveenemyexplo" }, },

Altogether a successful result, I think. The generated code was pretty good, considering the straightforward prompts I used, but the AI had trouble generating code for some of the maps, in particular the platform and pac-man levels. This can often be resolved by giving more specific instructions, such as what algorithm to use, but I did only limited prompt tinkering. Another was that in my current setup, I had a lot of maps, entities, sprites, particles, etc., to create all the 9 games, which became difficult to keep track of in the configuration tables. For example, I have about 30 different tiles and entities, which means I started running out of ASCII characters at some point. I tried to do everything from within VS code, with help of some extensions, but I may want to create a dedicated game development GUI at some point.

Henlo jammers!

I made this jam entry in ~1 day using just Unity primitives. I got no time to try your games, so please, rate my games at least to reach 20 ratings.

https://ldjam.com/events/ludum-dare/59/wave-matcher

Hi! I did music and sound for Jim’s Quest, and today I want to talk a bit about my work. By the way, here's the game: https://ldjam.com/events/ludum-dare/59/jims-quest-for-birthday-present

Here's the music: https://youtu.be/Efd4m68hrCU

When the theme was announced, our artist Natasha put together a mood board of references for the aesthetics, we discussed it and decided that vibe-wise, we would roughly aim for Zelda. As it happened, I had to step away for the whole day for family matters, and when I got to work in the evening, Natasha had already drawn the main art: Jim himself, the shop on the beach, and some items. This helped me a lot; I understood exactly what kind of vibe needed to be created.

We quickly realized that Zelda wasn't the right reference for us. It was important to create an atmosphere of carefreeness, joy, and a touch of nostalgia (without slipping into actual sadness) — we needed that feeling of warmth and home. Even though Zelda's music is generally quite wholesome, it carries a lot of ethereality, magic, and a certain mystery and tension. So, Animal Crossing felt closer in mood, although not a perfect match either.

Here is the list of tags I put down for myself before getting started: - Calm, soothing, sunny. Cute, but not overly so. Somewhat bristly. A bit bittersweet. - Beautiful string swells - Small percussion - Uke solo that goes harder than it needs to - Vaguely surfy strat

I'm really happy how the music turned out! Here's what works to create the atmosphere:

Harmony is mainly built on major 7th and 9th chords, which creates a light, dreamy atmosphere. Occasionally, a minor third degree appears, evoking melancholy, but we don't stay on it for long and return to major. There are also unprepared modulations in the music. But since the chords themselves sound quite soft, this isn't perceived as a jarring transition, but rather as an addition of freshness and a slightly jazzy vibe, like in the TV shows from our childhood.

Contrast. Instruments capable of loud, expressive sounds play very calmly and softly, while a tiny ukulele plays at the limit of its dynamics; even goes out of tune a bit during particularly hard moments. This contrast creates a slightly comical effect and keeps things from getting too serious or overly sweet.

Texture. The rolling swells of string chords evoke the feeling of ocean surf.

Rhythm. Small percussion, the bass rhythm, and guitar chords bring a somewhat Latin feel, which works well for setting a sunny beach atmosphere. Also, an electric guitar played with a slide adds a bit of a "Hawaiian" color.

I wrote three different tracks, and to avoid overcomplicating the implementation, I made kind of a mixtape of two of them: spliced together, added transitions, recorded a couple of bars of solo, rendered as one file and put it into the game in that form.

We originally wanted to leave one separate theme for the shop, but decided against it: the player doesn't spend enough time there to justify switching the music.

At work, I mostly do epic orchestral textures using VSTs, so for this jam, I wanted to write music using live instruments. I played and recorded a ton of stuff: violins, viola, cello, nylon and electric guitars, ukulele, and percussion. The only virtual instruments here are the piano and double bass.

I don't consider myself a professional instrumentalist, but even without proper technique, you can create sounds that set the vibe. The key is not getting fixated on a flawless start-to-finish performance, but rather proceed in small chunks. If a phrase seems too hard, deconstruct it: play it super slowly, understand its physics (bow movement, fingerings), and record the elements separately, up to single notes. When done right, it pieces together organically.

It's taking a lot of recording passes, so streamlining the workflow is crucial. I set things up so I can control the recording with one hand, without leaving the mic. My biggest roadblock is usually my own ego: thinking I can nail the whole phrase at once and wasting attempts instead of just breaking it down. Also, for monophonic instruments: focus on timbre, not pitch. You can fix the pitch in Melodyne, but a shaky, unconfident tone can't be saved in post.

Sound design didn't take much time. The metal detector pings were the main challenge, I needed a sound that played constantly without being annoying or getting lost in the mix. I've made the ping sounds in Phase Plant. Defold has fairly basic audio tools, so I couldn't build complex, randomized systems. That said, our programmer Stanislav implemented audio randomization in code, which allowed for necessary sound variation. This made the radar feel more organic and less repetitive. The same applies to the character's footstep sounds.

I'm so glad I got to work with Natasha @sobigdrasil and Stanislav @laminariy — we didn't know each other before, but we’ll definitely work more! I hope you liked the game and could relax for a bit in the world we created.

If you'd like to work with me, hit me up: timmedvedevaudio@gmail.com. I've written a lot of music in various styles for games, and also worked a lot as a sound designer.

I'm not really worried about it, but I am rather confused...

Not giving a rating in Humor I can understand. But what I don't get is why someone would play the game, give ratings in Innovation, Theme, Audio, and Mood... and not give ratings in Overall, Fun, or Graphics? (Especially Mood, since that's so ill-defined as a category... I would expect that to be the most likely for someone to skip.)

How strange.

I didn't have enough time to evaluate the games of others after completing the submission, I hope for these 4 days. But I'm afraid everyone has already stopped evaluating the games.

https://ldjam.com/events/ludum-dare/59/stay-tuned

I made this post about narrative-driven games on LD 59 and you all sent me a ton of great games, thank you!

I had the pleasure of playing every single one and I’m back to report the results.

Nest, this is Pilgrim — a cute, engaging story about long-distance lovers with a really fun signal deciphering mechanics.

Pyre Lookout — a Disco Elysium (and I suspect Firewatch) inspired adventure that was both hilarious and charmingly bitter-sweet. (Also Scott is funny as hell and really moe in a pathetic way—love that for him)

SAVE OUR SOULS — fun, intriguing and with a nice twist! Has a ton of potential to make you laugh, surprise and even scare you.

Shroomice — super cute text adventure, which you can tell was made with love! The voice acting is also a nice touch hehe

Trace In The Either — a stylish and funny adventure. Can’t believe you guys made this in just 3 days — it’s incredible!!!

n 0 m i n a l — fantastic writing and a gripping story wrapped in fun puzzles, which beat my ass quite badly but made the texts into an anticipated reward.

I also wanted to note a few more narrative games I enjoyed a lot this LD!

The Dark Spots in Space — One of those games you can’t stop playing until you 100% it! A must play for all Sam Barlow enjoyers.

On Ivy Boulevard — A stylish mystery game with a very tight and engaging loop and amazing narrative. Had a lot of fun figuring this one out!

The Lighthouse — A cool Lovecraft inspired pixel art quest which reminded me of The Last Door.

Go check out these games guys!

I humbly offer you to check out our game as well! Go infiltrate a secret society in Vice Signalling and uncover a conspiracy against the Emperor… if you dare.

And once again: if you’ve made or loved playing other narrative games this LD, please share them in the comments! I’d love to play more if I’ve missed any entries <3

Have a great jam everyone!

First time making postmortem. Our LD59 game Lighthouse Diaries was special game in many aspects, so I thought it would warrant a post mortem.

There would be lot to say if I told everything we did. However, there was many same things that we've done in previous ludums and the most learning occurs when doing something new and going out of comfort zone, so I tell what we did differently this time.

Light effect

We planned a normal light effect first, but then the graphics team got a wild idea that it could be an old map that turns into a more natural looking surface when the beacon light touches it. We achieved this by making all map graphics two times and using mask layer.

zoom levels

This time we wanted to try using variable zoom levels and actually achieved it. You could zoom in and out with mousewheel and it was awesome!

The zooming or more like the scaling thing posed some problems too... which were our own making. There was some miscalculation of the asset sizes in the planning and our graphics team made super high resolution graphics compared to the actual zoom level they would be viewed.

There would be pixel by pixel accurately drawn ships in something in the lines of 256x256 and they looked amazing, but also took whole lot of artists time

All active objects were drawn in super big size and levels became about 10k x10k pixels, so drawing the maps was an opposite of a breeze

...Yeah, we're probably never doing that again!

Water Shader

For the first time in Ludum, we used a shader and with some effort from one of our coders we got very beautiful "animated" sea.

Dynamic music

You heard it right. DYNAMIC. MUSIC.

Our Music team has always overdone itself and made such wonderful consistent and catchy songs for our games (and even a rap for the credits screen for every game!) ...But this time they planned something totally new!

In the first plan, not only would the music change depending on the events, but it would also constitute of several tracks that would be played simultaneously. How awesome would that be!

So two different themed layers of music was made, one bunch for lighter mood and another for a more scary/anxious mood:

...In the end we didn't have time to implement the situational music properly, but we still used all the tracks!

Now in the current gamejam implementation there are two lighter maps and an anxious map... And you will have a randomized easy going music that is slightly different for each time you play it and similarly randomized anxious music in the last level.

Each 20 seconds of music consists of 2-4 randomly chosen clips layered on top of each other... So with quick calculation there's 7x7x7x7 + 7x7x7 + 7x7 = 2793 different ways any 20 seconds of the song might play.

Same calculation for anxious music where 1-2 of 4 clips might play simultaneously: 4x4 + 4 = 20 different anxious music compositions.

That was about all the new stuff

...So enjoy the game with super accurate zoom in and your unique soundtrack every play!

And if you haven't yet tried it, try Lighthouse Diaries

Throwing a lightning bolt is all in the wrist...

After a lot of work, I finally managed to bring you a new version of my game, and I believe it's now 100% functional, with a beginning, middle, and end. I hope the mechanics are easy to understand and that you have a pleasant playing experience. Come on in, pull up a chair, and download the game :)

https://ldjam.com/events/ludum-dare/59/signal-wave-path

With the jam winding down, it's time for my customary look back at how things went: what went well with RAVTZN, what didn't, and my plans for the next jam. As always, though, I'd like to start by saying a big "thank you" to everyone who's played and rated the game so far, and if you haven't, there's still time! I've only got a couple more games left to review in return, so if you'd like to add to my backlog, please leave a comment!

What Went Well

• I'm still proud of the various technical bits and pieces I was able to program into the game, including the decryption algorithms themselves, the mock waveform visualizer, and the autosave with hints upon resuming. The game looks and feels more complicated than it actually is under the hood.
• I've always been something of a design minimalist, and with RAVTZN, I feel like that worked in my favour. The game has no music, very few sprites or sound effects, and takes place more or less entirely on a single screen. That gives it a distinctive presentation style but also meant I didn't have to spend ages creative assets and had more time to spend on the puzzles and whatnot.
• Another jam, another bug-free release! That might not sound like much of an achievement, but most of my past Ludum Dare games have been riddled with bugs, so it's always a personal point of pride when I manage to release a game that just works.

What Went Badly

• My ADHD continues to play havoc with my ability to take part in these jams. I forgot to book the Monday off work, so I had to make do with the 48-hour Compo period, and then I kept losing focus and couldn't make the most of that time. It didn't help that...
• I'd originally planned for a longer storyline with about 15 puzzles, including signals that used multiple layers of encryption. However, when I came to implement the user interface for multi-layer decryption, I realised it just wouldn't work with the control system I had in place. It would've worked just fine with mouse controls, and in hindsight I should've gone with that from the start, but by the time I realised that, I didn't have enough time to make the switch, so I had to scrap the multi-layer encryption idea, cut the game short, and improvise a new ending. ** I'll take the unprecedented step of caveating this one. The improvised ending works well enough that you'd never tell it was improvised, 15 puzzles might have been a little too long, and considering how much people struggled with the regular Vigenere ciphers, then Affine + Vigenere ciphers absolutely would've had people tearing their hair out. So maybe it's for the best that I had to cut the game down after all, even if the circumstances that forced me to do so were less than desirable.
• In my rush to wrap the game up, I neglected to include a very important feature: the ability to look back over previously-solved messages for hints as to what the encryption key could be, meaning that if you don't write it down or can't remember the previous message, you're screwed. I'd recognised this problem during development, and had hoped the mentor's hints would be enough to nudge you in the right direction, but sadly not, and pretty much every review brought this up as a criticism.

My bright idea to name the game "RAVTZN" should probably earn a dishonorable mention, as I feel like it's massively hurt the game's discoverability. With four days to go, it's entirely possible that this will end up being the first Ludum Dare where I don't get enough ratings to be scored. (If you'd like to know why the game is called that, play it!)

What Happens Next

I don't need to wait for the scores to come in to know that this was my worst Ludum Dare since BreakEven all the way back in LD48. It's nowhere near as bad (it's playable, for starters!), but it definitely pales in comparison to the likes of Color Critters or Six Seats Left.

Once the rating period ends, I'll go back and do a post-jam update that adds the ability to review the most recently decrypted message, and maybe a couple of other tweaks, but after that I'll be back to working on my full-time project, Prism Warriors (wishlist it on Steam!). I remain committed to entering all five remaining Ludum Dare and will strive to do better next time.

That's all for now! Good luck to everyone when the ratings come in!

This past weekend Gasp Away! received its Post Jam update bringing in a number of QOL improvements and performance changes. We have a devlog here you can see for more details.

We would appreciate it if you all tried it out.

Windows, Linux and Web builds are available on our itch page.

okay be honest.. did I manage to match the portrait right?

try yourself and share your portraits here: https://ldjam.com/events/ludum-dare/59/almost-the-same

Watch our trailer for New London 3D Turbo 2000!

https://youtu.be/byFpXHpakvg

Try it, rate it, tell us what you think!

I'm honestly kinda shocked.

https://ldjam.com/events/ludum-dare/59/mission-404

As part of a minor update coming after the jam ends, I added a "spectate" mode to my game so you can view an in-progress (multiplayer) game without actively joining it. As a bonus, it let me quickly take a peek at some of the top games on the leaderboards and see what crazy fun people have been getting up to.

A huge thank you to everyone who has played, rated, and commented on Searching for Signal so far! <3

It has been genuinely lovely reading your feedback, whether you vibed with the atmosphere, laughed/groaned at the puns, enjoyed the music and visuals, or very kindly pointed out the bits where our 72-hour jam gremlins escaped containment. Every rating, every comment, and every “hey, this bit softlocked me” has been hugely appreciated.

We are sitting at a lovely pile of ratings already, but like an ancient Aikon 3310 desperately climbing a ruined city tower, we are still searching for just a little more signal.

So! If you have not played Searching for Signal yet, please do give it a go. It is a short atmospheric platforming adventure full of rusty streets, chatty robots, questionable reception, and at least one phone with more determination than most of us had by hour 71 of the jam.

And here is the deal:

Play our game, leave a comment on our Ludum Dare page after playing, and I will play and rate your game in return.

Comments are especially helpful because they let me know you have played, and they also give us the good stuff: feedback, thoughts, bug reports, puns, emotional support, or just a friendly “I made it to the top and only fell into the void twelve times.”

Massive thanks again to the Ludum Dare community. You have been kind, constructive, funny, and wonderfully generous with your time. Phil, Bizzybee, Frank, and I are very proud of what we managed to build, and seeing people actually play it has been the best part of the whole thing.

Now please excuse me while I go now to return some ratings, and pretend I definitely did not create any bugs. Tee hee!

Thanks for helping us find a signal. <3

https://ldjam.com/events/ludum-dare/59/sneaky-signals

And send some secret signals to your teammate while you are at it.

https://ldjam.com/events/ludum-dare/59/dragonia-siege

Since many people couldn't get past the first room I have written a walkthrough for my game. You can find it on the game's page.

Play Funnel World, a real-time ray traced puzzle game featuring optics related puzzles here.

Hello everyone!

We've crossed the 40-vote threshold, thank you all!

We're so glad you're playing our game and rating it—it's important to us.

Have a nice day, everyone.

PLAY ON ITCH.IO

RATE ON LUDUM DARE

I made a version with controller support for our handshaking diplomacy simulator Full Clasp. It's not entirely refined, but it's fun. It's interesting that it makes parts of the game hard, and parts of it easier. https://ldjam.com/events/ludum-dare/59/full-clasp-clasp-warfare https://www.youtube.com/watch?v=XyxG9ldeuXs

Hello, everyone! How's life?

This is third time my team and me participate in Ludum Dare, and I wanted to make a post about my small story with Ludum Dare. Because funnily enough, previous two times I made a game with my team at LD, it ended up getting a full release!

First time it was Ludum Dare 53 (theme: "Delivery"), when whe created our first ever jam game Detour. After the gamejam we worked for 1.5 years and made a full game, Robot Detour! Which released on Steam in 2024, and even on consoles recently.

Afterwards, I made a small compo game Feng Shui Struggles for LD 44. It was fun, but making a game together with team turned out to be 10 times more interesting!

Second time we made here a game together was Ludum Dare 55 (theme: "Summoning"), on which we made a demonic deckbuilder Burn With Me! We didn't release the full version yet, but are very actively working on the game!

And it's not like we try to make a full release out of every jam game: we created 10+ gamejam prototypes already. I suppose Ludum Dare is just that special :smile:

So, in a way, I owe Ludum Dare my indie gamedev career. Even though our time together was brief, I will remember this jam forever. And will try to participate as much as I can now!

This year stars finally aligned, and we had some free time around LD. We decided to make a small narrative atmospheric game, without any intent to make a full release out if it. It turned out a bit harder than we wanted, but that's just how jams work sometimes.

If you fancy trying it out, remember you can skip levels via pause menu

Nest, this is Pilgrim

Have fun everyone, hopefully everyone got out of this gamejam what they wanted already :heart:

Hey everyone!

I participated in this game jam and managed to finish and release my game, but unfortunately I ran out of time after the release to properly promote it.

As a result, I'm sitting at only 13.8 ratings received, and the minimum threshold to pass the initial evaluation is 20. I'm at risk of being disqualified due to lack of votes.

If you have a few minutes, I'd really appreciate it if you could check out my game and leave a rating.

Thank you so much!

As the Ludum Dare approaches its finale, I wanted to list some games I found fun and enjoyed the most ^^ My friend @vidarn recently made a gorgeous post with fanart of all the games they liked playing this LD, and I admit I am stealing this idea! I wanted to draw more but got progressively more disappointed in my artistic ability (or just tired?)

So here they are! I will split the post in two parts cause there are too many xD

1 Blipp (@vidarn) https://ldjam.com/events/ludum-dare/59/blipp

Obviously starting with this one. A lovely short adventure with beautiful graphics and usage of split screen. Highly recommend!

2 Satellite Days (@lectvs) https://ldjam.com/events/ludum-dare/59/satellite-days

One of the BEST games I've played this jam. It was so fun!! It might look simple at the first glance, but definitely try this one out if you haven't already - gameplay is engaging, somewhat challenging but not too much, and the game evolves with every level, getting to the EPIC ending!

3 Signal Sleuth (@jdeedubs, @ordineu, @bluewoozle, @thedugnutt and @csuth17) https://ldjam.com/events/ludum-dare/59/signal-sleuth-wip

This was not easy but definitely one of the games I remember the most. I swear, I did at least 40 tries to beat one cursed level! And that means I liked the game, since I was willing to sit there in the night and try and try and try again. It's also good practice for doing two things at once!

4 The Sound Store (@busisen and @jejkobb) https://ldjam.com/events/ludum-dare/59/the-sound-store

This was a lucky find, this game. It's drawn on paper, by hand, so the visual style is fantastic. It looks cute, and cozy, and I found the gameplay pretty original and chill (well, chill until waves combination where I failed ofc xD) Try it out if you haven't!! You'll probably do better than me xD

5 Misplaced (@manabreak) https://ldjam.com/events/ludum-dare/59/misplaced

I like all the games by Manabreak and this one is no exception. It's a very fun platformer, for me - not too difficult, it feels polished and it's funny :) I've played it myself and then forced my boyfriend to play it too. He breezed through it of course (he is a huge fan of metroidvanias). I would love to play a full game like this!

6 Pouring rain (@jackofcups and @t-c) https://ldjam.com/events/ludum-dare/59/pouring-rain

Second part of Rain (https://theworldsquid.itch.io/rain). So I've played them both! I found the story to be very interesting, and I love adventures like this. There is a walkthrough too if you get stuck. The game is pretty and atmospheric, and it's fun to build theories about it. Waiting for the full release xD

7 Robo Phone Home (@wuppos and @pastry-chef) https://ldjam.com/events/ludum-dare/59/robo-phone-home

Wuppos's art is always so pretty, and again I liked the visual style of this game a lot ^^ So cute! It wasn't very easy for me, but it has an interesting and polished gameplay that fits the theme well, so def try it out! :)

// Second part coming soon!!

I’ve hit my 20, but feel like I need to review a few more games. Drop yours here if you don’t have your 20 yet and I will try to play them a little later today!

Be sure to play some of the other games that are put here as well! Let’s help each other!

I’ve already hit mine like I said, but feel free to play it if you’d like! https://ldjam.com/events/ludum-dare/59/reaper-savior-of-souls

Continuing the list of the games I liked and drew lil simple pictures of :)

8 Love Caps (@wouter52) https://ldjam.com/events/ludum-dare/59/love-caps

Found love of my love in this game (see the picture). It's such a fun idea, and I love mushrooms, and I enjoyed this game a lot and you might too! ;) Find your mushroomy soulmate today!

9 Hidden Signals (@soundgnome) https://ldjam.com/events/ludum-dare/59/hidden-signals

At first I was confused, but when I figured what to do, it turned out to be a very meditative and relaxing game. I was sad when it ended. I wish it didn't. Hard to draw fanart for something that is just shapes, but I tried nonetheless! :D

10 Mixed Messages (@ben-morledge-hampton) https://ldjam.com/events/ludum-dare/59/mixed-messages

Text-based game with gameplay I liked (figuring out the correct letters/words) and engaging story that I did, in fact, fully engage in! Very memorable, and makes you want to eat a peanut butter and jelly sandwich :)

11 FROG (@railnof, @korobei-jt, @hana-ghst, @setsu, @stromineur and @egrassah) https://ldjam.com/events/ludum-dare/59/frog

It is very cute!!! I love frogs. The final CG is so so pretty!! It's a puzzle game and it might be a bit confusing, but I managed to complete it so everyone should be able to xD

12 Signal Colors (@doridie, @jasmin and @robin-schmitz) https://ldjam.com/events/ludum-dare/59/signal-colors

Another shape-game I enjoyed this jam. My stats are represented on the picture :) I especially liked the upgrade system. And pink and teal colours. Very relaxing, too!

13 Speed Signal (@pkenney) https://ldjam.com/events/ludum-dare/59/speed-signal

This compo game is super fun. Only forward!!! There is only one button to press. Jump and jump and jump! To get the banana. I liked it a lot ^^ Chaotic and fast-paced.

14 While you were here (@jpat) https://ldjam.com/events/ludum-dare/59/while-you-were-here

I really liked this game, it's so beautiful and atmospheric! I struggled with the fanart but ultimately decided to post it anyway to shoutout the game. I just can't draw as prettily as jpat, sorry! But I tried my best! Check out the game and the tips if you get stuck, it has a lovely fairy tale atmosphere <3

// I wanted to mention a few more games I didn't draw a fanart for.

Foto: https://ldjam.com/events/ludum-dare/59/foto

Here is my photo from this game. What I liked a lot is the social aspect of it! You make the photos and share them :) And then people can find the location you took photo of!

Samband: https://ldjam.com/events/ludum-dare/59/samband

A short and sweet puzzle game. I needed a tip to figure it out but when I did, I enjoyed my stay with it! ^^

I've been around games for a long time. A few years building web games early in my career, then years as a server dev. Over a decade reviewing other people's games.

Lighthouse's Vigil, made for Ludum Dare 59, is the first game I've ever shipped by my decision (and the incredible Sasori-san too)!

That sentence took me a while to write down honestly. Saying it out loud makes the gap obvious — a whole career adjacent to the thing, and never the thing itself.

I have a dream game. One I've waited much more than I should to start. I did so last year, it's been in actual production for the past ten months, with all the usual signs of a project that's serious. More than it should for a debut game to be honest. And like most of them, it has the gravitational pull of a small planet. The closer I spend time with it, the bigger it gets.

Every game develop I respect, when I've described that project, has given me a version of the same advice: ship small things first. Finish something. Let yourself find out what "done" feels like before you stake years on it. I have mostly refused that advice until now, the jam was me finally taking it.

What a 72-hour deadline does to you

Three days is not enough time for second-guessing. That turned out to be the entire point.

I went in reasonably conservative. The thing I'm best at my day job is (which is also in games) is judgment - looking at a game and feeling what is working, what isn't and what is ready. That muscle is genuinely useful when you're building something. It's also something that stopped me for years from ever calling my own work "good enough".

In a jam, I figured I would assume at face value what I was doing, small experiments - some of which took me 6 hours I regretted - and do whatever I could to make the best experience possible with the simplest idea I could come up with. I had a bunch of personal ideas I would do for smaller games, I just never implemented them, and one of them felt like the best for the current theme, signal - a lighthouse game, where the whole point is controlling the light.

Here, even though I was in a small group, we make a call, we ship the call, and three hours later it is already invisible behind the next one. By the Monday night (JST) I had made thousands of decisions I'd normally have agonized over for weeks like I did in my main game, and the game just existed. I sincerely knew a few of the things that were lacking, much of which people gave precious feedback about, but it got to a moment we decided to stop and call it a release, and push it forward.

The feeling of relief of finishing it was something really odd to me, as I have been in an infinite loop of regret and working on unfinished things for more than half a decade. The other surprise, and that is the part I want to bring forward into the dream project, was how much a small project gives you to be audacious.

We added voice acting in the last 24 hours, 75 voice lines recorded in less than one hour by my beloved wife, Pangami. She reacts to essentially most of the in-game events. We had no plan for it, and it was one of the most commented elements we received, beyond atmosphere, style, and the infamous difficulty. A "real" project, like many of which I have dealt with, with milestones, stakeholders and risk reviewers, would have killed the idea in an instant.

The uncompromised vibe of "let's just try to do it" is the the golden opportunity of a game jam. The cost of trying is bounded by the deadline you're already going to hit anyway. So you try things, and it turns out a surprising number of them land or crash. And a couple weeks later, I'm already applying the feedback into a post-ratings update AND to my main project.

If not for this game jam I would probably still be very conservative on it, and would have lost many opportunities, like the incredible opportunity to work with Sasori-san.

Feedback I didn't expect

I've spent over a decade giving other developers feedback on their games, in my original Brazilian blog, CyberCafe, which will be closing down this June after 13 years operating. Receiving something similar on something I'd actually built was very satisfying, especially the ones that were countering my original proposal here.

Talking specifically about a few of your (the esteemed reviewers and commenters which I cherish personally) points: - Multiple players complained about the lighthouse rotation speed. I made that deliberately conservative, on the theory that a fast spotlight would feel unrealistic and trivialize the game. The honest answer is that I'd optimized for the wrong battle. The complaint wasn't "this is too hard", more so "I can't act in time". That's a control-agency problem, dressed up as a difficulty problem, and I would have caught it in five seconds in someone else's game. - A few people suggested a few things I even planned on eventually getting to had I a little more extra time: like upgrades. - Another point was not knowing how to beat the final boss, and it's essentially the same as beating any other enemy! You focus on its core, but that wasn't clear enough for users, and they got frustrated by the swarm of miasmas going their way (there is no time!!!). - I made the system of this game with the idea in mind that it was a survival, while players were tending on optimizing scores, and got frustrated by a system with a different goal. I could have, for sure, made something that would satisfy both things, if I had the time (and maybe I can, after the ratings are out).

The biggest takeaways from this game jam for me: 1. Ship small first, even in a massive project 2. Deadlines beat taste 3. Be audacious in bounded contexts 4. Get feedback before you're ready. ASAP.

Sorry for the massive wall of text, and thank you for reading until here. I deeply appreciate the opportunity to participate the Ludum Dare 59 and will likely again.

If you haven't had the opportunity to play Lighthouse's Vigil yet, please do! And let me know in the comments if you'd like me to review yours in the meantime, while ratings are up! I'd be happy to check any that I haven't yet, I really tried to review as most as I could.

Stay safe out there!

Tanjou

[Signal wave path]

It's good to keep an eye on your surroundings; you never know when a creature might jump on you... maybe it just wanted a hug?

Leave a comment under the post with a link to your submission. I will rate it. In return, please rate mine. https://ldjam.com/events/ludum-dare/59/system-invader

TL;DR tech issues on our end during submission, initial submit was missing ~ 90% of the level. Then IRL things happened that have kept us busy for most of the last couple weeks.

So I will be playing/rating some games today. If you're still checking out the Ludum Dare page and want me to rate yours, leave a comment on this post. I'll try to get to as many as I can while I have the time!

If you haven't had a chance to check out our (rather short due to being over-ambitious) entry, you can find it here: https://ldjam.com/events/ludum-dare/59/bad-vibes

I'll be doing my first ever postmortem on it soon as well, so long as nothing else pops up between now and then :sweat_smile:

Thought I'd share the full quality apple photoshops I did for the paintings in game, since some of them appear too small in game to be readable. Some of them contain references to our previous jam games

Ghost channel is a Luigi's Mansion inspired action/puzzle ghost hunting game where you play as a tv head that can connect to the frequencies of ghosts. It's also a tv show that you watch on a screen inside the game and it has a 90s inspired aesthetic!

Play it here!

Hi, my game "Bird Man Signal" needs just 5 more votes. It's a short web game about an office worker trying to get to the Batman-like signal to alert the local super hero Bird Man. Text-based, light puzzles.

https://ldjam.com/events/ludum-dare/59/bird-man-signal

Edit: Thanks to everyone who voted! I have nearly 30 votes :heart:

What's this?! They play a deceitful melody?!?! CURSE THEM!!!
https://ldjam.com/events/ludum-dare/59/the-last-beat

If you want focused feedback on your game come into my stream and post your games in the chat!

https://www.twitch.tv/kayrumdev

Hi everyone!This was our first-ever game jam and our very first project. We were super excited, but unfortunately, we didn't calculate our time well and missed the submission deadline.Even though we didn't finish on time, LD was a great experience. It pushed us to mobilize our efforts and showed us how much we can actually do in just a few days.We aren't stopping here!

This jam gave us the boost we needed to keep moving forward. We've learned some big lessons and are excited to keep developing our project.Good luck to everyone who finished!

Streaming an overview of my team's puzzling board game, then playing other games!

If you have recommendations and want feedback, you may link your game in the comments below, or mention your user name or game name on the Twitch stream so I may look your game up to play and give feedback on it. Looking forward to seeing what we all made!

Haven't made a post about my entry yet, but it's a fairly small experience you can play in browser. I'm only at 11 ratings right now, so I'd love if I could get a little boost before the voting ends.

Link, if it works

Good day or morning, guys!

I have a question. If a game is really poorly made in some specific aspect, what is better to give it: no score at all, or a 1?

Hi everyone!This was our first-ever game jam and our very first project. We were super excited, but unfortunately, we didn't calculate our time well and missed the submission deadline.Even though we didn't finish on time, LD was a great experience. It pushed us to mobilize our efforts and showed us how much we can actually do in just a few days.We aren't stopping here!

This jam gave us the boost we needed to keep moving forward. We've learned some big lessons and are excited to keep developing our project.

Yesterday I spent most of the day making a new game with my newly developed AI code generation technique to see how well it works for a more complex game. So I present the Generative Gungeon, a hard Roguelike Gauntlet-like maze/dungeon shooter with random levels, featuring 100% AI generated game code.

>>>Play the game here<<<

Looking for some feedback on my game👀 Happy to return the favor — drop your games below! :point_down: >>>>>>Play Here!<<<<<<

FIELD UPDATE:

Missile Strike can now evolve into Missile Barrage, allowing operators to convert precision impacts into sustained saturation fire.

This has significantly increased battlefield effectiveness.

...and operator self-casualties.

Turns out one missile was not enough missiles.

We've have updated our Fire Support Survivors with a Post Jam version with - upgraded tutorial - new weapons eg Tesla Coil and the field tested Missile Barrage! - character selection!

Tutorials are always tricky to get right and only way to have any understanding is via feedback, so if you have a moment to try our new tutorial and share your thoughts, that would be great!

PLAY THE POST-JAM VERSION

👉 https://zamizmi.itch.io/fire-support-survivors-post-jam

https://ldj.am/$424583

Hey! Vice Signalling artist here! Firstly, I'd like to express my gratitude for all the kind words about the visuals. It always warms my heart to know the game left a lasting impression by the looks alone aha

But. That scope and quality wouldn't be possible without my hardworking and talented friend @pt

This time instead of simplifying the assets as it was on my first jam as the only artist, the strategy was to split the workload between the two of us. I was in charge of sprites and CGs, @pt is behind the wonderful UI, backgrounds and elegant typography

Tbh nothing new: plan ahead and stay in touch with each other during the process. We settled on a limited colour scheme, a strict code of decoration, a general placement for sprites and UI and... descended the art mines for 72h.

The result has outdone our best expectations and honestly speaking I didn't expect 7 unique CGs for three endings over 72h from myself haha

...and our little humble team would be happy if you take a closer look at Vice Signalling

LD

A general call to colleagues! Our project is just a few ratings short of reaching the desired score. We would greatly appreciate it if you didn’t pass by and took a moment to experience the eerie atmosphere of SCP-███ – Warehouse.

Slim Pickins run a secret message relay base deep in the raider-filled wilderness, but receiver has broken! Find items, meet characters, and search across a wacky world to find the people and components you need to get things back up and running. I'm pretty proud of what we managed to make this time - it's pretty darn cool - and we would love some more feedback before rating ends if some of you are interested!

>> Play Here <<

First of all thank you to everyone that rated our game and everyone that showed up yesterday!

Since I want to give feedback to as many people as possible I made a queue. I will try to play as many games as possible even after the voting has ended. To submit your game just drop it in the chat.

Will try to stream every evening from now on until the queue is empty (except friday) on my twitch.

Feeling endlessly honored and teary right now. Three days can do so much! Read the full article here and play Pyre Lookout here if it convinced you to check it out!

Strike down the deceitful! We need 7 more votes!

Play GigaHurtz ( Web ) here

I've added an external link so hopefully it works.

Btw - do hit me up to play your games too, especially web ones - I've sadly not had enough time this challenge to smash through as many as I'd have liked. :scream:

Try it!

Hi jam folks!

I didn’t even wait for the theme announcement — I just went to sleep like an old man. In the morning I saw the theme, got a bit sad because I already had another idea prepared, and originally wanted to make the game in Construct because I already spend enough time in Unreal at work lol.

My early ideas included: - a signal from space, - Doomguy jumping into the Earth’s core, - Morse code during war, - office signals, - forest Wi-Fi horror, - and neural signals in the body.

I actually started the forest horror version, then suddenly decided: no, let’s suffer properly and make it in Unreal, solo, in compo spirit, despite the fact that I absolutely do not know how to do 3D.

While I was in the shower, the idea finally clicked: signal distortion.
First it was some robot carrying a signal from point A to point B. Then I remembered an old idea I had back in 2012 about a physical backpack, where information could fall out and get mixed up. Then I remembered the “last brain cell” meme.

And that’s how the final idea was born:

you play as the last brain cell of a shy guy on a date, carrying Thoughts through his brain to the speech apparatus so he doesn’t say complete nonsense.

I opened Blender for the first time in 5 years, made a sphere with little arms and legs, watched a 6-minute rigging tutorial, imported it into Unreal, and somehow ended up with a dumb little neuron guy. Animation tutorials were no longer 6 minutes long, so I gave up on that and used Unreal’s built-in procedural animation instead. Because my export was broken, the rig was cursed, and IK didn’t behave, I ended up with floppy physics arms — which honestly looked funnier anyway.

I also tried to add jumping and moving platforms, but they felt terrible, so there is no jump in the game lol.

Then I spent half a day fighting a shader because I copied one from a stylization talk and it looked уныло, so I had to make my own weird fleshy version instead ahaha

By day two I finally had: - a weird brain-cell character, - a backpack, - fleshy brain terrain, - a Megabrain that spits out Thoughts in the correct order, - and the core loop.

The core loop is simple: - the Megabrain spits out Thoughts in the right order, - you memorize them, - you carry them through the level, - and throw them into the speech hole in that same order.

If you do it right, the guy says something normal and the Mood goes up.
If not, well… the date goes badly.

I wanted to add way more: - 3 stages of the date, - voice acting, - wind in the head, - shaking from nervousness, - scrambled Thoughts, - visual reactions from the girl.

But even without all that, I’m still really happy that I managed to finish the core gameplay loop — and make the whole thing 100% by myself.

If you want to help this poor guy survive his date, you can play it here:

Last Brain Cell

Thanks for reading, you’re awesome.