This page is the complete index of archival materials Larva Labs publishes for its works. It is written for institutions, conservators, and researchers who need to know how each file was derived, by what process, and how to prove that the copy in their care is the right one.
This page lists what exists for each project as a whole. Materials for an individual work are linked from its page in the catalog.
Every media asset in this archive is either a native-format work or a derivative with a documented path back to it. The archive also includes catalogs, manifests, contract records, and transaction ledgers that document provenance and fixity.
Every path printed on this page is a URL. The archive is served from files.larvalabs.com, so the source file cryptopunks/original/punk4821.png is at files.larvalabs.com/cryptopunks/original/punk4821.png, and the same holds for every path below. There is no directory browsing, and a URL naming a folder returns 404, so a project's manifest.jsonl is the thing to enumerate against rather than crawling. An index page lists the entry points for all seven projects.
Each project has a native format, which is the canonical data that represents the work and might not necessarily be visual media. These native-format files are the archive's source files. They are byte-exact, and they are never regenerated or re-encoded. Media files produced from these source files for display, print, or alternate representation are derivatives, and each is documented below with the exact process that produced it.
| Project | Native Format |
|---|---|
| CryptoPunks | 24×24 PNG pixel data |
| Autoglyphs | Text, the ASCII output of the on-chain generator |
| Meebits | Binary voxel data (.vox) |
| Quine | SVG, vector art whose text is its own source code |
Correct derivative generation depends on the nature of each project. CryptoPunks are pixel art, so every raster derivative is produced by pure pixel replication at integer scale factors. Scaled versions are generated directly from the native pixel data using nearest-neighbor methods, with no interpolation anywhere in the code path. Autoglyphs are line art, so the correct derivation is not upscaling an image but re-running the drawing rules at the target resolution.
In neither case does a derivative pass through SVG. SVG rasterization is renderer-dependent, and renderers visibly disagree on these works. Vector renditions ship in the archive as alternate renditions, but they are never an input to derivation.
Files generated for a project's archival bundle are indexed by <project>/archival/manifest.jsonl, which records their SHA-256 checksums and byte sizes. Its exact scope varies by project and is described in each project section below. Transaction ledgers have their own manifest under <project>/archival/ledger/.1
Published media assets and closed-year ledger partitions are immutable. Index files, current-year ledger partitions, and facts that describe an active edition may be updated in place as the archive or blockchain state changes. Each manifest records the current checksums needed to synchronize a copy.
Native-format source files are kept separately under <project>/original/ and are not covered uniformly by the archival manifest. Where the artwork or its fingerprint is recorded on-chain—such as the CryptoPunks composite, Autoglyph text, or Quine generator and token hashes—the project section explains how to verify it directly against Ethereum. Other source files retain their original-file provenance but do not claim an independent on-chain fixity anchor.
Raster source files and derivatives use sRGB color values. Print TIFFs embed the sRGB IEC61966-2.1 ICC profile and carry 300 DPI resolution tags, so they open at their intended physical size in print workflows. Screen PNGs preserve the intended sRGB pixel values but do not embed an ICC profile or PNG color-space declaration. Vector and nonvisual native formats do not carry raster color profiles. No CMYK or wide-gamut conversion is performed on our side; print shops convert for their own press and stock at print time.
Two independent checks are available, and they answer different questions.
Fixity confirms that your copy matches ours. Download the project's manifest.jsonl, find the entry for your file, and compare its sha256 against your own hash of the file.
shasum -a 256 punk0000.tiffOn-chain verification confirms that our copy matches the artwork's own contract, which is the stronger claim, and it requires nothing from us but the file itself. The CryptoPunks market contract stores the SHA-256 of the composite image, and a second contract holds every punk's pixels individually. The Autoglyphs contract computes each glyph's complete text. The Art Blocks contract stores both Quine's generator and every token's generation hash.
# Punks: compare the composite to imageHash() on the market contract
shasum -a 256 punks.png
# Punks: compare one punk's pixels to the image contract
cast call 0x16F5A35647D6F03D5D3da7b35409D65ba03aF3B2 \
"punkImage(uint16)(bytes)" 4821
# Glyphs: compare to glyph115.txt
cast call 0xd4e4078ca3495de5b1d4db434bebc5a986197782 \
"draw(uint256)(string)" 115Each project's contract.json records the contract address, the verified deploy block, the chain id, the token standard, and the retrieval instructions for whichever on-chain anchor that project has.
CryptoPunks are 24×24 pixel art, and the archive treats the pixel data in the form of the composite image as the visual component of the work. Along with a verified version of the contract source code, this is the complete archival version of the work.
In addition to the composite, we provide 10,000 individual pixel source files. Derived materials include 20,000 per-punk print TIFFs, two composite print TIFFs, 20,000 screen-sized PNGs, 10,000 vector renditions, and the full trait catalog.
The per-punk pixel source files (cryptopunks/original/punkNNNN.png, 10,000 files) are 24×24 pixels, which is the punk's native resolution, and they have a transparent background.2 These files are byte-identical to the images in the original Larva Labs codebase, which were the atoms that every punk rendering pipeline we ever built consumed, and their pixels are byte-identical to what the on-chain image contract returns.
The composite is 2400×2400 and holds all 10,000 punks in a 100×100 grid at native 24 pixels. It is the artifact anchored on-chain. The CryptoPunks contract stores imageHash, the SHA-256 of this exact file, so anyone can verify the image against Ethereum independently of this archive. Its value is ac39af4793119ee46bbff351d8cb6b5f23da60222126add4268e261199a2921b, and you can read it directly from the contract.
The contract code is part of the work. Its source is published at github.com/larvalabs/cryptopunks as contracts/CryptoPunksMarket.sol, and the compiled program it became is what actually lives on Ethereum. That deployed program is 6,969 bytes with the SHA-256 075710479c792e7a52a39b2588f98a3710052d2ea3ab23a6372c3d53c83a2a53, and anyone can retrieve it from the chain and hash it themselves.
cast code 0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBBThe published source recompiles to exactly that program. Building it with solc 0.4.11 and the optimizer enabled at 200 runs, passing the source unnamed as the 2017 toolchain did, reproduces all 6,969 bytes including the trailing metadata hash.3 The source also carries the composite's fingerprint in plain sight, as string public imageHash, so the code and the image vouch for each other.
The whole build is archived, so none of this has to be taken on trust: the source as it compiled, the deployed bytecode those hashes describe, and the solc input that pins the compiler version, the optimizer setting, and the source-unit name. Handing that input to solc 0.4.11 returns the bytecode file byte for byte.
In August 2021, four years after the punks were minted, the artwork itself went onto Ethereum. CryptopunksData at 0x16F5A356…03aF3B2 answers three questions for any punk index, with no gas and no transaction fees: punkImage returns the raw pixels, punkImageSvg returns those pixels as vector rectangles, and punkAttributes returns the type and list of attributes.
What it stores is not ten thousand pictures but the parts and the rules for assembling them: a 120-color palette in 480 bytes, 133 run-length-encoded attribute layers in 8,205 bytes, the names of those layers, an alpha-blending lookup table, and 80,000 bytes, 8 bytes per punk to represent its type and attributes. That is roughly 90 KB for the entire collection, and each image is composited algorithmically by the smart contract when queried.
The contract is sealed. Every function that writes is gated on an unsealed flag, and sealContract() was called at block 13047090, about four hours after the deployment at block 13045935 on 18 August 2021. What it holds can no longer be changed by anyone, ourselves included.
This is what makes the per-punk source files verifiable one at a time rather than only in aggregate. punkImage(index) returns 2,304 bytes, the punk's 24×24 pixels in RGBA row by row, and those bytes are identical to the pixel data of the corresponding source PNG. The composite's imageHash vouches for the set as a whole; this vouches for each file on its own and, like the Autoglyphs text source files, it technically requires nothing from this archive.
# Punks: compare a punk's pixels to the image contract
cast call 0x16F5A35647D6F03D5D3da7b35409D65ba03aF3B2 \
"punkImage(uint16)(bytes)" 4821The attributes are on-chain by the same means, and the trait catalog below reconciles with them exactly.
Print TIFFs are a 300× integer upscale of the 24-pixel grid, giving 7200×7200 pixels, or 24 inches square at 300 DPI. That factor was chosen so that every native pixel maps to an exact 300×300 block. The upscale is pure pixel-block replication, and interpolation is impossible in the code path.4
Two variants ship for every raster derivative, because they serve different uses. The transparent variant suits compositing and exhibition design, and the variant flattened onto the canonical #638596 gives the presentation the work is known by. Per-punk files are linked from each punk's catalog page.
At the project level, the composite print TIFF is 19200×19200, or 64 inches square at 300 DPI, an 8× replication of the composite the contract fingerprints. A transparent variant is also available.
Screen PNGs are a 50× replication of the source file to 1200×1200, meant for displays and slideshows, and they come in the same two variants (punkNNNN-screen.png and punkNNNN-screen-transparent.png).5
Per-punk SVGs (cryptopunks/original/punkNNNN.svg, 10,000 files) draw one 1×1 rectangle per pixel with shape-rendering="crispEdges", over a #638596 background rectangle. They ship as an alternate rendition and are not an input to derivation.
The trait catalog is in long format with one row per attribute, giving the columns punk_index,position,category,trait,skin across 39,548 rows. skin is the generator's skin-tone variant index, which is deliberately unnamed, and it is carried on the Type row. Aliens, apes, and zombies have none. The same data as JSON gives one object per punk.6
The contract facts record the address, deploy block 3914495 from 22 June 2017 as verified via the creation transaction, the chain id, the token count, the on-chain imageHash with instructions for verifying against it, and a note that CryptoPunks predates ERC-721. They also record the image contract described above, its deploy and seal blocks, what it holds, and the calls that verify a source file's pixels and attributes against it. The manifest lists all 40,008 files in this folder with their checksums.
The complete on-chain transaction ledger is published as year-partitioned CSV and JSONL files. The ledger manifest lists every file with its SHA-256 checksum, row count, and block range. Closed years never change, so comparing checksums against the manifest syncs an archive by downloading only what moved.
Autoglyphs live entirely on Ethereum. The contract computes each glyph's complete text, so the text is the artwork and every image is a rendition of those drawing instructions. All 512 text source files have been verified byte for byte against the live contract.
The text source files (autoglyphs/original/glyphN.txt, 512 files) are the decoded generator output. Each is 64 rows of 64 symbols drawn from . O + - | X / \ #, with every row newline-terminated, running 4,160 bytes in US-ASCII. All 512 have been verified byte-exact against the live contract by calling draw(id) for every glyph, and anyone can repeat that check for any glyph by calling draw(id) on the Autoglyphs contract. That makes these files verifiable without trusting this archive at all, which is a stronger guarantee than any checksum we could publish.
For Autoglyphs the contract is not a wrapper around the art, it is the generator, so the code has as strong a claim to being the work as the text it emits. The deployed program at 0xd4e4078c…86197782 is 6,638 bytes with the SHA-256 3db0e2074e6f6d185a0bebcaf535a38e5b04122bedd4f868e7070030238ad6da, retrievable from the chain the same way.
cast code 0xd4e4078ca3495de5b1d4db434bebc5a986197782The archived source recompiles to exactly that program. Building it with solc 0.4.24 and the optimizer enabled at 200 runs, compiled under its original Truffle path contracts/Autoglyphs.sol, reproduces all 6,638 bytes including the trailing metadata hash. The path is load-bearing, because the metadata hash covers the name a file was compiled under as well as its contents, so no copy of this source compiled as a bare Autoglyphs.sol will reproduce those last bytes. The optimizer is not optional here, since the contract does not compile without it.
The whole build is archived, as it is for CryptoPunks: the source, which is 22,822 bytes with the SHA-256 c0e2c35626b49db817aaa6263c77ecaabeac176ba5921953a83d6dadfb6a7c91, the deployed bytecode, and the solc input carrying the path and settings above. Handing that input to solc 0.4.24 returns the bytecode file byte for byte. This is the only published copy of the source that does so.7
Print TIFFs are 20400×20400 pixels, or 68 inches square at 300 DPI, rendered from the text source file by an interpreter of the original drawing rules. Each symbol is drawn as its geometric shape, with antialiasing, at the target resolution. There is one variant per glyph, since glyphs are black line art on white with no transparent-or-filled distinction.8
The print geometry follows the artists' own prints. One cell is one inch, which makes the 64-cell glyph 64 inches with a two-inch white margin on each side. The margin is part of the artifact, because strokes at edge cells extend past the glyph bounds. Stroke width is the glyph side divided by 300.9
Screen PNGs (glyphN-screen.png) use the same renderer and geometry at a 32-pixel cell, giving 2176×2176, which is a 2048-pixel glyph plus the two-cell margin. The stroke ratio is unchanged.
Per-glyph SVGs (autoglyphs/original/glyphN.svg, 512 files) come from the original renderer and ship as an alternate rendition. They are not an input to derivation, and Autoglyphs are the clearest illustration of why.10 The raster pipeline interprets the text directly instead.
The trait catalog gives one row per glyph across 512 rows, with the columns glyph,category,trait,scheme. Every glyph's symbol scheme has been verified against the chain via symbolScheme(id). The same data is also published as JSON.
The contract facts record the address, deploy block 7510386 from 5 April 2019 as verified via the creation transaction, the chain id, ERC-721, the 512 tokens, and how to verify a downloaded source file against the on-chain generator. The manifest lists all 1,030 files in this folder with their checksums.
The complete on-chain transaction ledger is published as year-partitioned CSV and JSONL files. The ledger manifest lists every file with its SHA-256 checksum, row count, and block range. Closed years never change, so comparing checksums against the manifest syncs an archive by downloading only what moved.
A Meebit is natively a voxel sculpture, and every raster image of one is a render of that model. This is the largest of the four archives, holding the voxel source files, the generator's own metadata, rigged mesh exports in several formats, a full render archive, and a 20,000-plate pen-plotter edition.
Two source files sit in meebits/original/<id>/ for each Meebit, named <id>_<TYPE> as in 00001_MALE. The .vox file is the posed voxel model, which is the generator's output and the native artwork. The .json file is the generator's own metadata record, holding the type, the garments as element plus style, the skin, and the generation seed that produced this Meebit.
These were the original owner downloads, and their meanings are recovered from the original Meebits website source.
| File | What It Is |
|---|---|
<id>_<TYPE>_T.vox | T-pose, cored (hollow), for rigging |
<id>_<TYPE>_T_FILL.vox | T-pose, solid |
<id>_<TYPE>_PRINT.vox | 3D-print-ready model |
<id>_<TYPE>_ISO.png | Small isometric reference render |
meebit_<id>_<type>.vrm | Rigged VRM avatar |
meebits/fbx/, meebits/glb/ | Rigged mesh exports, 20,000 each |
meebits/renders/<id>_<TYPE>/ | Render archive holding PNG, JPG, the Blender scene, and the render mesh |
meebits/hero-blend-renders/ | Grid and hero composites |
Each Meebit has one plotter-ready print plate (meebits/archival/pen-plots/meebit_<id>.svg, 20,000 files) that draws the voxel model as an isometric line drawing on 11×17 inch tabloid, sized 1056×1632 at 96 units per inch. Each plate carries two pen layers, outlines at 0.50 stroke and shading at 0.30 hatching, so a plotter can run a separate pen per layer.
Each plate is a finished composition holding the figure, a footer rule, the Meebit's number, and its trait caption. Everything is expressed as stroked paths rather than text elements, so the whole plate is plottable geometry.11
The trait catalog is in long format with one row per attribute, giving the columns meebit,position,category,trait,style,skin,seed across 128,005 rows. style is the garment's color or pattern variant. Skin and seed are the generator's inputs and are carried on the Type row. The same data is published as JSON.12
The contract facts record the address, deploy block 12358080 from 3 May 2021 as verified via the creation transaction, the chain id, the 20,000 tokens, a custom ERC-721 with a built-in marketplace, and the on-chain contentHash. The manifest covers the 20,003 files generated for this archive, which are the pen plots and the catalog records. The voxel source files and the mesh and render derivatives predate it and are listed on each Meebit's catalog page instead.
The complete on-chain transaction ledger is published as year-partitioned CSV and JSONL files. The ledger manifest lists every file with its SHA-256 checksum, row count, and block range. Closed years never change, so comparing checksums against the manifest syncs an archive by downloading only what moved.
Quine is Larva Labs' Art Blocks Curated project, and the final Curated release. A parent generator stored on-chain produces a per-token program whose visual output embeds its own source code. Because both the generator and every token's generation hash live on the blockchain, all 497 works are reproducible from chain data alone.
The on-chain parent generator is 36,792 bytes, a byte-exact reconstruction of what the Art Blocks core contract stores, which is the concatenation of projectScriptByIndex(506, 0) and projectScriptByIndex(506, 1). Anyone can re-derive it from the chain and compare, by reading it on the contract.
The per-generation SVGs (quine/original/<index>/<gen>.svg) are the native artwork, and each lays out its own source code as typographic composition.13 Alongside them, the per-token Art Blocks records (quine/original/<index>/traits.json) hold the features, token hash, and provenance.
All 497 generation hashes in the catalog have been verified against tokenIdToHash(tokenId) on the core contract.
The trait catalog gives one row per attribute across 2,485 rows, with the columns quine,position,category,trait,token_id,hash, carrying the token id and on-chain hash on each Quine's first row. The categories are Code, Space, Chrome, Engine, and Quinity. The same data is published as JSON.
The contract facts record the shared Art Blocks core contract, deploy block 23326849 from 9 September 2025 as verified via the transaction receipt's logs for a factory deployment, project id 506, token ids 506000000 through 506000496, and retrieval instructions for the generator and the hashes. The manifest covers the four files generated for this archive, which are the generator and the catalog records. The per-generation SVG source files are listed on each Quine's catalog page.
The complete on-chain transaction ledger is published as year-partitioned CSV and JSONL files. The ledger manifest lists every file with its SHA-256 checksum, row count, and block range. Closed years never change, so comparing checksums against the manifest syncs an archive by downloading only what moved.
Protoglyph, Voxelglyph, and I ♥ LA are editioned works. Every token of one of these projects is the same artwork, so each project has exactly one archival asset rather than a per-token file set. That asset is the single shared image at <project>/original/cover.png, and trait catalogs do not apply. Each project's contract facts are published at <project>/archival/contract.json, with a manifest.jsonl alongside.
Protoglyph is 77 tokens with non-contiguous ids from 20 through 1020, on the shared PROOF Collective Grails contract that carries 1,036 tokens across all the Grails artists. It was deployed at block 14274700 on 25 February 2022, verified via the creation transaction. The artwork is the single shared image. The contract facts are published as JSON, and the contract itself can be read on Etherscan.
Protoglyph transaction ledger (manifest):
Voxelglyph is an open edition on a dedicated contract, so its size is not fixed and any count here is a snapshot. As of 30 July 2026 it held 273 tokens with contiguous ids from 1, against an on-chain cap of 2,000, and the most recent mint was 29 June 2026. Minting is still live and is not restricted to us: the contract's minter role belongs to a companion migration contract whose mint function anyone can call.14 It was deployed at block 17920896 on 15 August 2023, verified via the creation transaction. The artwork is the single shared image. The contract facts are published as JSON, and the contract itself can be read on Etherscan.
Voxelglyph transaction ledger (manifest):
I ♥ LA is 357 tokens with non-contiguous ids from 3 through 2459. The contract hosted mints by several artists, 2,475 tokens in all, so the Larva Labs edition is interleaved with the others. It was identified by reading each token's metadata on-chain. The contract was deployed at block 21640471 on 16 January 2025 by a factory, verified via the transaction receipt's logs. The artwork is the single shared image. The contract facts record how the Larva Labs edition was identified, and the contract itself can be read on Etherscan.
I ♥ LA transaction ledger (manifest):
