Would probably be slower but doable, fun mod for the future!

Circuit Artist is a game about drawing digital circuits as pixel art — like MS Paint, but pixels are wires and little triangles are NANDs. Hit play and the simulation runs in real time. It's fully white-box: every wire's state is visible.

I launched it last year with a unit-delay simulation that ran until convergence on each update. It worked, but I realized it had some fundamental problems:

(i) It hid what was actually happening. Players couldn't tell the difference between a ripple carry adder and a look-ahead adder — everything just resolved instantly.

(ii) Design bugs became "game bugs." When players had non-converging wires (like A = not(A)), the game couldn't explain why or where the error was.

(iii) Layout didn't matter. A NAND on one side of the map would instantly propagate to the opposite side, making spatial decisions meaningless. Unit delay probably works better for schematic-based simulators like Logisim, not a layout-focused game like this.

(iv) Propagation visualization couldn't be added on top of the unit-delay engine — there was no notion of direction or distance.

So I rebuilt the engine with variable-delay event-based simulation using an adaptation of Elmore delay. The delay for each wire depends on distance and fanout — longer wires are slower, higher fanout adds delay, branching wires are faster.

For the implementation: I compute Elmore delay over wire trees. Each pixel has resistance and capacitance, with NAND inputs as nodes to account for fanout. For non-tree wire graphs, I build a Dijkstra-based spanning tree (driver as root) and interpolate for edges outside the tree. I calculate the delay for each node and project it back to the image so every pixel has a distance.

This lets me animate propagation with a glow effect during simulation. The shader knows when each wire was triggered, the current time, and the Elmore distance of each pixel, so it resolves state per-pixel in real time.

On top of that:

- Time rewind: the simulation is now delta-based, so players can freeze and scrub backwards to debug. Super useful for cyclic circuits.

- Layers: since timing matters now, I added up to 3 layers. NANDs only go on the bottom layer, upper layers propagate faster (lower capacitance). Lets you route wires above dense NAND areas.

The game has a campaign for learning from scratch, though it's still incomplete and in progress. I'm working toward Steam Workshop support so people can create their own campaigns to teach different concepts or cover more advanced topics.

GitHub (full source): https://github.com/lets-all-be-stupid-forever/circuit-artist

Steam: https://store.steampowered.com/app/3139580/Circuit_Artist/

Comments URL: https://news.ycombinator.com/item?id=46445412

Points: 135

# Comments: 19

The game is open source and available in full in Github and on Steam:

https://github.com/lets-all-be-stupid-forever/circuit-artist

https://store.steampowered.com/app/3139580/Circuit_Artist/

More info on the github page, thanks.

Comments URL: https://news.ycombinator.com/item?id=46398495

Points: 4

# Comments: 3

The circuit is just an image. The primitives are (i) connected wires which have undefined, 0 or 1 state during simulation (displayed brighter or darker in function of the state) and (ii) NANDs, which are little pixel triangles. During simulation the user can interact with any wire by clicking on it, toggling its state, which is cool for messing around when learning. The simulation uses a unit-delay event driven algorithm.

Then, on top of that there are little wire interfaces on the left side of the image that communicate with an external system. This external system is defined in lua and is simulated together with the main circuit (they alternate until convergence). By default there's a sandbox mode with a clock and a power-on-reset signal. The user can choose other "levels", where the API change and there are some problems to solve, from finding if a number is multiple of 3 to solving hanoi tower to finding if a number is prime. The idea is that if the user want to learn but not sure what to do they can try to solve these puzzles, or they can change the lua scripts to add their own stuff/interface for a custom project.

I've also included a small wiki (circuitopedia) with some basic digital concepts to guide those who are new or are a bit rusty. It's not super detailed but I guess it can at the very least present the concepts so the user can dig further on more serious material if they want to.

I developed the game in C with raylib, with scripting in lua/luajit. I've put the game on steam (for windows) and released the source code on github under GPLv3. There's also a web demo version on itch.io, even though it's a bit laggy: https://lets-all-be-stupid-foreva.itch.io/circuit-artist-dem... .

Feedback is appreciated!

Comments URL: https://news.ycombinator.com/item?id=41543642

Points: 139

# Comments: 14