What Is Programmable Data?

Programmable data is data that has been written to Irys, verified by the protocol, and made available as an input to a smart contract during execution. The smart contract can read it, reference it, enforce rules over it, and write new data back to storage in the same execution. The smart contract reads the data as a protocol-verified input from the same chain that holds it.

Irys calls this category a programmable datachain, the next evolution of the datachain category that includes Arweave, Filecoin, and Walrus. Irys defines the programmable variant: a data-first base layer where storage, execution, and verifiability are designed together.

Status note. Programmable Data is currently in development and scheduled to launch in 2026. The sections below describe the design as published in the Irys docs and whitepaper. Check docs.irys.xyz for the latest status and final API shape.

What makes programmable data programmable

Most blockchains can store small amounts of data and run smart contracts, but the two systems sit at arm's length. Onchain storage is expensive, so developers move data off-chain to IPFS, S3, or a separate decentralized storage network and feed it back through an oracle or a fetch call. The smart contract's trust assumption sits in that bridge.

Programmable data closes that gap. The same protocol that holds the bytes also runs the smart contract that reads them. The smart contract sees the data as protocol-verified network state.

Data is the information. Storage is the mechanism that holds it. Programmable data is a property of data: specifically, that smart contracts can use it during their own execution. The storage mechanism remains separate, doing the job of keeping the bytes available and verifiable.

The category ladder for L1s goes: execution chains, then datachains, then programmable datachains. Execution chains optimize for running code and treat storage as a side effect. Datachains treat storage as a primary resource. Programmable datachains add native execution on top, so the stored data becomes usable by the smart contracts running on the same chain.

How programmable data works on Irys

On Irys, storage, verification, and execution all live in one Layer-1 blockchain (L1). IrysVM, an Ethereum Virtual Machine (EVM)-compatible execution environment, exposes a precompile that streams chunks of stored data directly into a running smart contract.

Data enters Irys through a data transaction. It first arrives in the Submit Ledger, where miners storing the data generate ingress proofs confirming receipt and storage responsibility. Once it satisfies promotion requirements, the data moves to the Publish Ledger, and its Merkle root becomes part of network state. From that point on, storage responsibility is subject to ongoing verification: random sampling, partition replicas, and Useful Proof of Work tie miner rewards to honest, available storage.

Solidity smart contracts deploy and run the same way they do on Ethereum. A smart contract inherits from the ProgrammableData precompile library and reads stored bytes through methods like readBytes(). The client-side access list specifies a transaction ID and a byte range (a start offset and a length within the transaction's stored data) before the smart contract calls the precompile. From the smart contract's perspective, the bytes arrive as input parameters that the protocol has already verified. The Irys whitepaper frames the goal precisely: smart contracts that "read and act on onchain bytes at hot-access latency."

Because the data is referenced by its onchain identifier and verified against the Publish Ledger's Merkle root, the smart contract can branch on its contents, enforce rules over it, or write derived state back to storage. The chain holds the data, proves it is still there, and hands it to the smart contract when execution requires it. The protocol that runs the smart contract is the same protocol that verified the data, so the smart contract's entire trust assumption stays inside one system.

Storage fees and execution fees are accounted for separately. Storing a large file does not pay for executing a smart contract that reads it, and vice versa. This separation lets applications hold meaningful volumes of data on Irys without inflating the cost of smart contract execution, and it lets smart contract execution stay independent of the file sizes the smart contract happens to reference.

Both fees are paid in the network's native token (IRYS), in a single fee market. This is different from split-token designs where storage and execution use different tokens. Walrus, for example, prices storage in WAL while execution happens on Sui. On Irys, one token covers both lanes, so applications do not have to manage two fee balances or two issuance schedules.

What programmable data enables

A few concrete patterns show what changes when stored data becomes a usable input to smart contract execution.

AI provenance. A model published to Irys carries verifiable structured metadata: the training set hash, the fine-tuning recipe, the evaluation results. An inference smart contract reads that metadata directly from storage and verifies it against the Publish Ledger before signing off on inference output. The chain itself confirms the model lineage; provenance is enforced by protocol-level verifiability.

DePIN (Decentralized Physical Infrastructure Networks) coordination. Sensor networks generate high-frequency telemetry. With programmable data, telemetry lives on Irys, and a payment smart contract reads the most recent window of measurements when it computes operator rewards. The data source and the payment logic share one protocol. A separate oracle becomes unnecessary because the chain that pays the operator is the same chain that holds the readings the operator submitted.

Autonomous agent smart contracts. An onchain agent makes decisions over time. Each decision and the inputs that produced it are written to Irys. The next time the agent's smart contract executes, it reads its own prior decision history from storage and uses that history as a verified input. The agent's record of itself becomes part of network state.

These examples share one shape. The smart contract reads stored data during its own execution. The data is verified by the protocol that holds it. The smart contract's behavior depends on data that the chain itself can prove.

Programmable data compared to nearby concepts

The table below compares programmable data on Irys to the other ways smart contracts get at data today.

In prose:

Programmable data versus data on a decentralized storage network. Storage networks like IPFS or Arweave hold the bytes. A separate execution chain runs the smart contract. The smart contract talks to the storage network across a bridge or a pinning service. Programmable data removes that bridge by putting storage and execution in the same protocol.

Programmable data versus oracle-fed data. An oracle is an off-protocol service that posts external data onchain on a schedule. The smart contract trusts the oracle. Programmable data is the smart contract reading data the chain already holds and verifies. There is no separate trust assumption for the data itself.

Programmable data versus data availability (DA) layers. A DA layer like Celestia makes blob data retrievable for rollups. It does not give a smart contract a way to read that data as part of its execution. DA solves a different problem.

Where this fits in the bigger picture

Programmable data is the abstraction that makes a programmable datachain different from a generic blockchain. Once data is verified and directly readable by smart contracts on the same protocol, applications can be designed around shared, reusable, verified onchain data. This replaces architectures that stitch together private databases with bridges. The result is a smaller trust surface and an application architecture where multiple smart contracts can read the same verified onchain data.

For a developer, the practical change is in where data lives and what gets to read it. Files that previously had to be staged on S3 or pinned on IPFS, with an oracle or signed message bridging them back to a smart contract, can live on Irys and be read by the smart contract directly. The application's data layer and its execution layer become the same protocol. Verification stops being something the application has to assemble out of independent services and becomes a property of the chain itself.

FAQ

What is the difference between programmable data and stored data?

Stored data sits in storage and waits to be retrieved by an application. Programmable data has been verified by the protocol and is directly readable by a smart contract during that smart contract's execution. Programmable data is data that participates in execution.

How is programmable data different from data stored in an Ethereum smart contract?

Ethereum smart contracts can store data using SSTORE, but each storage slot write is expensive in gas, and large data items are impractical to keep in contract state. Programmable data on Irys uses a separate storage system with its own fee accounting, designed to hold large data items. A smart contract reads that data through a precompile call, separate from the standard EVM storage opcodes.

Do I need to learn a new VM or a new language to use programmable data?

No. IrysVM is EVM-compatible. Solidity smart contracts deploy the same way they do on Ethereum. The new surface is the ProgrammableData precompile that streams stored data into the smart contract. Existing Ethereum tooling, including Hardhat, Foundry, and the broader EVM toolchain, continues to apply.

Is programmable data live yet?

Not yet. Programmable Data is in development and scheduled to launch in 2026. The precompile-based design described above reflects how the feature will work at release. For the latest status and final API shape, check docs.irys.xyz.

What kind of data can I write to Irys?

Any byte stream that fits the DataItem format: files, datasets, model artifacts, sensor records, structured metadata, application records. The smart-contract-facing surface is the same regardless of payload shape, because the precompile reads chunk ranges and the smart contract interprets the bytes. Tutorials and reference examples live in the docs.

Programmable data, in one paragraph

Programmable data is data that has been written to Irys, verified by the protocol, and made available as an input to a smart contract during execution. A precompile in IrysVM streams that data into the running smart contract, which reads it as protocol-verified state and can derive new data that gets written back to storage. Because storage, execution, and verifiability live in the same Layer-1, applications can read shared, verified onchain data directly, and the smart contract's trust assumption stays inside the protocol that already runs it.

For implementation details, read the Programmable Data quickstart, the IrysVM overview, and the ledger architecture write-ups at docs.irys.xyz.