Bitgrid

I've come up with an architecture[1,2] that I think could be quite useful. But I've been stuck on how to actually compile "code" for it for far too long. (Decades, actually) It's my hobby horse, and I want to ride it before I die. I need to take expressions, or programs, and break them down to a directed acyclic graph of binary logical operations. In the end.... a cell has 4 inputs, and needs 4 outputs for each possible combination, a total of 64 bits (or 16 nibbles). Heck, I'd settle for a good way to express said tree in a plain text file as a kick start. [1] https://esolangs.org/wiki/Bitgrid [2] https://github.com/mikewarot/Bitgrid

BitGrid is my hobby horse. It's a Cartesian grid of cells with 4 bit in, 4 bit out, LUTs (look up tables), latched in alternating phases to eliminate race conditions. It's the response to the observation that most of the transistors in a computer are idle at any given instant. There are a full rabbit hole worth of advantages to this architecture once you really dig into it. Description https://esolangs.org/wiki/Bitgrid Emulator https://github.com/mikewarot/Bitgrid

Sometime in the next year, I finally get some other human interested in the BitGrid architecture[1] as a general purpose compute platform. It's an FPGA without the hassle (sorta). That helps me get out of analysis paralysis, and make a better case for the architecture. Over the next few years, people figure out how to best impedance match it with the execution of AI workloads, and we're off to the races.... all those high speed transistors no longer have to sit around waiting for their turn to take part in executing code, and things get much, much faster. But first... I need something more than a Pascal based emulator for the BitGrid, with no meaningful I/O.[2] Maybe if I implement it as a blueprint in Factorio? [1] https://esolangs.org/wiki/Bitgrid [2] https://github.com/mikewarot/Bitgrid

I'm talking about a Turing complete, general purpose architecture.[1] One with some seemingly stupid choices that turn out to work well. A cartesian grid of look up tables (LUTs) with latches, clocked in alternating phases. This slows things down, and makes it completely deterministic, and very easy to reason about. There are no race conditions to worry about. Like an excel spreadsheet, it's very easy to see all of the dependencies, and circular references aren't possible in the traditional sense, because of that delay. I'm stuck in analysis paralysis... or I'd have more than an emulator[2] to show you. In theory, you can take any expression that can be broken down to a directed graph of binary logical expressions, and compile it into the "program" for the BitGrid. Because the grid is homogeneous, you can shift or rotate, or flip it to m

I'm trying to impedance match my BitGrid [1] idea to the real world. I've got a simulator that runs at a reasonable speed.[2] I'm now stuck in analysis paralysis, trying to get to the next steps. How would I interface it to external hardware How to represent the values of the look up tables, etc. I think it represents a new class of Turing machine. One that could be scaled to Exaflops of performance without much effort. Distributed bitgrids should be an easy way to extract sufficient horsepower out of even a Raspberry Pi pico, if you have enough of them. [1] https://esolangs.org/wiki/Bitgrid [2] https://github.com/mikewarot/Bitgrid