Infinite Languages, One Chain: Expanding Ethereum’s Developer Horizons - Ovidiu Damian | Pi Squared

All right. Uh, hello everyone. Names names Oidu or Damian, whichever is easier for you to pronounce. And I'm glad to be here and represent some of the cool stuff we have prototype at Pi Squared. And it's very relevant for the ETM community as a whole because it could in theory if we if we would add if we would modify the execution engine of Ethereum using our latest tech that we have that we have developed.

You could in theory add the possibility of adding more programming languages to Ethereum the same way for example you would add the new smart contract. Basically treating programming languages as as an onchain object that you can then use in different things. If that sounds wild or if that sounds like you're you're not sure how that works, we'll we'll get there. But until until we get there, I want to talk a bit about why we have chosen to spend time in doing this and it's a critical pain point in web 3 from our point of view and that is fragmentation. Basically you have fragmentation in different ecosystems in liquidity in assets in UX in everything and especially you have fragmentation in terms of in terms of which developers can code on which chain and basically you have let's say a global community of programmers and a subset of them are web free developers an even smaller subset of them are just Ethereum developers.

And it would be great if we would be able to enable all developers in the whole world to code on Ethereum without having to know specifically Solidity to develop their smart contracts for example. Now our solution to web3 fragmentation is verifiability. And what we mean by this is that we don't have to we believe that we don't have to trust that execution is correct just because it yields the result that we think is correct. We can actually verify this and this is what our thesis is based on. Now the cool thing about verifiability is that first of all it's universal in terms of programming language and program execution.

It's in general uh in general our solution is universal in terms of proof mechanisms and also it's universal in in in the sense of distributed consensus and the security guarantees it offers. But uh let's let's uh let's take a step forward and see more exactly what our stack is and what we're preparing in terms of in terms of a stack that you can use. Now we have three main uh we have three main let's say products that are part of our stack. First of all, we have the verifiable language machine which is the cool thing that I'm mostly presenting today. Uh we have the verifiable settlement layer and the verifiable consensus protocol.

Now regarding the uh regarding the language regarding the language machine, it basically allows you to define programming languages in terms of mathematical definitions. For example, let's say for each let's say let's put it like this. You know that according to the rules of math 2 plus 2 is four. Now if you could define that the programming language has specific mathematical rules and you can do that by using formal semantics and put it on chain and verify it on chain. You could know that you could a execute programming languages onchain on the fly and b know for sure that that execution is correct and nodes can simply check if execution is correct just by checking the execution against the rules of said programming language.

We also have the verifiable settlement layer which is able to generate proofs of execution and settle them on a common layer across ecosystems which think of it think of it like a layer in which you could input let's say blocks from Bitcoin or Ethereum and check that they are correctly executed and then you have on that chain or layer all the informations from Bitcoin and Ethereum. and then use it to maybe do some magic DeFi where you put all the chains together and offer products and uh offer products and yields based on multiple uh based on multiple um chains. We also have the consensus protocol which is a in-house consensus protocol which makes everything let's say scalable parallel basically uh we want to also like revolutionize some things regarding how different chains reach consensus. But going f further what do all of these mean? First of all, first of all, the VLM allows every developer in the world to become a web free developer.

The VSSL makes sure that any app in any language can be verified for correct execution and the the uh the protocol allows us to basically reach consensus on the first two things extremely fast. Now the whole point about this is that as I've explain as I say in the beginning we have a lot of developers in the world. If you look at that circle with all web two developers it's about 39 million. Some of them some of them are web free developers but there's very few of them. Whoever is a developer in web 3 knows that if you are to look at all the developers in the world, it's a very very small subset of developers that are in web 3.

Even less so are coding in solidity. We see that about we have about 9,000 solid developers in the world or it was it was so around 2023 when I took this data. So this makes development slower because we don't have enough manpower. What if we could expand? And this is what it's all about.

And so because we have this possibility, the question is not why, the question is why not yet. And what I mean by this is the following. currently or why this hasn't happened yet is because each programming language is extremely complicated to run. You want to run C well you have to interpret it, compile it, you have to verify it and so on. This is extremely complicated.

You have to have a system that does this and is mostly able to do just this because it would add too much complexity and it nodes would need too much computational power to do more than this. Same for Java, Python, Rust or EVM. EVM nodes only execute EVM at the current time because making them also execute for example Solana byte code would be a huge hurdle. Now we have the barriers that we're also showing in in how complicated it is. We're showing it in in this graph.

But updating those tools, training developers to use these tools and also developing these tools for new and new languages that appear is complicated and it's complicated both from a human point of view and from a machine point of view. Now the way in which we solve this is by using a secret sauce which is K which is an open-source framework developed by developed by our CEO while uh while he was working at NASA uh which basically allows one to use formal semantics to define a programming language as a set of mathematical rules. rules. Basically, if you use K for execution and for defining programming languages, you don't have all those complications regarding languages. Any language can be defined as a set of rules and if you have that set of rules, you can on the fly generate all the tools for that language.

Basically, this means that if a machine simply knows how to interpret those uh those rules, it can run any programming language as long as the rules of that programming language are written correctly. And to go more concrete, here's an example of a complete formal semantics for a programming language. Even if it looks complicated for you, it's just because you haven't seen this before. This is a madeup programming language called simple. And this is basically what university students can do by themselves after one laboratory of learning K.

It's a very simple programming language as you would expect. You can like define some numbers and you can add them up and so on. And you can you can basically see different rules like rule I1 at row 28 you can see rule I1 plus I2 it's basically an integer addition and so on. The point the point with all this is that uh just by having this written correctly if I have the right software I can run this programming language and let's say that at some point I find some sort of bug in this uh in this uh in this code I haven't written the language correctly. Well, you can simply add the new definition onchain to be used by whoever wants to use it.

Some might choose to keep the old version if they want to. The same way not all node providers upgrade upgrade at the same time their nodes to uh to the latest EVM versions. Now this is um this is I say the way in which we change we plan to change the paradigm. Instead of having just some EVM execution layer that executes EVM, we want to change it so that we have an execution layer that takes programming language definitions and executes them on the fly. Meaning that EVM would become just the definition of a programming language on chain and can be executed along with many other languages Python, Java, C, C++, C, uh, TypeScript and so on.

And basically why this is cool is that we can if we add this to the the code of an EVM node then we can revolutionize what gets executed on Ethereum. But you might say well yes but what's the chance of actually convincing the Ethereum core team to do this? And in I'm saying there's a chance because Ethereum always wants to stay on top. But at the same time, even if let's say we don't do that, that's where we come in with proof of proof, which is where our name of the company comes from, which is Piqu. By proof of proof, we mean that we have a zero knowledge proof of a mathematical proof.

Let me explain that. This is the this is as following that mathematical proof is generated after the execution of some code. If you want to execute that an integer a and an integer b equals a uh and you sum them up and they they result in seven if they have some specific values. This at execution also generates a mathematical proof that can be checked. And our point is that if we have a separate layer, if you have like a layer zero that can execute any code, then what we can do is that we can send the result of set code and the proof of that result to the layer one.

For example, you could ask, okay, what's 3+4 in Python on Ethereum? we could execute it on our chain and then send the proof back to you. The only issue with this is the following. The ma mathematical proofs are huge. They're they take lots of uh storage space.

So we won't want to send all of it on the on the next chain. So what we're doing is that we're packing that up into a ZK proof and sending it to the chain. So it can still be uh checked by different ZK uh by different ZK checkers. And this is how even by ourselves without convincing someone to adopt all our technology can basically uh say so revolutionize the way in which computation works on blockchains because you could have without without changing anything to Ethereum you could have the results of Python code of Java code of so on on Ethereum and the way it works is as following. So we have a programming language which we have defined which looks kind of like this.

From that programming language we are able to generate an to generate an interpreter. That interpreter gets a program. It can be a D5 program. It can be a random number generator. It can be anything.

And based on based on that program and the obviously the execution environment with different variables and so on, it can generate proof hints and based on those based on those proof hints basically execution traces the the initial and final state and so on we can have a math proof generator which is then able to be checked by some zk. Now the the whole point with this is all of this is feels complicated but is packaged in a in a black box and for anybody that doesn't care about details of this they can just use easily use our tech to leverage whatever programming language they want to run onchain and have that result then on other chains. Now, here's where we stood at in at the end of February. And I'm going to explain why it's just for February and not more recent. So, what we wanted to do is improve case speed by 1,00% to match ad hoc implementations such as GIF.

This is because if you talk with anybody that's passionate about formal semantics, they will tell you that generally sure you have mathematical proof for execution and so on, but it's slower. Well, we wanted to make it we want to make it faster and were able to do it and we even have K execution on EVM semantics that was 58% faster than GF. We also we also wanted to have a proof of proof proof of concept that uh that is able to generate maps and use offtheshelf ZK VMs. We were we were able to do it. We used seven different ZK VMs.

We benchmarked it with uh the Ethereum tests. All was good. We also wanted to have a VSSL proof of concept with Ethereum claims and integration with Ethereum. And thus we also were able to get do that by having the VSSL the VSSL demo with integration with worhhole wormhole and the pod protocol. But uh we also had the VLM demo which uh which can be seen on our which can be seen on our website.

At the end of the presentation, which is basically the next slide, I'll have some QRS that take you there. And you can basically see how in the VLM demo, you can just take the definition of Rust, add it on chain, and then after it's added, you can write a smart contract in Rust and put it on chain and it works. For anyone that's curious about how the execution layer is modified to do that, uh you can find me around here afterwards so we don't get into too complicated details. But uh until then, uh we're getting close to the end. So I have two more things to two more things to tell you.

First is the fact that obviously you can follow us on X or Twitter, however we want to call it. And second is that you can go to our developer portal and see all our demos that we currently have available. But there's one more thing that I feel like is very very relevant for you to know is the fact that if you go on X, our first pin post there is a form that allows you to sign up for our DevNet which is going to get launched very very soon. Our devet is is a devet of the VSSL which the VSSL is basically is let's call it an asynchronous chain where you'll have different examples on how to access data from the Bitcoin network on our chain from Ethereum to do things combining them on how you can integrate uh on how you can integrate um on how you can integrate AI agents and so on. We've we have prepared lots of things, but basically if you sign up for our DevNet and play around, you might even get some cool rewards.

Who knows? But the point is the tech is there. You'll be able to play with it. And that was it from me in terms of presentation. So now if you've got any type of any type of question, I'm all here for it.

Okay, if not, I suppose that's it. Thank you so much for your for your attention. It was a pleasure and see you around. Uh if any question comes up to any of you regarding this, I'll I'll be I'll be here. Uh and you you can find me around.

If you see a pi squared shirt, uh, you you'll know it's either me or my colleague David. Thank you.