What Is IrysVM?

IrysVM is the smart contract execution environment that runs on Irys, the programmable datachain. It is an Ethereum Virtual Machine (EVM)-compatible runtime that extends the standard EVM with precompiles letting smart contracts read stored data on the chain as input parameters during their own execution. Solidity smart contracts deploy on IrysVM the same way they deploy on Ethereum, and existing Ethereum tooling such as Hardhat, Foundry, and MetaMask works without modification.

The core property that makes IrysVM different from a vanilla EVM is the precompile for stored data access. A smart contract can call the precompile to stream stored bytes from the Irys protocol into the execution environment, without bridging through an oracle or a separate retrieval service. This is the abstraction that makes a datachain programmable.

What makes IrysVM different from the EVM

EVM-compatible means Solidity smart contracts written for Ethereum deploy and run on IrysVM with no code changes. The Ethereum gas model, the opcode set, the ABI, and the standard tooling all carry over. What changes is what smart contracts can do once they are running.

A vanilla EVM smart contract has access to onchain storage limited to what it has written to its own storage slots, plus the public state of other smart contracts. To use large data items or files, the smart contract has to fetch them through an oracle, a retrieval service, or by trusting an off-chain signed message.

On IrysVM, the smart contract has an additional read path. A precompile streams stored data from Irys's storage layer directly into the smart contract's execution context. The data is identified by its transaction ID on the chain; the smart contract specifies a byte range; the precompile returns those bytes. The smart contract treats them as input parameters that the protocol has already verified.

The practical change: applications can be designed around large or shared onchain data without leaving the smart contract execution environment to fetch it. Storage and smart contract execution live in the same protocol.

How the precompile works

The precompile interface is exposed through a Solidity library called ProgrammableData. A smart contract that needs to read stored data inherits from this library and calls methods like readBytes() to pull bytes into execution. The Irys whitepaper describes IrysVM as a runtime that "extends the EVM with precompiles that stream chunk ranges into contracts."

The reference to the stored data is built client-side, before the transaction is submitted. The application uses the Irys client SDK to construct an access list: a transaction ID (the onchain identifier of the data) plus a byte range, specified as a start offset and a length. The access list rides along with the transaction calling the smart contract, and IrysVM uses it to fetch the specific chunks the precompile call needs.

When the smart contract calls readBytes(), the precompile streams the requested bytes from Irys's storage layer into the smart contract's execution environment. The bytes arrive as input parameters. From the smart contract's perspective, the data is a verified input the protocol handed it. The smart contract can branch on its contents, enforce rules over it, and write new data back to storage during the same execution.

Because the storage and the execution share the same chain, the smart contract's trust assumption stays inside one protocol. There is no separate trust assumption for the data itself.

For implementation details and code-level walkthroughs, see the Programmable Data quickstart in the Irys docs.

EVM compatibility in practice

For a developer migrating from Ethereum, the practical implications:

Smart contracts. Solidity smart contracts compiled for Ethereum deploy on IrysVM without modification. The same source code, the same compiler output, the same deployment bytecode.

Tooling. Standard Ethereum developer tools work. Hardhat for project structure and tests. Foundry for compilation, testing, and deployment. MetaMask for wallet connection. ethers.js and viem for client libraries. The Ethereum JSON-RPC interface continues to apply.

Gas model. IrysVM uses Ethereum's gas model for smart contract execution. Storage operations on Irys's data layer (the Submit Ledger and Publish Ledger) are priced separately, so writing a large file does not consume execution gas. Both fees are paid in the network's native token, IRYS, in a single fee market.

Differences from Ethereum. The precompile for stored data access is the main new surface. The Submit Ledger and Publish Ledger are the storage-side primitives the smart contract is reading from. The underlying chain runs on Useful Proof of Work, the storage-tied component of Irys's hybrid consensus.

How IrysVM fits into the Irys protocol

IrysVM is one half of the Irys design. The other half is the storage layer: data transactions, the Submit Ledger, and the Publish Ledger. The two halves share the same chain.

When a developer writes data to Irys, it enters through a data transaction, is held in the Submit Ledger for initial validation, and is promoted to the Publish Ledger after meeting promotion requirements. Once in the Publish Ledger, the data's onchain identifier and its bytes are available to IrysVM smart contracts through the precompile.

The same consensus mechanism that secures block production also secures storage. Miners earn rewards for both block production and storage proofs, slashing applies to storage failures, and the chain's economic incentives align around keeping the data available. From IrysVM's perspective, the storage layer is verified state that smart contracts can read.

This integration is what makes Irys a programmable datachain. The storage layer and the execution layer are designed together as one protocol.

IrysVM compared to other smart contract environments

A few comparisons help place IrysVM.

In prose:

vs Vanilla EVM (Ethereum). IrysVM keeps the language, the tooling, and the deployment flow. The change is the addition of the precompile for stored data access. Developers moving from Ethereum get full source-code compatibility.

vs AO (Arweave). AO is a parallel actor-model network for computation that uses Arweave for messaging and storage. Smart contract logic on AO runs as Lua-based actors that pass messages, separate from Arweave's storage layer. IrysVM keeps the smart contract execution model that the EVM ecosystem already runs and adds protocol-level access to stored data through the precompile.

vs FVM (Filecoin). FVM runs Solidity and WASM smart contracts that reference stored data by content identifier (CID). Accessing the underlying bytes during execution typically goes through retrieval from a storage provider. IrysVM exposes stored bytes through a precompile call inside the execution environment.

FAQ

Is IrysVM EVM-compatible?

Yes. IrysVM runs Solidity smart contracts compiled for the EVM, uses the same opcode set and gas model, and exposes the standard Ethereum JSON-RPC interface. Developer tools like Hardhat, Foundry, MetaMask, ethers.js, and viem work without modification. The extension on top of the standard EVM is a precompile that streams stored data on Irys into smart contract execution.

Can I deploy my existing Ethereum smart contracts on IrysVM?

Yes. Solidity smart contracts written for Ethereum deploy on IrysVM with no code changes. The same source code, the same compiler output, the same deployment bytecode. You can deploy an existing smart contract to take advantage of Irys's lower storage costs and consensus-level storage incentives, then extend it later to read stored data through the ProgrammableData precompile.

What tools work with IrysVM?

The standard EVM toolchain: Hardhat for project structure and tests, Foundry for compilation and deployment, ethers.js and viem for client libraries, MetaMask and other Ethereum-compatible wallets, the Ethereum JSON-RPC interface. The Irys client SDK adds programmable data access list construction on top of the standard EVM tooling.

How does IrysVM read stored data?

A smart contract on IrysVM inherits from the ProgrammableData precompile library and calls methods like readBytes() to read stored data. The client builds an access list specifying which transaction ID and byte range the smart contract is reading; this access list rides along with the transaction. When the smart contract calls the precompile, IrysVM streams the requested bytes from Irys's storage layer into the smart contract's execution environment as input parameters.

What smart contract languages does IrysVM support?

IrysVM supports Solidity and any other language that compiles to EVM bytecode. Because IrysVM is EVM-compatible, smart contracts that run on Ethereum run on IrysVM. The Irys client SDK is available in TypeScript for application-side code that constructs transactions and access lists.

IrysVM, in one paragraph

IrysVM is the EVM-compatible smart contract execution environment that runs on Irys, the programmable datachain. It extends the standard EVM with precompiles that let smart contracts read stored data on the chain as input parameters during their own execution. Solidity smart contracts deploy on IrysVM the same way they deploy on Ethereum, and existing Ethereum tooling continues to apply. The change from a vanilla EVM is that smart contracts have an additional read path: a precompile, exposed through the ProgrammableData library and methods like readBytes(), that streams stored bytes from Irys's storage layer into smart contract execution. The result is a smart contract environment where storage and execution live in the same Layer-1.

For implementation details, see the Irys docs and the Programmable Data quickstart.