What is Yul?

Yul is a low-level, stack-based programming language that sits between high-level Solidity code and the Ethereum Virtual Machine (EVM) bytecode. It lets developers write smart-contract logic in a simpler, more portable form that can be compiled to different blockchain runtimes.

Let's break it down

  • Low-level: closer to machine instructions than a language like Solidity, giving more control over how the code runs.
  • Stack-based: uses a data structure called a “stack” where values are pushed and popped, similar to how calculators work.
  • Intermediate language: not the final code that runs on the blockchain, but a step that can be turned into the final bytecode.
  • Portable: the same Yul code can be compiled for the EVM, eWASM, or other virtual machines, making it reusable across platforms.

Why does it matter?

Yul gives developers finer control over gas costs and execution speed, helping to make smart contracts cheaper and more efficient. It also serves as a common language for different blockchain platforms, reducing the need to rewrite code for each one.

Where is it used?

  • Optimizing critical parts of Solidity contracts, such as complex math or loops, to save gas.
  • Writing contracts that need to run on multiple blockchains (EVM-compatible and non-EVM) by compiling the same Yul source.
  • Building custom tooling or libraries that generate low-level code for developers who prefer higher-level languages.
  • Educational examples that teach how the EVM works under the hood.

Good things about it

  • Gas efficiency: allows hand-tuned code that can dramatically lower transaction costs.
  • Cross-platform: one source can target the EVM, eWASM, and other virtual machines.
  • Transparency: developers see exactly what operations are being performed, aiding debugging and security audits.
  • Flexibility: can be used alongside Solidity, letting you replace only the parts that need optimization.
  • Future-proof: as new blockchain runtimes emerge, Yul can be extended to compile to them.

Not-so-good things

  • Steeper learning curve: being low-level, it’s harder for beginners compared to Solidity.
  • Limited tooling: fewer IDE features, debuggers, and libraries than more mature languages.
  • Readability: code can become cryptic quickly, making maintenance tougher.
  • Potential for bugs: manual optimization increases the risk of subtle errors that are hard to detect.