 In the same way, computers, the internet, and smartphones gave us new ways to interact with software. We believe a new era of crypto browsers is about to begin. The Moon project is our attempt at finding the best user experience for Ethereum. OK. OK, this is an example of that on Moon browser. The browser just looks like a normal web browser, but it has three major differences, which are represented by those three buttons on the upper right corner. First, instead of normal accounts and passwords, everything is based on crypto signatures. So first, like on MIST, you can just store your assets here. You can manage them without a bank. But really, nothing of this is new. So let's move on. Yes, this is not really new because MIST does that all right. But imagine if you could fork an application in a single click, not just the front end, not just the interface, not just a video, the entire company in a single click. Imagine if you could fork YouTube in a single click. That's what the fork button above there does. And that's one of the difference we have. So now, if we want to store real money on apps, then we need something else than JavaScript-like languages, which are not enough anymore, really. The dApps need a formal specification, something that states in code, actually, everything the dApp promises to do. Then, if we ask the browser to check on the formal specification, the mathematical proof of that specification, we can be sure that the program does what we expect. In other words, by just checking the first line there, we could have avoided the entire DAO incident. It's one line that if someone just read it, it could have avoided everything that happened two years ago on the DAO fiasco. So this was our vision, but there was a problem. Those are some of the most popular proof languages in the market. For many reasons, some simple are very complex. None of them had everything we needed. Like, we wanted one of those languages to be the JavaScript of our browser, but none of them had it all. Some of them almost did it. But there is one thing none of them had. Performance. There was no language in the world that had high level, that was high level, had formal proofs, and was fast enough for us. So the problem is, if you wanted to compile some of those languages to the EVM, the cost of doing that would be very expensive. A lot of money in our transaction, and then it would not be practical. Yeah, the bad news is that we had to stop our browser development to focus on making our own language. The good news is that it is awesome. So... Better than our presentation. So DevCon, today, the Moon team proudly presents you Formality. Thanks. Formality is a high level functional programming language that features formal proofs that is not garbage collected and that targets the EVM and the GPU. It's the only language in the world that does that. It's simple enough for you to implement it yourself. In other words, if you don't trust our check, you can do, you can implement Formality yourself. And it has the potential to be very fast, which we will explain soon. Thank you. Well, Formality programs have two building blocks. One, inductive data types. They represent data, like natural numbers, like vectors, equality certificates, and two, functions. They represent computations and proofs. So things like doubling the number, like fetching the first element of a vector, or proving the symmetry of a quality. But that's pretty standard on proof language, so we won't spend a lot of time doing this. So let's move on to the fun part. That's how fast Formality is, how fast it can be. Please check this code. It's very simple. It does three things. First, it creates an array with 100 zeros. Then it uses the map function to increment every number by one a million times. And then it outputs the result. It's very simple. How long it takes to run this code in different languages? As you can see, Formality beats every other language, and the difference is huge. This is not a compile-time optimization. This is not some clever trick. This is actually what happens when you run very high-level code on Formality. There is no other language in the world capable of optimizing functional high-level code like it. If you don't believe me, please check your benchmarks on the link below, where we also explain why that's the case. But that's not the whole history. Yeah, let's have a look at this other example. This also does three things. The first thing, it creates a linked list of bits. Then it just flips them over and over about a million times. And then it prints out the result. How fast can this execute? As we see here, Formality is now slower than the rest. It happens because the code is too low-level, so it can't be really optimized. Formality is too an interpreted language, so it can't compete in raw performance with other major compilers. But that's OK. The potential is here. And we'll see why in the next example. So this is the same code. This is the same thing now running on the GPU. So yes, that's true. You can take any Formality program and run it in thousands of cores in parallel with no programmer effort at all. And you can get real speedups with that. So this is something that also no other functional language in the world is capable of doing. You can't compile Haskell either is anything that you think to the GPU. And Formality can do that. We believe that with a sufficiently major compiler, we could beat those languages. So how? How can a high-level language like Formality have no garbage collection? How can it often be faster than Haskell? How can it cheaply target GVM? Or even the GPU. Mathematics. Those are the four axes of Formality. Linear types. Like rows, values can only exist in one place at the same time, making garbage collection unnecessary. Memory is freed when values go out of scope, simple as that. Easy clones. Unlike Rust, values can be cloned with no cost, making linearity much less painful, as we don't need to borrow values. And that's possible because copies are made lazily. Better optimality. Functions are reduced optimally. This allows an insane amount of runtime fusion to happen, breaking down. Bloated high-level code into small, lightweight computations. If a strong confluency. Evaluation is strong confluently, confluent. So the order of execution doesn't change the required work to complete the computation. This allows reductions to take place in any order, even in parallel. So all those things allows Formality to be compiled to a new model of computation called interaction combinators, which combines the best aspects of Turing machines and the Lambda calculus. That's what allows us to run on the GPU to compile to GVM and everything else we presented so far. If that sounds fun to you, and I really think that's very fun, please check the link below, where we explain this model a little bit better. And that's it. Formality turns scientific breakthroughs into a real-world language. So with this, we are closer to building the moon browser as we are originally envisioned. Formality is not officially released yet. There's still a lot of boring work to do. But the fundamental parts are done. And you can check it today on GitHub. OK. So just a last thing. There is a brilliant researcher called Arnold Stump that created a type theory that fits in a single slide. It's that thing you are seeing here. That theory is not only very powerful, more powerful than Agda and Idris and Isabel and other languages, but it's also much, much simpler. And sadly, we don't have enough time to explain how this works today. But this is what will be used by Formality to ensure mathematical consistency, which is something very hard to do in proofing language. And we actually gave a grant for Arnold Stump to make this possible. So we are very thankful to him for that. And that's it. Thank you very much. Sorry about Java.