# Introducing Brevity: An Interpreted EVM Language | Jonathan Wolff - Lead ETH Dev Isentropy & More

- Channel: [Ethereum Denver](https://streameth.org/ethereum-denver)
- Date: 2026-03-09
- Duration: 18:03
- Topics: ETHDenver, Crypto, Web3, Blockchain, Event, Conference, ETHDenver 2025, ETHDenver 2024, Bitcoin, Ethereum
- Watch: https://streameth.org/watch/yt-alox5JYcQes
- YouTube: https://www.youtube.com/watch?v=alox5JYcQes

## Description

Brevity is a language, similar in syntax to Solidity, that is compactly transpiled to an EVM transaction and run on a general purpose smart contract, the Brevity Interpreter. Brevity allows anyone perform to arbitrarily complexDeFi workflows in 1 click. It also supports guardrails and metaTxs.

## Transcript

Hello. Hi. Uh, I'm Jonathan Wolf. Uh, I've been an Ethereum dev for about 10 years. I was formerly uh, lead Ethereum at dev at streamer and beacon protocol. And now I'm here presenting my own project, Brevity. um which is remarkably similar or a similar solution to Wayroll that that Colin just prepared. It's a very similar uh technology but I very different under the hood and it it has some different features. So I'll explain that. Um but it's basically a scripting system sort of like shell scripting for the EVM that allows composable DeFi workflows and the goal is to bring this to consumers basically bring oneclick D5 to consumers one click composability and uh so it's a similar motivation. So um DeFi is this new democratized finance system. There all these different ways to earn yields but a lot of the ways are uh a lot of the uh yield bearing uh uh assets and and and and protocols are uh inaccessible to normies who don't know how to use DeFi and and and uh you know these guies. So some some actions require multiple steps. For example, creating like a unis swap liquidity position and some features like flash loans are just completely inaccessible to anyone who doesn't know how to use solidity because you have to uh follow a pretty complex coding pattern with a callback that's in bytes and uh the question is how can consumers easily and safely compose D5 workflows. So so this is brevity. Um it has a uh a console it has a language that's really similar to solidity. It's not solidity but it's made it's meant to be as similar as possible to solidity to bridge the gap and uh it does the it's it's a basically functional fully expressive programming language that fits in call data. So um running atomically is important. So uh the whole script runs in the EVM as one. Uh it either succeeds or reverts. It does support if then statements and conditional branching. It does support variables and sort of normal arithmetic. You can use all the arithmetic that you use in solidity also. So it's a fully expressive language and uh you can for example arb to exchanges and then revert if conditions are not met. If you know if profit is is less than x then revert for example that's expressible in brevity and uh it's easy to add to an existing project. You can clone a brevity interpreter or just uh fork the code and add add it to your existing smart contract. You can also delegate call to a brevity interpreter. That's another way to integrate it. And uh brevity has a composable guey that I'll get to later. So, I'm going to run through some PowerPoint slides, then we'll get to a guey and we'll actually run brevity and do some um flash loans and uh add some liquidity to unis swap. So, uh the fact that it's a scripting language allows you to uh have a a guey with with with steps that compose uh and users can just click on these things and add add and it will generate the code that we saw in the previous slide. So, we we'll get to the guey in a minute. Um the um it's like Colin has a side about multi call also. I have a side about multi call. Okay, it's like multiol but better. So why people ask why is it different from multicol? Uh it's a fully expressive scripting language. It has variables, math, flow control, and then it has some other features like sandboxing. So it has guard rails. It supports metatransactions and it even has metering and some gas savings in certain situations. And I'll get into all these different details, but um it's it's a scripting language that runs in a controlled environment. And um it is the world's easiest flash loan interface. If you've ever done flash loans, you you do a call back with with bytes to uh smart contract. This is how you do it in brevity. Uh you put some directive at the beginning of the script that says that uh Brevity should run the whole script as a call back to a flash loan. And then you just uh you do the the pool manager uh unlock and then uh well it the director does the unlock. You take out some coins, you do something and you return them. And in the part that do stuff, you can just copy and paste code and it'll work. And uh we'll do a flash loan later. We'll just create some money out of nothing. So flash loans for those of you who aren't familiar, you can take out any amount of money from unis swap and a in one transaction uh as long as you return it in the same transaction. Um but the coding pattern is quite difficult because they they ensure that you they call you back and then you then you um you you have to return the money to them. So um the brevity robot that that console that I that I showed you is a typical implementation. I call that the brevity robot. So that's like a personally owned brevity interpreter. It's a cheap contract. It it's uh it supports the clone pattern. Costs like a 100,000 gas to deploy. So a few cents to deploy on mainet. And uh your brevity interpreter holds your tokens and it sort of does your bidding. You type in scripts. You press run and then it just runs it for you and uh it holds your assets and you can remove your assets at will. Um you can put brevity in different configurations. This is the probably the most uh obvious configuration where one person owns a robot and then gives the robot commands and then can take assets off at will. So in the demo that I'll show coming up um each brevity interpreter has like token holdings and you can just pull off the tokens from your own brevity interpreter. Um right so under the hood uh it's a simple scripting language and a general purpose uh interpreter smart contract. So that language that I showed is not solidity. That's a parser. It transpiles that that text that that I showed at the beginning which is the brevity script uh into instructions. The instructions are put on call data. So an important distinction between solidity and brevity is brevity programs live on call data. They're not stored to code. And that's why you can have some gas savings sometimes because writing to code uh is substantially more expensive than storing bytes on call data. Uh it's at least 10 times more expensive. It's about 200 gas per word on code and I think four to 16 in um in call data. And so Brevity can run uh new logic uh without deploying a new smart contract. That's that's an important feature of the language. Um and uh it doesn't replace solidity. So I want to make clear that this is not a uh competitor to solidity. I liken it more to like uh C programs and shell scripts. like you you you write C programs to do you know highly numeric computations or do some unique function and you write the cell the shell script to do the interstitial calls between them and brevity handles that so it handles full logic in between them you can do if uh reverts you can you know store variables do arithmetic on variables and and do flow control and all that and it's to my mind the most general thing you can put in a callback so um if if you're if if you want to put something in call data and many things take callbacks so for example like bridges take callbacks flash loans take callbacks Why not put a brevity script in the callback because it's the most fully functional thing you can you can it's a general purpose um script and um one other thing I'll say about brevity is that it can be configured to work in a sandboxed environment. And I think this is a very important point that you can sandbox your brevity interpreter so that uh it can only make calls out to certain contracts. So, for example, if you're a finance company uh looking to offer brevity as a a service to your customers and you want them to be able to compose um DeFi workflows, you can limit um you can limit them and say that you can't send it out to uh unregistered protocols or unregistered addresses and so forth. So, there's a hook that occurs at every time you do a call in brevity, which is different than writing freehand solidity. That's one risk you'd have with freehand solidity um is that you don't have this sort of uh hook each time you make a call. And um this is where brevity really excels and beats solidity. Um the UX uh it's a really really simple coding. So uh the scripts are typically very short. Could be three or four lines of code. Do this, do that, revert if some conditions are not met. And this is much easily more easily expressable in brevity than it is um with a custom solidity contract. In addition, your brevity interpreter never has to move tokens outside it because it can run everything. So if you had a solidity contract that had some limited functionality, you don't always have to move the tokens in and out of that. and vet the news contracts and so uh writing solidity contracts you know to do um new DeFi operations is not ideal uh but brevity because it's it's sandboxed and very concise is ideal for this and it has guardrails so you know the guardrails are uh a big big part and then the AI integration so I've taught claude code to run to write brevity cla code writes fluent brevity it just read the readme and it understands it immediately because brevity is a fairly simple language uh we'll get into the syntax maybe a little later if we have time I'm going to do a demo and then we'll we'll I'll show you some of the syntax of the language but that that's be getting into the weeds, but um you can just tell cloud CL are cloud code are some exchanges and I'll show you some examples of um of code that that that Claude wrote which is pretty impressive. It one got brevity and two wrote scripts that compile. Uh I haven't made uh millions on it yet but I think you need infrastructure to kind of wait for certain market conditions but to my mind it's the best tool to train AI to do uh DeFi. And um one other thing about brevity is has potential gas savings. So as I mentioned before when you're deploying solidity contracts you're writing them to the code area. it's uh you know 200 gas per word or something and um brevity can can save you get save you money or save gas fees um because uh all the stuff lives in call data. So if you're if you're only using it once if it's a one-off script uh you might as well just use brevity because you you'll actually I have an example on the brevity uh GitHub I'll I'll show at the end it's.com brevity. Um but uh it takes about half the gas to run a an arbitrage in brevity versus deploying a new smart contract in Solidity and running that. So um that's one other advantage and um other features brevity supports metat transactions. So I'm looking to partner with brokerages or people that are consumer focusing looking to offer DeFi to to consumers. Um you can have a brevity interpreter that's where where the owner the interpreter doesn't actually pay the fees for it. So the owner can have only USDC in this thing. Has no way to pay mainet fees. And with these EIP meta metatansactions um you can you can pay for the transactions of another and the metatransactions also allow brevity to run across bridges. So you can send a brevity transaction across a bridge and then bing it just runs on the other side as that person as the owner. Um and uh another part that's kind of cool is the metering. So the fact that it has a hook when it has calls allows you to meter inflow and outflow of your brevity interpreter. So if you're a brokerage offering uh these services to consumers, you can actually uh you know charge a fee or something and take a piece because brevity is has the option to meter and check when when things are going in and out of it uh using this this hook feature. And um I will now go to a live demo and we'll actually start playing with brevity. So if you want to uh play along, you can go to.com/brevity demo. Um, I'll we can talk after if anyone wants a more uh in-depth demo, but uh I'm going to go to my web page and uh show you some actually actual brevity interpreters and we'll do some brevity running. So, um so here's a flash loan. We're going to take out a $1 flash loan and then we're going to announce we uh Brevity has this possibility to uh emit key values. So, you can you can you can basically launch any event in Brevity. You can trigger any event so that your your your output is indexed. But uh it has a convenience method called emit uh key value. So this method uh we'll press compile and hopefully so we get a gas estimate. That's good. It wouldn't show you the gas estimate on the guey if you don't own it. So if you go to my brevity interpreter uh you can't control it because I'm the owner. But if you go to uh brevity demo without the other parts without slashb uh you can create your own. You can just deploy your own on on any any chain. Um and um so I'll press compile and then I'll run the script. and we'll confirm. And we should get a $1 flash loan. That's so it's going to take out a $1 flash loan. Then it's going to trigger some event that says, "Hey, uh I I have the flash loan." It's going to emit a key value pair where the where the value is the balance that we had. And then um it will um return the flash loan. So that's succeeded. So we we you know, Uniswap permitted us to do that. And if we view the transaction, we should see a $1 flash loan in there. Um, how do I get the Let me go to either scan and get this. So, cool. We actually see $1 is transferred. You can, by the way, tin this to a million dollars if you want. It'll work. Uh I just didn't want to get flagged for some weird behavior, but uh you know it's just a number in the machine, right? Um and uh another brevity thing that I'll show you is we're going to make a uh unis swap liquidity precision. So um this is a brevity interpreter that already has some ETH in it. So you see that it has some native tokens over here. And uh what I'm going to do is this script um is going to take uh 10% of my ETH. So the from amount is my balance of ETH divided by 10. Then it's going to uh wrap it in W ETH. It's going to uh take half that WET and swap it for USDC and then it's going to do all the approvals um it's going to it's going to do the approvals um for the uh wrapped ETH and USDC and mutable liquidity position. Now if you think about this, this is five clicks. Uh you know a lay person would have a hard time using this. Um you'd have to click several times and uh this is all done atomically and it reverts if conditions are not met. So at the end of the transaction, I'm going to u when you make this unisop 3 liquidity position, it's going to mint a token and I'm going to check that I'm in fact the token owner. So um so let's uh compile and we'll run this script. Why don't they just put you to Ether scan. That's weird. So, here we go. And it did everything that I said it was going to do. It uh it wrapped some ETH for W E. It swapped the ETH. It made a unisoplicity position. And um all this can be obscured obviously from the end user. The end user can just see some guey and it can be composed like that. So um yeah, these are the uh the demos that that I had planned for for for the um the transactions with brevity. And I can get into a little bit of the language. I'm also going to show you um some example brevity scripts that AI wrote which I found pretty impressive. So here here's an AI generated brevity script. Um Claude Code wrote that and it works. Um so uh you you can read what it's doing and uh and uh cloud code will look for arbitrage opportunities and then uh you just press run and uh if if if it runs then maybe you made money. You can also have it revert if it doesn't make money. So that means that if it did actually run then you necessarily made money. Um and just to go over the syntax uh I'll go over the readme in a minute. Um brevity is is is fairly familiar to any anyone who's programmed. Um there are these prep-processor directives. You know these constants up here. um those are not actually uh seen uh I mean the names of of which are just substituted in basically it's like variable substitution um function selectors the way you call functions in brevity is different than solidity because it I want to make it super compact so I just define function selectors you just type in the function selector you want and that so the next time it sees the symbol approve it knows that approve uh takes an address and and a unit 256 that that's the the function signature of approve and um and then brevity has one variable type the word it's a 32-y word and what I learned uh is that uh so brevity has a lot of like intricacies about the EVM uh under the hood it's a lot of it's an EVM assembly and that the way that that the EVM actually lays out variables is by words anyway so you don't really need anything except one variable type a 32-bit variable type so when you're actually making these function calls uh like this under under here uh everything is just a word even if it's an address or if it's a smaller data type uh internally the EVM is actually representing them as as birds. Um, and uh, so there's a a call with in capital letters does a call that that changes state. Uh, static call um, does not change state. That's like a view function. And then uh, there's basic ifs and things like that. So if this is less than that, revert. Uh, it also has a sense of like goto. You can tag lines um, and then if if this is less than that, go to some marker. So you can do for loops, you can do um, you know, arbitrary branching. um also has a go-to statement obviously, but I want to keep it as bare bones as possible. Um so, um the um that's the essentials of the language. Basically, it's it's uh arithmetic that you're familiar with just like C or or Solidity calls, static calls, ifs, and um and gotos and things like that. And the uh the source code is available on uh GitHub. So, it's entropy/ brevity. Um the readme contains a lot about uh different features that I haven't gone into, but there are a few other features. For example, so because I'm using one word, there's also a a way to work with signed or unsigned arithmetic. Um you can you can use these special directives. And then uh in terms of memory, um it's important point that brevity never actually modifies storage. So it never has any persistent effects on the contract that it's running except for the calls that it makes. It only makes persistent effects through calls. Um it does expose transient storage, but that's kind of a utility for you. Um and it exposes just a simple mem stack. It also doesn't expose any kind of um uh EDM internal except for a memory stack. So if there it's like a function call in C with with one stack frame and uh and one stack you know um and uh it's telling me to pre wrap up. So if anyone's interested I'm happy to discuss this after. Uh I also am looking to form partnerships with with brokerages and consumerf facing um projects also. And uh I think the the kind of use cases for brevity uh just quickly um um consumers, AI finance as I said and Ethereum devs who want to pack the most they can into a callback and uh this is my contact information. Um yeah, please come with questions. I'm interested in promoting usage of this thing in any case but also looking for uh you know partnerships especially with people doing AI finance and uh consumerf facing DeFi. Thank you.