 The T2 Tile project is about a different way to compute, still using digital hardware using all of the manufacturing and sort of low level and gate chips, all of that stuff that were already extremely good at being able to design a manufacturer, but to put a completely different architecture on it. And the important change is giving up on this idea of hardware determinism like that. So the software hardware contract that was made way back when in the beginnings in the 1940s was hardware is going to take the nasty, noisy analog physical world and clean it all up and provide pure bits, pure mathematical reliable bits that everything, step by step every input guaranteed the same output, same program, same input guaranteed to get the same output. It doesn't matter how long it takes the program to run or how much memory the program takes up. As long as it fits in the machine, the answer has to be the same at the end. That is hardware determinism. And you know, it's worth understanding that almost nothing in reality works that way. You ask someone to do something and they say, oh, yeah, sure, I'll do it and they don't do it, or they do it, they do it wrong. The world is full of that stuff. In fact, the idea of software being able to just assume that it can write something and on step one of a program, and it can read back again on step 100 billion of the program. And it'll still be exactly the same thing is remarkable. And that's part and parcel of the power of traditional digital computing. The problem is, it's too amazing. It doesn't actually scale up. And we're all in this trap. Everybody who's a computer person anyway, almost everybody is in the computer person is in this trap of, you know, making excuses and saying, oh, yes, it is, yes, it is. But in fact, it really isn't. I've had lots of arguments with people about lots of discussions, because I'm coming out of that same tradition. I'm coming out of hardware reliability is a hardware problem. Software's focus is on correctness and efficiency. But we have to get beyond that if we're going to get to the better, more powerful and safer world of computing. So hardware determinism doesn't scale, and it isn't safe. I'm not going to spend a lot of time going through the reasons for that right now. But the alternative is, is, you know, you say, okay, well, I'll make a computer that allows a little bit of errors, and I'll build some sort of software redundancy, you know, like that. Well, you can do that. And there are people who've done it. And there's a fields full of papers, research papers that are doing that kind of thing, sort of little piecemeal step away from hardware determinism, and tolerate a little bit of failure, or even deliberately give up on a certain amount of accuracy to try to do something faster, use less energy, that sort of thing. What I say we need to do with the heart and soul of the T2 tile project is we need a different assumption to take as our core assumption instead of hardware determinism, rather than staying right where we've been and taking little teeny steps away. We need to say, what should we be heading for? And that will allow us to reinvent all of the stuff that we've just sort of left the way it is on behalf of hardware determinism. And what I came up with was this idea of indefinite scalability, we should build a computer, we should build a computer architecture that will scale indefinitely, you can add more and add more, you use it before you build it. There's no notion of a sort of global boot time to turn on the whole machine, because it's too big. The thing is running your ad you're using adding more stuff to it and it's always failing. If you can begin with an architecture that is indefinitely scalable, then that will force a whole bunch of issues that we sweep under the table about software taking care of robustness as well as efficiency and correctness, and so on. And what I say is, and I'm pretty well convinced of this at this point, is that when you embrace indefinite scalability, so we build a computer architecture that can go from here to Pluto, the way software is going to work, the way computer, the way computations are going to work in this indefinite scalable hardware is going to look much more like living systems, they're going to move to get out of the way, they're going to protect themselves, they're going to heal, they're going to reproduce for the same reasons that living systems do, to preserve themselves, to get their jobs done, to occupy available resources. So I'm suggesting that we should put aside virtually all of our intuitions, all of the stuff that we lean on when we do traditional programming, software engineering, and so forth, and do a whole new start. Why would anybody do that? As Carl Sagan said, extraordinary claims demand extraordinary evidence. So the project is, well, heck, let's come up with the extraordinary evidence. Let's just build it. The way you can build an indefinite scalable machine is by making an individual little tile of computing that can plug together with more and more of its own kind. And there's no absolute address, there's no serial number, there's nothing unique about them, they're like grains of sand that you can pack together and make a bigger and bigger and bigger sheet of these things. And, you know, in the future we can hope that it'll all be optimized and these individual tiles will be microscopic and, you know, you might be able to repair your computer by just sort of scooping stuff out of a different machine and packing it into the thing that you need. Who knows. But for now, for a demo, for research to show the idea, say, we'll just take some cheap Linux board, something like a Raspberry Pi. Now, in the end, we've picked a board and it's not the Raspberry Pi but we'll get to it. Build a custom circuit board to mount the thing on that sort of remaps the IO pins in a way so that the tile, this individual little computing thing, can connect to copies of itself just to the nearest neighbors, you know, east and west and so forth. Maybe stick on some kind of little display so we can see what's going on. But the hardware itself is just a step in a larger program. The point is to build, you know, a table top full of 100 of these tiles or more and actually start being able to use that as a computational resource to build a new kind of software that follows this living computation thing. That's the plan.