{"id":18761,"date":"2026-03-28T15:08:35","date_gmt":"2026-03-28T15:08:35","guid":{"rendered":"https:\/\/cryptoted.net\/index.php\/2026\/03\/28\/go-ethereums-jit-evm-ethereum-foundation-blog\/"},"modified":"2026-03-28T15:08:35","modified_gmt":"2026-03-28T15:08:35","slug":"go-ethereums-jit-evm-ethereum-foundation-blog","status":"publish","type":"post","link":"https:\/\/cryptoted.net\/index.php\/2026\/03\/28\/go-ethereums-jit-evm-ethereum-foundation-blog\/","title":{"rendered":"Go Ethereum\u2019s JIT-EVM | Ethereum Foundation Blog"},"content":{"rendered":"


\n<\/p>\n

\n

The Ethereum Virtual machine is kind of different than most other Virtual Machines out there. In my\u00a0previous post<\/a>\u00a0I already explained how it\u2019s used and described some of its characteristics.<\/p>\n

The Ethereum Virtual Machine (EVM) is a simple but powerful, Turing complete 256bit Virtual Machine that allows anyone to execute arbitrary\u00a0EVM Byte Code<\/a>.<\/p><\/blockquote>\n

The go-ethereum project contains two implementations of the EVM. A simple and straightforward\u00a0byte-code VM<\/a>\u00a0and a more sophisticated\u00a0JIT-VM<\/a>. In this post I\u2019m going to explain some of the differences between the two implementations and describe some of the characteristics of the JIT EVM and why it can be so much faster than the byte-code EVM.
\n<\/p>\n

<\/g><\/svg><\/a>Go-ethereum\u2019s Byte Code Virtual Machine<\/h3>\n

The EVM\u2019s internals are pretty simple; it has a single run loop which will attempt to execute the instruction at the current\u00a0Program Counter (PC<\/em>\u00a0in short). Within this loop the\u00a0Gas<\/em>\u00a0is calculated for each instruction, memory is expanded if necessary and executes the instruction if the preamble succeeds. This will continue on until the VM either finishes gracefully or returns with an error by throwing an exception (e.g.\u00a0out-of-gas<\/em>).<\/p>\n

\n
for<\/span> <\/span>op<\/span> <\/span>=<\/span> contract<\/span>[<\/span>pc<\/span>]<\/span> <\/span>{<\/span><\/code><\/pre>\n
    <\/span>if<\/span> <\/span>!<\/span>sufficientGas<\/span>(<\/span>op<\/span>)<\/span> <\/span>{<\/span><\/code><\/pre>\n
        <\/span>return<\/span> error<\/span>(<\/span>\"insufficient gas for op:\"<\/span>, or<\/span>)<\/span><\/code><\/pre>\n
    <\/span>}<\/span>\n<\/span><\/code><\/pre>\n
    switch <\/span>op<\/span> <\/span>{<\/span><\/code><\/pre>\n
    <\/span>case<\/span> <\/span>..<\/span>.:<\/span><\/code><\/pre>\n
        \/* execute *\/<\/span><\/code><\/pre>\n
    <\/span>case<\/span> RETURN:<\/span><\/code><\/pre>\n
        <\/span>return<\/span> memory<\/span>[<\/span>stack<\/span>[<\/span>-1<\/span>]<\/span>, stack<\/span>[<\/span>-2<\/span>]<\/span>]<\/span><\/code><\/pre>\n
    <\/span>}<\/span><\/code><\/pre>\n
    pc++<\/span><\/code><\/pre>\n
}<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n
At the end of the execution loop the program-counter gets increment to run the next instruction and continues to do so until it has finished.<\/p>\n
The EVM has another way to\u00a0change<\/em>\u00a0the program-counter through something called\u00a0jump<\/em>-instructions (JUMP<\/em>\u00a0&\u00a0JUMPI).\u00a0<\/em>Instead of letting the program-counter increment (pc++) the EVM can also jump to arbitrary positions in the contract code. The EVM knows two jump instructions, a normal jump that reads as \u201cjump to position X<\/em>\u201d and a conditional jump that read as \u201cjump to position X if condition Y is true<\/em>\u201d. When either such a jump occurs it must always land on a\u00a0jump-destination<\/em>. If the program lands on an instruction other than a jump destination the program fails\u200a\u2014\u200ain other words, for a jump to be valid it must always be followed by a jump-destination instruction if the condition yielded true.<\/p>\n
Prior to running any Ethereum program the EVM iterates over the code and finds all possible jump-destinations, it then puts them in a map that can be referenced by the program-counter to find them. Each and every time the EVM encounters a jump-instructions the jump validity is checked.<\/p>\n
As you can see the executing code is relatively easy and simply interpreted by the byte-code VM, we may conclude even that through its sheer simplicity it\u2019s actually pretty dumb.<\/p>\n
<\/g><\/svg><\/a>Welcome JIT VM<\/h3>\n
The JIT-EVM takes a different approach to running EVM byte-code and is by definition\u00a0initially<\/em>\u00a0slower than the byte-code VM. Before the VM can run any code it must first\u00a0compile<\/em>\u00a0the byte-code in to components that can be understood by the JIT VM.<\/p>\n
The initialisation- and execution procedure is done in 3-steps:<\/p>\n
    \n
  1. We check whether there\u2019s a JIT program ready to be run using the hash of the code\u200a\u2014\u200aH(C)<\/em>\u00a0is used as an identifier to identify the program;<\/li>\n
  2. if a program was found we run the program and return the result;<\/li>\n
  3. if no program was found we run the byte-code\u00a0and<\/em>\u00a0we compile a JIT program in the background.<\/li>\n<\/ol>\n
    Initially I tried to check whether the JIT program had finished compiling and move the execution over to the JIT\u200a\u2014\u200athis all happened during runtime in the same loop using Go\u2019s\u00a0atomic<\/em>\u00a0package\u200a\u2014\u200aunfortunately it turned out to be slower than letting the byte-code VM run and use the JIT program for every sequential call after the compilation of the program had finished.<\/p>\n
    By compiling the byte-code in to logical pieces the JIT has the ability to analyse the code more precisely and optimise where and whenever necessary.<\/p>\n
    For example an incredible simple optimisation that I did was compiling several\u00a0push<\/em>\u00a0operation in to a single instruction. Let\u2019s take the\u00a0CALL\u00a0<\/em>instruction; call requires 7 push instructions\u200a\u2014\u200ai.e. gas, address, value, input-offset, input-size, return-offset and return-size\u200a\u2014\u200aprior to executing it, and what I did instead of looping through these 7 instructions, executing them one by one, I\u2019ve optimised this away by taking the 7 instructions and append the 7 values in to a single slice. Now, whenever the\u00a0start<\/em>\u00a0of the 7 push instructions is executed, it instead executes the one optimised instruction by immediately appending the static slice to the VM stack. Now of course this only works for static values (i.e.\u00a0push 0x10),<\/em>\u00a0but these are present in the code quite a lot.<\/p>\n
    I\u2019ve also optimised the\u00a0static jump\u00a0<\/em>instructions. Static jumps are jumps who always jump to the same position (i.e.\u00a0push 0x1, jump<\/em>) and never change under any circumstance. By determining which jumps are static we can pre-check whether a jump is valid and lies within the bounds of the contract and if so we create a new instructions that replaces both the\u00a0push<\/em>\u00a0and\u00a0jump<\/em>instruction and is flagged as\u00a0valid<\/em>. This prevents the VM from having to do two instructions and it prevents it from having to check whether the jump is valid and doing an expensive hash-map lookup for valid jump position.<\/p>\n
    <\/g><\/svg><\/a>Next steps<\/h4>\n
    Full stack and memory analysis would also fit nicely in this model where large chunks of code could fit in to single instructions. Further I\u2019d like to add\u00a0symbolic-execution<\/a>\u00a0and turn the JIT in to a proper JIT-VM. I think this would be a logical next step once programs get large enough to take advantage of these optimisations.<\/p>\n
    <\/g><\/svg><\/a>Conclusion<\/h3>\n
    O<\/span>ur JIT-VM is a whole lot smarter than the byte-code VM, but is far from being completely done (if ever). There are many more clever tricks we could add with this structure, but simply aren\u2019t realistic for the moment. The runtime is within the bounds of being \u201creasonable\u201d speedy. May the need arise to further optimise the VM we have the tools to do so.<\/p>\n
    <\/g><\/svg><\/a>Further code-reading<\/h4>\n
    Cross posted from –\u00a0https:\/\/medium.com\/@jeff.ethereum\/go-ethereums-jit-evm-27ef88277520#.1ed9lj7dz<\/p><\/div>\n

    \n
    Source link <\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
    The Ethereum Virtual machine is kind of different than most other Virtual Machines out there. In my\u00a0previous post\u00a0I already explained how it\u2019s used and described some of its characteristics. The Ethereum Virtual Machine (EVM) is a simple but powerful, Turing complete 256bit Virtual Machine that allows anyone to execute arbitrary\u00a0EVM Byte Code. The go-ethereum project […]<\/p>\n","protected":false},"author":6,"featured_media":18498,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"tdm_status":"","tdm_grid_status":"","footnotes":""},"categories":[24],"tags":[],"kronos_expire_date":[],"class_list":["post-18761","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ethereum"],"_links":{"self":[{"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/posts\/18761","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/comments?post=18761"}],"version-history":[{"count":0,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/posts\/18761\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/media\/18498"}],"wp:attachment":[{"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/media?parent=18761"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/categories?post=18761"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/tags?post=18761"},{"taxonomy":"kronos_expire_date","embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/kronos_expire_date?post=18761"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}