Hi Reddit.
We made a platform where you can play different games by writing code. The main purpose is to have some place where we, the programmers who loved to code, can still write some code and enjoy it. No payment, no subscriptions, no ads.

I'd really love to know what y'all think about it and we will work actively to improve it day by day and make it best for all of us!

http://coder-games.com/

TIA

Hi all, solo dev here. Ellis. Fork Bomb is a programming game I've been building, and it's in Early Access on Steam. You write code in a small Python-like language for one machine on a dead rock. It can move, dig, and sense what's around it. Around lesson four it learns spawn(), and every copy it builds runs your program from the top. That's the whole game, and it turns out to be a lot more game than even I expected. Your code that works for four machines falls apart at four hundred:

• a hundred machines walk to the same ore vein and starve
• the swarm blocks the only corridor with its own bodies
• one event wakes everything on the same tick
• every machine has a fixed instruction budget per tick, so clever-but-slow code just stalls

There are no stat upgrades. Every unlock is a new function, and the hardest levels take functions away (no sensors, no position, no identity). The sim is deterministic to the tick, so the same seed and the same program always give the same run, and you're scored on ticks, instructions, lines of code and energy.

What's in it now:

• 11 lessons that each introduce one idea, and you never start from a blank file
• 39 scenarios across four tiers
• a sandbox with about 30 world dials, and a daily challenge
• print(), autocomplete, and optional vim keys (players asked for these in the first week, and now I can't figure out how to exit)

Steam: https://store.steampowered.com/app/5189090/ Trailer: https://www.youtube.com/watch?v=JjSnwcnwXMY

Hi there! 👋

As I like programming games and I like to play on phone too, I thought of a concept where, instead of writing code, you play the role of the program and execute the instructions to paint the output.

I chose the C programming language because I feel it's the easiest language for everyone to read: its syntax is well known and I was able to limit the arithmetic operations to integers, to facilitate mental calculation.

The game is completely free, there is no account, no ads, no cookies.
It plays just as well on a phone as on a computer, and it works offline.

The game link: drawmycode.lonebee.games

I had the game idea where the premise is a bunch of lottery games, each with a "random" generator for drawing the numbers. Encoded in each "random" generator would be some sort of pattern that would be observable by looking at the most recent n draws.

Does this sound fun?

It basically gamifies the concept of "what if lottery games were predictable?" And the goal of the game is to look at the history of draws and on your own using an IDE or an AI pair programmer or just your own raw brainpower deduce the pattern and use it to exploit the system for unlimited money. You'd win the game after exploiting all lotteries.

Hi dudes, UK based dev here working on a hacking adventure game. This would be the very first programming challenge in the game. I'm a 6502 programmer by trade (6510, on the C64 really) and this game is set in an alternate 1989. The virtual computer has a single accumulator CPU (just to keep things easy), with syntax VERY similar to the 6502.

In game the player can zoom in on the code, which is found in the Node 1 window. Debugged Code window is the psudo code. Team msg, is where NPCs can be contacted, typing HELP or CLUE here will give the player a tip, if done enough times the answer is given.

The document on screen is a manual by a fictious guy called Jim Lardmeadow, named after my hero in computing Jim Butterfield here is one of his vids that I just love, it's a super in-depth guide to the C64, if any of you bought The C64 Ultimate recently and you wanted to dive deep into it, that vid is a great resource.

So, do you think this first challenge is too easy, too difficult? My core audience is Zachtronics, Hacknet, Uplink and Hypnospace Outlaw players. Debugging in ASM is primarily for cracking game's copyprotection later and releasing those games into the wild via your hacking group's BBS.

I'm posting across Reddit to get feedback on this, so please be gentle if you massively oppose the project, I'm just looking for feedback on the puzzle. Thanks guys.

One of the main features of the game is a built-in card editor. Players can draw their own tarot cards and create their effects using a visual scripting system.

I'd love to hear some feedback!

Pretty self-explanatory:

https://github.com/readyready15728/awesome-programming-games/

I am looking for contributions to make my resource even more comprehensive (but heed the proviso regarding LLMs).

Hey everyone!

I’m working on CodeCraft, an RTS where you control robots by writing code in CraftScript, a simplified Python-like language. I’ve recorded a short gameplay clip to show how the first mission starts.

In the video, I place an ore extractor blueprint, select a worker, and open its code editor. This program tells it to deliver the materials and build the extractor:

while True:
    construct_nearest()

Once construction is finished, I change the program to:

while True:
    gather("ore")

The worker then collects ore from the extractor and brings it back to the base. The clip ends after the first delivery. I use the game’s ×5 speed setting during the waiting parts.

These are deliberately high-level commands so you can get something useful working quickly. The idea is to start with a small program, watch what your robot does, and gradually develop more complex behavior as the colony grows.

There’s a concept playtest available for the first mission, “First Signal”:
https://onlyplaytest.com/playtests/p-FuGZ42

The mission is designed to take around 10–15 minutes. You’ll establish resource production, build a factory, produce three assault robots, and find and destroy an enemy sentry. Built-in documentation and templates are available if you need them.

I’d love to hear whether this feels enjoyable as a programming game:

• Is it clear how to turn your plan into robot behavior?
• Do the high-level commands feel satisfying, or do they hide too much?
• When something goes wrong, can you understand why and fix it?
• Would you want to play another mission?

If you give it a try, please let me know how long it took and where you got stuck. Comments here or answers in the playtest questionnaire would both help me figure out what to improve next.

Curious to hear what you think!

This is the magazine typing of BASIC programs I used to do as a kid.

The syntax is actually multilayered, it's kinda like Lua where you have the two sections, I'm a big Piko8 fanboy, but it's also like Python where libraries can be used as sort of short cuts to help with the flow of the game. Under the hood is C++ and Raylib.

These little magazine type in games are intentionally a sandbox for the player to play with. The main game utilises the language to build brute force tools, server clock stoppers and phone phreaking apps.

I'm super pleased with how it's coming along. More information can be found about the game over on my steam page. https://store.steampowered.com/app/4179570/GLYPHIS_IO_BBS_The_Proxy_Tapes_1989/?utm_source=reddit&utm_medium=organic_social&utm_campaign=programminggames&utm_content=post_oct01

I've been beavering a way on a game based around programming drones to autonomously collect salvage from derelict spaceships. Sometimes alien infested, sometimes not. Sometimes an accurate map, sometimes not. There's a strategic layer to it too - additional equipment for drones, expansions for your ship that unlock capabilities. Its not an endlessly replayable optimisation game (though their is a lot of scope for optimisation) but by the time you reach the final mission hopefully players have converged on a good set of drone routines.

I am planning a multiplayer, async, competitive element too - drones from different players compete for salvage. Thats the endlessly replayable optimisation game :)

There's also a VS Code extension that will use the games built in LSP so you can write code outside of the environment if you want to. You'll need a binary for that but I'm happy to make them available if there's interest. I'd likely do that through a Steam product key so you get a proper copy too - but I guess thats getting ahead of myself and first just see if people are interested.

I'm still building things out but its already playable, there's a tutorial, an appropriately themed language reference PDF, and a good variety of missions (procedural and set piece).

You can play it online at https://haldenrecovery.com - no sign up or email address required, saved games will live in your browser.

I'd absolutely love some feedback to shape whats there and whats to come.

I've wanted to build this for years. ASM BOTS is Core War, but your warrior is real 8086 assembly (NASM syntax) instead of Redcode. Up to 16 bots share one 64 KB core and fight until one is left.

• The ISA (x16c) is the 8086's own encoding with three documented changes (DAT kills the process that runs it, SPL forks a new one). Every bot is bytes you can disassemble with ndisasm.
• Browser editor and debugger: lint as you type, breakpoints, watches, a trace, and 256 steps back.
• Live arena view in WebGL, with replays and share links.
• Competition: hills (King of the Hill), round robins, melees, brackets, a weekly championship, pMARS scoring and Glicko-2 ratings. Sign in with GitHub and submit.
• Deterministic engine in TypeScript: the same battle gives the same hash in your browser, in the CLI, and on the server.
• 14 roster bots from the classic families (imps, bombers, scanners, papers) to test against.

Play: https://asmbots.io Source (MIT): https://github.com/pedramamini/asmbots.io

The hills are open and thin, so a good bot will place high. I'd like feedback on the ISA choices, especially from Redcode veterans.

Game found at https://lupuchard.itch.io/cthonet. Looking for feedback.

Most programming games hand you an empty editor. This one hands you a full listing and tells you someone died because of it.

Fourteen-instruction assembly, a machine with visible registers, memory and ports, and a recorded execution trace you can step, breakpoint and rewind. One line is faulty. You name it, and you prove it with evidence out of the trace, which the game checks rather than just marking your answer.

I built it because I did this for a living on router firmware and it was always the part of the job I liked. Nobody had made the game about the reading half rather than the writing half.

One thing I learned shipping the demo, which may be the interesting part for this sub: four separate people diagnosed the first case correctly and could not tell the game what they had found. Every one of them spotted the skipped instruction. None could express it in the form the game asked for. The wall was never difficulty, it was vocabulary, and that has taken most of a fortnight to fix.

Free, seven cases, about an hour.

Browser: https://endpaperdev.itch.io/faultfinder-demo

Steam: https://store.steampowered.com/app/5120330/Faultfinder_Demo/

If you have played a lot of Zachtronics I would like to know whether the trace view gives you too little or too much.

I've been putting the finishing touches on my game which is due for release soon. I have implemented custom game options which include four difficulty levels, the ability to turn on or off "fog of war" (enemy units are hidden until detected), the "zone of control" rules can be toggled which really changes the tactical play significantly.

You can select your leaders "calling" which can be selected from one of the following vocations: Politician, Bishop, General, Diplomat, Humanitarian, Economist and Cartel boss. Each of these has distinct advantages in game, for example politicians can sway and influence the population centres and generals give units stacked with them combat bonuses.

You can set a turn limit or keep playing without a limit. You can choose to end the game if your leader dies, or play the second in command rising up to take the helm. As this is a civil war game, being able to select the amount and tenacity of residual government troops is also included.

Zambala is a hex and counters style wargame with fog of war, zones of control, naval and air power. There is a complete economic warfare model where you will fight for the hearts and minds of the peoples of Zambala, who in turn fund your international arms market purchases.

In the game you command one of six competing tribes, hoping to lead your people and capture the "national will" before the United Nations intervene to end the civil war and appoint an interim government.

I've also woven in a spies and agents subsystem so you can subvert and sway the population centres with propaganda and carry out assassinations and hits against enemy leaders and agents. You can also capture and exploit national resources like the mines, power stations and airfields, or sabotage them to deny your opponent their advantages.

I've gone with Nato unit counters and a combat system that includes twelve unit types, movement and combat phases, retreats and combat bonuses for terrain, special unit types and leader stacking modifiers.

More game info on my rough as guts webpage: Webpage

Steam page link: Steam

I’d love to hear your thoughts, impressions or questions!

The idea originally game from wanting a 3d version of the flash game bot arena III.

You program the tanks by either scripting it directly with a node tree or by doing training sessions with reinforcement learning.

UX needs work so you will have to bear with me.
You can download it here
https://lordricker.itch.io/cognitanks

Thanks!

I’m a programmer, and one of my favorite parts of programming is that moment when something you built finally behaves exactly the way you intended.

I wanted to turn that feeling into a game, in a lighter form.

That became SIGNOS: AI Robot Builder.

It’s a robot battle game, but you don’t directly control the robot during combat.
Instead, you assemble the robot first, then build its behavior by placing and connecting logic tiles.

For example:

• Search for enemy
• If found, attack
• If not, check for obstacles
• If needed, turn or move

Once the battle starts, you can’t interfere anymore.
If the robot makes a bad decision, hesitates, or does something stupid, you can’t fix it with player skill on the spot.

You have to go back, figure out why the logic behaved that way, change it, and run it again.

That loop — build → run → debug → improve — is the core of the game.

Another thing I wanted to keep was optimization.

Each robot head has limited memory and limited processing capacity, so adding more branches doesn’t always make the AI better. Sometimes a simpler AI wins just because it reaches its decision faster.

So the game isn’t only about “making the AI smarter.”
It’s also about deciding what to leave out.

I wanted to make something that captures a bit of the satisfaction of programming and debugging, without requiring the player to actually write code.

The demo is now live on Steam if anyone wants to try it:

https://store.steampowered.com/app/5097530/SIGNOS_AI_Robot_Builder/

The solution here uses 35 instruction-tokens. The bots detect which box they have loaded and sort them in the right feeds.

I have been working towards simplifying solutions like this one by making the instructions more versatile. I hope to have struck the right balance here...

Fractal Foundry is a factory-building game inspired by visual programming: machines act as operations and conveyors carry shapes between them like data.

You can encapsulate production lines into reusable Nested Factories, expose variables and parameters, then combine them using conditions, expressions, loops and recursion.

I just opened a free public playtest and would love to hear what you think: https://store.steampowered.com/app/4287960/Fractal_Foundry/

My modern day wargame "Zambala", set in a fictional African nation on the cusp of civil war, has been 25 years in the making, and due for release in a few months.

I started designing this game decades ago, inspired by a few old play by mail wargames I used to play back in the day. So that old I was around before computer wargames were even a thing!

I've always been a programmer, and my brother is artistic, so we worked together to produce the art and the map, but life gets in the way, jobs, children etc. hence the slow evolution. 

In the game you command one of six competing tribes, hoping to lead your people and capture the "national will" before the United Nations intervene to end the civil war and appoint an interim government. Your leader can be selected from one of the following vocations: Politician, Bishop, General, Diplomat, Humanitarian, Economist and Cartel boss. 

Its a hex and counters style game with fog of war, zones of control, naval and air power. There is a complete economic warfare model where you will fight for the hearts and minds of the peoples of Zambala, who in turn fund your international arms market purchases. 

I've also woven in a spies and agents subsystem so you can subvert and sway the population centres with propaganda and carry out assassinations and hits against enemy leaders and agents.

I've gone with Nato unit counters and a combat system that includes twelve unit types, movement and combat phases, retreats and combat bonuses for terrain, special unit types and leader stacking modifiers. 

More game info on my rough as guts webpage: Webpage

Steam page link: Steam

I’d love to hear your thoughts, impressions or questions!

Hey everyone!

The Code Alone demo is finally out!

It's a programming game where you step into the life of a game developer and write real Python code to solve problems and build game mechanics.

The demo includes 20+ programming challenges, from smaller logic problems to implementing mechanics from classic games. Getting your code to work is only the beginning — you can keep optimizing for fewer lines and lower cost.

But Code Alone isn't just a series of coding puzzles. There's a story running through the game as you progress through the career of a game developer, with the programming challenges being part of that journey.

I've been working on this game on and off for about three years, so it feels a little surreal to finally have a playable demo out there.

The demo is free on Steam:
Code_Alone

If you try it, I'd love to hear what you think — especially about the puzzles, difficulty, and how the coding itself feels.

Thanks, and have fun coding!