Second building that client trained our developers to understand how the Ethereum ecosystem worked. They literally started from nothing, just from the IELE paper and from the documentation and wrote 100% new code in Scala, so that exercise was incredibly valuable, creating a knowledge transfer and bridging the skill gap so that we understood where Ethereum is at and all the things it could do and all the things it couldn’t do. It's easy to be overly academic or to kind of throw the baby out with the bathwater...

You can do that with a control layer and that's what the second layer of our system is and what we've already demonstrated in practice with K-EVM and the IELE testnets. So when our sidechains protocol comes out, if your system is compliant with that protocol, people will be able to move ADA back into your system and out of your system and you'll be able to move your token in your system, to our system and back.

There's not a master slave relationship. It's a firewall relationship, meaning that it's easy to move assets to and from. On the 1st generation of sidechains we launch, will be custom tailored for K-EVM and IELE, as this is for interoperability with those smart contract paradigms, but later versions will include more generalities, so we can wire our system together with things like ETC and Ethereum and future versions of other protocols or potentially even Bitcoin, depending upon where their upgrade path sits and your cryptocurrency as well, just follow an open standard.

So this is a kind of a butchered simplification of the concept, but it is meaningful for us as an ecosystem, because what it effectively means that if we do things in a very careful way with IELE, given that we have the K semantics of IELE. All we will need to do, when semantics based compilation has reached its N??? There is to just simply write the semantics once of a new programming language, and if we ever want to update IELE, we just update the semantics of IELE, but we do not need to update the semantics of any other programming language hypothetically.

The next versions will be on Ouroboros BFT and decoupling of components in preparation for Shelley. And then Shelley testnet next. And then after that, it's basically Shelley. Decentralization. Then very short leader after tackle on the side chains, extended UTXO and yeah, Plutus, Marlowe and then K-EVM and IELE. So lot of stuff is coming soon and long long overdo.

Can you explain the difference between Plutus, Marlowe and IELE and the K-EVM? So, you can break smart contracts and financial transactions into kind of two worlds. There is the world of I am sending some notion of value between one actor or group of actors to a another actor or to another group of actors.

OK, so what IELE in K-EVM are about is about following that model of saying I need some sort of replicated engine that I can deploy code to, and the code is going to run and it's going to run in a security model where the output that I get, I have a high degree of certainty to it's got storage, got network capacity that's some computation.

That's the dapp model. Now why IELE? Well, because K and semantics based computation compilation gives us a path over an arc of time to have the best possible tooling to verify these types of programs are written correctly and also gives us the greatest chance to have interoperability with the largest set of languages Java, C++, C JavaScript, Python, Ruby, Closure....

And if we ever update the virtual machine to IELE version two or version three, you have to update the compilers. Because the semantics auto update with your semantics-based compilation.

So along that same token, it's trivial for me to have K-EVM and IELE running in the same system and then maybe iOS or maybe something else? So if there's a particular competitor who's done some great work and they're getting a lot of adoption, I can bring that into my system.

IELE test nuts out the KVM test.

The IELE test that out, and there's probably maybe only 2-3 months worth of tuning and parameterization that we'd like to do and cleaning, we'd like to do before we'd feel comfortable with the 1.0.

Assuming semantics based compilation and you know case rewrite and K to IELE VM is done and so forth.

IELE ellow is more of a logical refinement of everything that Ethereum was about, and just trying to take an old thing and make it better.

So, we felt it was very important for us to invest money into building from the ground up a completely new client from nothing. So we just took the IELE paper, the documentation we borrowed no code, we brought together a great team of Scala developers. We called them the growth team and we said to have fun, and they spent basically a year constructing at the moment the most concise Ethereum client ever built.

They created IELE, which was based on LLVM, a very successful framework funded by Apple. Steve Jobs himself really likedit. The department chair of the University of Illinois Urbana Champagne was one of the builders. We believe this is a powerful tool. IELE alone would be cool, it's pretty easy to write compilers for IELE, because it's like targeting LLVM, and that's very well understood at the moment by language designers.

Now the really cool thing about this is if you upgrade your base layers. Let's say we come up with IELE 2.0 based upon all the lessons and experiences and magic we've learned from IELE. You only update the semantics of IELE. And you change nothing else in the system and you don't have to update any compiler or anything like that.

So that's really cool. And I think there's some magic there so that's kind of a second bucket. There's nineteen people that are working on that. Some are rebuilding the K framework to make it better based on the 15 years of lessons that RV has learned from it. Some are working on semantics based compilation. Some people are working on IELE, the IELE testnet that's actually going to be launching at the end of the month as the first example of it.

So if we wanted to after the IELE testnet is complete, which would only take a few months, we certainly could have a smart contract layer for Cardano.

OK, that layer would be faster and have more capabilities than Ethereum and would certainly have a kind of a better development experience because we probably could be more clever about the surface languages that target IELE.

So after the IELE testnet that's had some time to run, we'll take a look at where we're at, take a look at where our sidechains protocols are at and then we'll make some form of announcement of when we think we can start linking CL and SL together.

We already have an Ethereum version of CL running. It's been running for over a month and the IELE version will be running at the end of this month, so you know all the things you come to know and love with Ethereum you'll be able to do, and then we'll have some new capabilities that we roll out as well.

But we can install IELE, which is a cardano's virtual machine, into this framework and then deploy a test that so that we can begin testing Plutus and solidity smart contracts on the IELE virtual machine so that we can do things like fine tune the gas model and also clean up a lot of the engineering rough edges.

Currently, they have eight people, and our hope is to more than double the size of that team over an arc of a few months. They have a very rigorous, beautiful work agenda for evolving IELE to make it the finest virtual machine the world's ever seen for smart contracts.