This site lists neural networks whose weights and programs are stored fully on Ethereum mainnet. Each entry has a contract address and a live check that you can run from this page.
Models that store their files somewhere else, or run somewhere else and only post a proof, do not qualify. Each entry says where the model runs — inside Ethereum, or in your browser.
CENSUS
| MODEL | AUTHOR | YEAR |
|---|---|---|
| 陰XOR陽 | nahiko | 2021 |
| ARAGNATION | Devi Parikh and Abhishek Das | 2023 |
| INCHAINPEPEGAN | lifeonchain | 2023 |
| CONCRETE | Higgs × diid | 2025 |
| I. | ryley-o.eth | 2025 |
| ARTIFICIAL AFTER ALL | Han Saglam | 2026 |
| AUTOMATE ATTENTION | diid | 2026 |
| SLONKS | Blockhash | 2026 |
| HELLO WORLD COMPUTER | Han × 1001 | 2026 |
| THE MARKET IS TALKING | FelixFelixFelix | 2026 |
| remanence | diid | 2026 |
11 entries. Each entry passed the automatic registry checks. Select an entry to run a new live check.
陰XOR陽
NAHIKO
| FIELD | VALUE |
|---|---|
| TYPE | two-layer neural network, 2-2-1 (MLP) |
| SIZE | 3 neurons |
| STORAGE | fixed values in contract storage |
| OUTPUT | the XOR result as one boolean |
| ADDRESS | 0x2A648cb23D3ADf1BB171Fabc0119eA3eb951841f |
| YEAR | 2021 |
Three neurons in two layers compute XOR. The artist minted this work in August 2021 as a one-token NFT. The artist and the collector each set one input. The network turns the two inputs into yin, yang, or a blend. The weights are fixed values in the contract; anyone can read them. isYingYang() runs the model fully inside Ethereum.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
isYingYang() — runs the model on the two stored inputs and returns the XOR output as a bool
Requests go from your browser to public third-party Ethereum servers.
ARAGNATION
DEVI PARIKH AND ABHISHEK DAS
| FIELD | VALUE |
|---|---|
| TYPE | coordinate MLP (CPPN) — 5-32-32-32-32-32-32-3, ReLU |
| SIZE | 5,571 parameters (5,376 weights + 195 biases) |
| STORAGE | data contracts — plain number arrays in 7 locked script chunks on the Art Blocks core |
| OUTPUT | an RGB color per (x, y) coordinate; some works use palette coloring instead |
| ADDRESS | 0x99a9B7c1116f9ceEB1652de04d5969CcE509B069 |
| YEAR | 2023 |
Aragnation draws abstract compositions with a watercolor look. A small neural network learned to map each (x, y) position to a color. Its weights sit as plain numbers inside the project script, in seven locked data chunks on Ethereum. Your browser reads the script from Ethereum and runs it. Some works use palettes instead of the network.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
projectScriptByIndex(401, 3) — reads part 3 of 7 of the onchain program; this part is entirely model-weight numbers
Requests go from your browser to public third-party Ethereum servers.
INCHAINPEPEGAN
LIFEONCHAIN
| FIELD | VALUE |
|---|---|
| TYPE | GAN image generator (DCGAN-style) |
| SIZE | ≈2,900 parameters |
| STORAGE | contract storage; int16 fixed-point |
| TRAINING | trained offchain on pepe images, then written into the contract |
| OUTPUT | three 5×5 frames, built into an animated GIF inside Ethereum |
| ADDRESS | 0x65e9A5BbC1B26C0833B232355534cC404b0e69D4 |
| YEAR | 2023 |
This GAN generator draws animated pepes inside Ethereum. A call to tokenURI() takes three seeds from the token id, runs the network three times, and builds an animated 5×5 GIF from the three frames. The artist trained the weights offchain and wrote them into contract storage. The weights, the network, and the GIF encoder all live at one address. The image exists nowhere else.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
tokenURI(1) — runs the generator three times (one per frame) and builds the animated GIF inside Ethereum
Requests go from your browser to public third-party Ethereum servers.
CONCRETE
HIGGS × DIID
| FIELD | VALUE |
|---|---|
| TYPE | GAN generator, first stage (single upsampling block) |
| SIZE | 79,680 weights |
| STORAGE | data contracts (SSTORE2); int16 fixed-point |
| OUTPUT | 12×8 RGB fingerprint, drawn as an SVG image inside Ethereum |
| ADDRESS | 0x4512759606f9E680361DD76C4c17F92031De7AcD |
| YEAR | 2025 |
The first collection of Higgs, an AI artist that diid built. The contract holds the first stage of the GAN generator; its weights live in data contracts on Ethereum. fingerprintSvg() runs the network inside Ethereum on a 16-byte seed and returns a 12×8 RGB fingerprint as an SVG image. The large display images are offchain; the check here covers only the onchain generator.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
fingerprintSvg(<token #1 seed>) — runs the model inside Ethereum; the call is too large for one public Ethereum server, so checks usually pass with 2 of 3 servers
Requests go from your browser to public third-party Ethereum servers.
I.
RYLEY-O.ETH
| FIELD | VALUE |
|---|---|
| TYPE | conditional VAE-GAN generator (cVAE-GAN) |
| SIZE | 297,859 parameters, quantized to uint8 |
| STORAGE | data contracts — gzip shards in 24 locked contracts, 422,292 bytes total |
| OUTPUT | one 64×64 RGB eye image per token, drawn in the browser |
| ADDRESS | 0x000000A35301Fa5784E820F489003FfcfFdc69a6 |
| YEAR | 2025 |
I. draws 64×64 eyes with human expressions. A small cVAE-GAN generates each image. The full program — inference code and compressed weights — lives in 24 data contracts on Ethereum, locked forever. Your browser reads the program from Ethereum and runs it. No server and no outside library is needed.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
projectScriptByIndex(0, 5) — reads part 5 of 24 of the onchain program; parts 5–18 are the model weights (base64 text)
Requests go from your browser to public third-party Ethereum servers.
ARTIFICIAL AFTER ALL
HAN SAGLAM
| FIELD | VALUE |
|---|---|
| TYPE | compressed decoder network |
| SIZE | 32-number latent, 4 conv layers; one network in each of 256 contracts |
| STORAGE | each contract's own bytecode; int8, Huffman-compressed |
| OUTPUT | 32×32 grayscale image, 1,024 bytes |
| ADDRESS | 0xbDF5A7F5e5AE18eE580139297C63a89fc1d18B5f |
| YEAR | 2026 |
This work is 256 contracts on Ethereum. Each contract holds one seed and one compressed neural network in its own code. A call to artificial() runs the network inside Ethereum and returns a 32×32 grayscale image (1024 bytes). The contract computes the image at call time and stores no image. The address here is one example piece; a factory deployed all 256.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
artificial() — returns a 32×32 image as 1024 pixel bytes (1088 raw bytes with ABI framing)
Requests go from your browser to public third-party Ethereum servers.
AUTOMATE ATTENTION
DIID
| FIELD | VALUE |
|---|---|
| TYPE | 5-layer transformer language model (Llama-style) |
| SIZE | dim 48, hidden 128, 8 heads, 2,048-token vocabulary |
| STORAGE | data contracts; int8 quantized |
| OUTPUT | one aphorism per NFT, drawn as an SVG image inside Ethereum |
| ADDRESS | 0x5F8E7D750E75b44747C058A204D8DEa0D18fA5d3 |
| YEAR | 2026 |
This contract is a complete transformer language model that runs inside Ethereum. Data contracts on Ethereum store its weights. A companion NFT contract calls the model to write one permanent aphorism for each token. The model also draws the text as an SVG image inside Ethereum. The address here is the language model itself.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
logits([1]) — runs the model once and returns int16 scores (logits) for all 2048 vocabulary tokens
Requests go from your browser to public third-party Ethereum servers.
SLONKS
BLOCKHASH
| FIELD | VALUE |
|---|---|
| TYPE | candidate-palette classifier — per-pixel 18-way argmax over learned embeddings |
| SIZE | 203,680 learned int8 values (10,000×10 embeddings + 576×18×10 pixel heads) |
| STORAGE | data contracts (SSTORE2) — 214,048 int8 bytes in 9 locked contracts |
| TRAINING | trained offchain on the CryptoPunks image set; 95.77% pixel accuracy |
| OUTPUT | 576 palette indexes — a 24×24 reconstruction of the source punk |
| ADDRESS | 0xCa116243a2013ED33015c776ee37310b199Ee80c |
| YEAR | 2026 |
Slonks redraws all 10,000 CryptoPunks with a small model that lives on Ethereum. For each pixel, the model scores 18 candidate colors against a learned 10-byte embedding. The best score wins. The weights fill nine data contracts and can never change. The model runs inside Ethereum. The pixels the model gets wrong are the art.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
renderSourcePixels(0) — runs the model inside Ethereum for punk #0 and returns 576 palette indexes, one per pixel
Requests go from your browser to public third-party Ethereum servers.
HELLO WORLD COMPUTER
HAN × 1001
| FIELD | VALUE |
|---|---|
| TYPE | single-layer perceptron |
| SIZE | 1,024 weights (hashed text n-grams) |
| STORAGE | contract storage; int32 packed in uint256[128] |
| TRAINING | learns inside Ethereum — weights start at zero and update when each question settles |
| OUTPUT | a yes/no label with a confidence value |
| ADDRESS | 0x6901afceb66564a9b6E7193561fB78F0878b5906 |
| YEAR | 2026 |
This perceptron lives inside one contract. The contract stores the weights, trains them, and answers questions. You send it a short text (up to 64 bytes). ask() returns a yes/no label and a confidence value. All weights started at zero. Anyone can post a yes/no question for a fee. Each settled question updates the weights inside the contract.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
ask("hello world") — runs the model on the text and returns (label uint8, confidence int256)
Requests go from your browser to public third-party Ethereum servers.
THE MARKET IS TALKING
FELIXFELIXFELIX
| FIELD | VALUE |
|---|---|
| TYPE | two-layer echo-state network |
| SIZE | 20 hidden neurons, 4 inputs |
| STORAGE | derived at read time — each block's weights come from live market activity, not stored |
| OUTPUT | one deterministic sentence per block |
| ADDRESS | 0xd6D8555E131c0C431601aF62141A61a9b1aa6b13 |
| YEAR | 2026 |
This network reads the market itself. Its hidden layers are two baskets of live token markets. Each block, it derives fresh weights from the trade activity of those tokens. Ethereum stores the renderer program; your browser runs it. The output is one sentence per block, from a 299-word vocabulary. stateAt() returns the exact state at any past block, so anyone can compute each sentence again.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
stateAt(25599744) — returns the saved inputs and mood state; the renderer rebuilds the network from these
Requests go from your browser to public third-party Ethereum servers.
remanence
DIID
| FIELD | VALUE |
|---|---|
| TYPE | convolutional image decoder (4 conv layers, two output heads) |
| SIZE | 1,512 conv weights (int16) plus 110,592 stored latent values |
| STORAGE | data contracts (SSTORE2) — weights, activation tables, and 16 painting latents |
| OUTPUT | one 192×144 indexed-color BMP, computed inside the EVM |
| ADDRESS | 0x788Ee0B4Fb97657Cc2F35829d19C0f129c349B5a |
| YEAR | 2026 |
remanence stores sixteen paintings on Ethereum as compressed fragments. A small neural decoder turns fragments back into a picture. The decoder weights and the fragments are in data contracts. The model runs inside Ethereum: one read-only call runs every layer and returns a finished image. Collectors combine fragments to restore a painting, or mix paintings into a chimera.
VERIFICATION
The check reads the contract code and runs the call on public Ethereum servers.
tokenURI(101) — runs the decoder in EVM opcodes on token 101's fragments and returns the image as token metadata
Requests go from your browser to public third-party Ethereum servers.
METHOD
Software checks the schema, file name, evidence links, and declared return size of each entry. Two or more public Ethereum servers must then agree on the contract code and the exact call result at one block. These checks prove that the call is reproducible. They do not prove that the code is the described neural network. A person also reviews the source evidence. To correct or add an entry, open a pull request.