A puzzle programming game about building small neural networks. The inspiration and connection to the theme is the phrase deep learning. The networks didn't end up being very deep in the sense of having many layers, but I think there is quite a bit of depth to the mechanics. Some of the puzzles can be pretty difficult but there is a small surprise if you manage to make it all the way to the end.

Link: https://kaliuresis.itch.io/neuronic-netronics

Controls: * Left click to place nodes, drag nodes, create new links, adjust connection weights

• Right click to delete things

Here are some hints for the first few levels (spoilers, scroll to see) ``` Nodes have a value from -1 to +1. Positive values are displayed as yellow circles growing from the center, negatives are displayed as yellow rings growing inward from the edge

                                                                                                    Links between nodes have a weight from -1 to +1, the node value will be the sum of all the incoming nodes multiplied by the link weight, this values is then clamped to -1 to +1 after all the values are added.

                                                                                                    You can create additional nodes by clicking on an empty region. You can create new links by clicking and dragging near the edge of a node. Slide the white circle along the link to adjust link weights

```

I'm pretty happy with how this turned out. I was slightly worried the mechanics would end up isomorphic to every other game about logic gates, but I think there is a bit of additional depth that differentiates it.

I had an interesting development setup for this. Most of the game code is in hand written Web Assembly, with a tiny bit of javascript just to interface with inputs and outputs. The only part where I cheated was for text rendering, which I didn't feel like making in wasm and is used minimally. Aside from that all of the graphics and audio are handled in wasm, with video and audio buffers directly written to in memory. Despite the self imposed restrictions, I was able to keep a pretty good pace and ended up having a good bit of time for polishing graphics and audio at the end, which I tend to neglect. While this setup was mostly for fun and learning, it did end up having a few advantages, the biggest of which is that changes to the code are reflected almost instantaneously. I wanted to experiment with procedural audio this jam, and web assembly actually ended up being very good for this. I could change numbers in the code to tune things and it was nearly as responsive as a slider, but with much more flexibility. I think the limitations and unfamiliarity also helped me keep from being too ambitious and over-scoping. While I probably won't use raw wasm again for a jam, it was a great learning experience. My main takeaways are how to do web-builds without the bloat of emscripten, and that wasm is a pretty simple format to build custom tooling for. I also think the procedural audio was a huge success, I learned a lot about how to use simple primitives to make creating new sounds and controlling them with game logic fairly fast.