I’ve spent the last few months building a Zachlike programming game where you program an Arctic weather station. The programming side is heavily inspired by games like Shenzhen I/O.

The challenge in the screenshot needs the player to find the magnitude of the wind over a set time. The wind changes direction and for that you need a square root. Turns out there are several ways to do a square root, so I thought it'd be an interesting problem.

Hello everyone, I recently released a demo for my game Hello Triangle: Build a GPU. In the game you wire components like Comparators and Adders to build circuits, and eventually pieces everything together to build a GPU. The demo is available on Steam, and it supports Windows/macOS/Linux.

https://store.steampowered.com/app/5395930/Hello_Triangle_Build_a_GPU/

The game is about graphics rendering pipeline. Every time you run your circuit, you’ll see what your circuit renders and you’ll be able to debug the circuit if it doesn’t render the target image.

The demo has 15 levels, and in the end, you build a rasterizer that draws a triangle.

I hope you can give it a try, and I’d love to hear what you think.

I’m developing ERZ Online, a side-view mining MMO. You can dig by hand, and hunting the rarest veins that way is a playstyle of its own, but the core gameplay is about programming a fleet of bots to do the bulk of the work for you.

The trailer below shows these logic systems in action: bots autonomously navigating, mining, and returning resources based on player scripts.

How the programming works:

You use a visual block-based editor (no coding required) to snap together logic:

- Movement

- Scanning (searching for specific mineral deposits)

- Conditions & Actions (e.g., If inventory is full - return to base; If hostile detected - flee).

Once running, your bots operate entirely on their own. You use the gathered resources to trade on a 100% player-driven market and research upgrades.

https://rpoverwhelming.itch.io/rheuma

This is a free-to-play visual programming game with a retro graphical style inspired by Conway's Game of Life. It is extremely minimalistic in the tools it gives you: there are essentially only the cells you place and the arrows that tell them where to move. The rules of how the cells interact when colliding create the logic. It is extremely space-efficient for making simple logic gates, as a NAND gate only takes 7 tiles.

It has an endless grid that automatically saves all the changes you make and a select tool that lets you move, delete, copy and paste circuits. You can also undo recent changes or reset the whole grid.

Zach Barth once said here on Reddit "Whatever you do, don't make your players program in JavaScript":

So I guess you could say that this is a "hold my beer" type post...

Anyway, try it out if you like programming/automation type games!

Web demo: https://www.bryanpg.com/pragma_twice/

Hi everyone!

I posted here a while ago about IT THINKS, a game where you build and program your own GPU.

Over the last two months I’ve been improving it based on your feedback. It now has daily challenges, community puzzles, and lots of UX improvements.

The playable demo is finally ready and is taking part in Steam Next Fest. I’d especially love feedback on the programming mechanics, the difficulty curve, and whether the concepts are explained clearly enough.

You can try it here: https://store.steampowered.com/app/5196330/IT_THINKS__Build_Your_Own_GPU/

AI disclosure: Most assets in the demo were made by human artists, but it also contains a few AI-generated placeholder assets. I plan to replace them before the full release.

Been working on this project since some years and right now I am heading to release a demo in 1-2 weeks. If you like games like Avorion, or maybe have played Eve, and you would like to get some Minecraft elements into it and then use Lua scripting to automate everything -> Auto-Astra is made for you!

https://store.steampowered.com/app/2996550/AutoAstra/

Ready for any questions and if you want to join the next play test, give me a message!

Hi all, Ellis again. A little while back I posted Fork Bomb here, an incremental with no upgrade shop, where the only thing that scales is your code. A lot of you played it and told me exactly what was missing. Most of it is in now, so here's where it's at.

If you missed it, you write code in a small Python-like language for one machine on a dead rock. Around lesson four it learns spawn(), and every copy it builds runs your program from the top. Code that works for four machines falls apart at four hundred. There are no stat upgrades and every unlock is a new function. The sim is deterministic to the tick, and you're scored on ticks, instructions, lines and energy.

It runs on Linux now (beta)

There's a native Linux build on an opt-in beta branch. I don't own a Linux machine or a Deck, so honestly you're the test. Right click it in your library, then Properties > Betas > linux-beta. Once a couple of you say it runs, it moves to the main branch and goes on the store page. Your saves come with you through Steam Cloud.

You can actually see what your swarm is thinking

The question I heard most was "why is machine 212 just standing there." So:

• Rest your mouse on any variable to see its live value on the machine you clicked. Locals and parameters work too.
• If most of your machines are stuck in a loop that does nothing, the status line says so and points at the line. It's nearly always a missing else.
• Errors make sense now. recv()[1] on an empty mailbox used to say "value is not indexable." Now it tells you the mailbox was empty and how to check for it.

The editor grew up

• The code panel can go fullscreen.
• The API reference and Field Guide pin open beside your code while you type.
• Saved snippets follow you through Steam Cloud. They still count toward your line score, so no free lines.
• Themes: One Dark, Dracula, Monokai, Solarized, Gruvbox, Nord, and a light one.
• Emacs keybindings, next to vim. C-x C-s deploys. I still can't figure out how to exit either one.

It feels like a proper game now

Next up is a proper debugger. With breakpoints, a watch list, and hovering whole expressions like grid[x]. After that come leaderboards and more campaign levels.

If you're on Linux, I'd really love to hear how it runs and what distro you're on.

Steam: https://store.steampowered.com/app/5189090/

Trailer: https://www.youtube.com/watch?v=JjSnwcnwXMY

Fellow developers,

I made a Discord for our small community making games for this beloved genre.

Share ideas, showcase projects, playtests, and Steam pages, exchange marketing tips, discuss implementation details, team up on bundles and Steam fest events, and help each other out in this tiny niche.

You're all welcome to join.

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

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

First time posting here. The game runs on a fictional 1989 computer, the Bradsonic 69000, onyx-black and CGA+. It's got a single-accumulator assembly language inspired by the 6502 and its own BASIC called BradBasix.

The programming isn't a side mode, you need it to get through the story. Writing a brute-forcer to get into a board, a timer stopper for a secured server, cracking copy protection on games and then actually playing them. It's set in an alternate 1989 where Japan became the American Pacifica Isles, and it's retro-cyberpunk with dial-up, cassette software and pirate radio.

Out April 2027. Glad to share some of the instruction set if anyone's curious.

AI disclosure: I’m building Glyphis_IO BBS: The Proxy Tapes with custom-built engines, traditional creative software and AI tools. The game includes AI-generated and assisted artwork, ElevenLabs voice changing for pirate radio, Suno music and NotebookLM radio-show material, alongside my production and editing in FL Studio. AI also assists with coding our custom BBS, desktop and game systems. All generated content is prepared during development; no generative AI runs during gameplay. For complete transparency, watch my devlogs on YouTube and follow me on social media for daily updates as I build the game.

Using humans: I volunteer on a Games Design course at SGS College in Stroud, and this week I hired my first grad to do QA on the Linux build.

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.