Building a Performant and Modular zkVM Framework With OpenVM | Yi Sun - Axiom

all right hello everyone thanks for joining us for our next talk here super excited to introduce ye Sun founder of axium who's going to be talking to us about open VM so give it up for y awesome yeah so my name's y I'm excited to tell you guys a little bit about open VM which is a modular and performant ZK VM framework so first just for some background um the purpose of open VM is to allow developers to generate zero knowledge proofs and so I thought I'd begin with a summary of what ZK allows you to do so the premise of ZK is that you have aover we're calling Alice here who has a computer program and what ZK allows Alice to do is to make a claim about what the output of that program is on some input um and then there's a verifier named Bob who's skeptical about the claim so Bob doesn't trust Alice and Bob will ask Alice to provide some cryptographic data which is called a proof and the point of ZK is that using the proof alone Bob can verify that Alice actually correctly evaluated the program and gave him the correct output for the program and one special property of ZK is that this can actually work for arbitrary computer programs now to make that real uh recently A New Concept called a ZK virtual machine has been developed and so this is to solve the problem that it's actually very difficult traditionally to use ZK so traditionally how ZK worked is that a Prov would have start with a computer program and then to ZK verify uh execution of that program they would need to translate the program into something called a ZK circuit so a ZK circuit is a system of polinomial equations such that knowing a solution to that system is equivalent to knowing an execution trace of the original program uh here I tried to show it with a quadratic polinomial but in practice these polinomial systems are extremely complicated and very challenging for developers to actually write so the premise of a zkm is to allow developers to directly generate zeron NCH proofs for programs written in normal programming languages like rust and the way that they do that is by splitting the workload of generating a zero knowledge proof into two pieces first um a zvm is a very special circuit that's hyper optimized to verify an interpreter for a virtual machine or an Isa and then when a developer writes a computer program in that virtual machine then the ZK Circuit of the ZK VM is able to verify that that program was correctly interpreted and gives the correct output and so that would imply that the program actually executes to the claimed output uh what this means for developers is that they don't need to know any details about ZK to generate zero knowledge proofs for their programs all they have to do is write in a supported programming language which is then compiled to a binary that's actually run against the zkm so there are a bunch of existing approaches for ZK VMS uh beginning with the earliest ones probably uh which are probably the earliest would be chairo and so in general when considering a ZK virtual machine developers today have to trade off between performance and flexibility uh the core choice they have to make is what what sort of instruction set should be supported by the virtual machine and they roughly have two classes of choices the first is to pick something that's very ZK specific so Cairo and Vita support new isas that were invented specifically for the purpose of being convenient in ZK and so this has a lot of performance advantages which is why the developers of those systems chose this however they have the significant downside that they're not really compatible with standard programming languages and the the Developers of these systems have created new programming languages that developers must rewrite their programs in to use these Z kvms and so obviously that's a pretty big developer experience bottleneck the other option is for developers to use a more traditional Isa uh something like rist 5 or web assembly uh that's already used as a compilation Target for normal programming languages for example RIS 5 is used in open- Source processors and web assembly is very commonly used in the browser the big advantage of this is that it makes it possible for developers to use existing programs written in existing programming languages for example things like rust or go or maybe Z has in the previous talk um but the problem with this is that there can be substantial performance overhead because the um the ZK system is not actually adapted to this existing instruction set architecture uh which is optimized for physical hardware and so existing Z kvms fundamentally require the developer to choose between performance and flex and um flexibility uh for this reason and so the question that we came to while developing open VM was whether we can remove this trade-off and develop a ZK system that balances both and so the answer we came to W would be is to give Developers a choice between them in a more fine grain Way by developing a more modular zkm and so I wanted to now tell you about the solution we've developed which is called open VM um so it's a modular and performance ZK VM where the focus of the architecture is on customization and extensibility and so there are four key features that I want to go through in this talk uh the first is just what open VM does at the developer level um in terms of allowing developers to prove the execution of arbitrary Rush programs then I'll talk about um the modularity property which allows developers to generate proofs for programs in arbitrary isas and finally talk a little bit about what happens behind the scenes to enable this so first what open VM offers for developer is the ability to prove unbounded execution of just standard rust programs so the flow of uh generating a Zer knowledge proof using open VM has three steps uh the first is that developer writes a rust program uh encapsulating the execution they want to verify then they build it through a special open VM build process into a program binary that we are going to verify the execution of then using open VM they can generate some relatively larger ZK proofs using a type of ZK proof system called a ZK St par and finally that proofs those proofs can be recursed to make them amendable for verification on different blockchains uh So currently we support evm verification uh but in the future we're probably going to add support for other blockchains as well so through this process if you start with just a standard rust program you're interested in perhaps something like the state transition function of a rollup then you can use open VM to generate a alge proof for your rollup State transition and settle it on ethereum okay so that's kind of what open VM allows developers to do at a high level but what if you're a more advanced developer and you want a little bit more what we allow uh developers to do is to customize open VM through a concept of VM extensions so what that means is we allow developers to Define their own set of op codes um and add support for them in open VM while ensuring that those OP codes are going to interoperate over common address spaces um so of course we developed a set of default op codes so open VM ships with RIS five recursion elliptic curve cryptography and hashing support uh but our architecture actually allows developers to create a new VM extension um to accelerate performance in their specific use case um and and this ex these extensions could be very program specific and perhaps not relevant for other users of open VM now the design of open vvm is actually extension first so all functionality in the VM is implemented through these extensions including RIS five support and recursion support and so as a consequence of this architecture we actually allow developers to add their own extensions on equal footing with this default set of extensions and one core feature we have is that developers can add extensions without forking or modifying the open VM core repo all they need to do is import open VM as a library okay so now I want to talk a little bit about how the design of open VM actually enables this modularity um so one observation we had when looking at all existing ZK VMS is that the design is actually a little bit skoric to how physical processors in your computer would work uh notably in all existing zvm there is a circuit which is called the CPU circuit and the job of that CPU circuit is to verify that the execution of different op codes is done correctly um so with open VM we've introduced a new way to verify execution which we're calling a no CPU architecture and the core feature is that just that it does not have a CPU circuit instead the execution consistency check is spread out between the circuits for all of the op codes and so what that means is that developers can freely add new OP codes by simply writing ZK constraints in circuits backing the op codes that they're interested in that satisfy certain input and output post and preconditions um and the overall CPU architecture will make sure that the execution consistency involving those OP codes is constrained correctly and so that's what enables us to allow developers to add VM extensions in their own repos without having to Fork the upstream or modify the Upstream finally the pace of development in ZK is pretty fast these days and obviously one extremely important feature of any ZK system is the underlying ZK proof system uh so one concern for any developer using a ZK Sy uh VM or any other ZK infrastructure is just that maybe they choose the wrong proof system and their application is Left Behind and so what with open VM our approach to this is to allow developers to incrementally experiment with new proof systems um now the the the way we enable that is to enable different parts of open VM to use different proof systems uh in contrast to existing systems where if you want to test out a new proof system you pretty much have to rewrite a new zkm from scratch which is takes you know many months of developer time it is not super practical so in our model we're able to take individual components use a new and allegedly better proof system to prove them and then Benchmark the difference between that and the previous proof system that's used by default and so that allows us to incrementally experiment with new proof systems and just incrementally upgrade open VM to use them and ultimately what we want to deliver for developers is a future proof experience for any new developments in ZK uh research is happening very quickly and we believe what developer developers want is a single platform that can continuously keep up with the a state of the art all right so just to give a sense of where we are um we first announced open VM in December right before the holidays uh and we evaluate our performance on the time it takes to verify the execution of a single ethereum main net block uh using uh the re eth node and so today we're using CPU benchmarks uh we're able to prove a main net Block in about 9 Minutes uh a single machine or a little under 3 minutes using multiple machines and as you can see the progression since our release in December has been pretty rapid um in December the single machine proving time was over 40 minutes and the multi machine proving time was around 20 minutes uh so we've come down about 5 to 6X on both numbers since then and the coming months we're going to introduce GPU acceleration and we expect some pretty significant decreases from these numbers from that lastly uh we want to build an open development ecosystem for open VM so I'm one of the founders of axiim but we built open VM in collaboration with uh contributors from scroll as well as some independent uh ZK researchers such as Max gillet and we actually believe that the ultimate zvm framework that's most robust for Developers will have multiple contributing teams that are each using the VM for their own product purposes uh so yeah we're really excited to grow the contributor community in the coming months so if you'd like to learn more about Open VM put a bunch of links on the slide uh we have a very technical developer chat um and if you'd like to um you'd like support in implementing or using open VM for your infrastructure or application uh we have a interest form for axiim at the bottom of the slide uh that's it [Applause]