---
pretty_name: mtg-nest-benchmark
license: cc-by-4.0
language:
- en
- pt
tags:
- image-compression
- image-retrieval
- multimodal-retrieval
- vector-database
- av1
- avif
- jpeg-xl
- siglip2
- clip
- nest
- magic-the-gathering
- scryfall
- benchmark
size_categories:
- 10K<n<100K
task_categories:
- image-to-text
- text-to-image
- image-feature-extraction
configs:
- config_name: default
  data_files:
  - split: train
    path: data/cards-*.parquet
---

# mtg-nest-benchmark

38,627 magic: the gathering cards, one per oracle id, the scan and the rules text of each, packed into single `.nest` files that answer text and image queries from memory-mapped bytes: no server, no python at read time. ten such files live here. they carry the same cards, the same text and the same content hash; what differs is how the 4 GB of jpeg was encoded inside, and which image models embedded it.

the file to start with is `release/v0.3/stills-5models`. it is the only one with the models that read the printed name: on 38,627 queries of the form "artwork of the card {name}", siglip2 finds the card at rank 1 three times in four. the other nine files carry clip alone, which finds it once in ten; they exist because they are the compression ladder, and they are kept for that.

the code, the specs, the per-experiment numbers and the roadmap are in the github repository, [brennercruvinel/mtg-nest-benchmark](https://github.com/brennercruvinel/mtg-nest-benchmark).

- engine: [nest](https://github.com/hoffresearch/nest), the single-file vector database that reads these
- source images and text: [scryfall bulk data](https://scryfall.com/docs/api/bulk-data), as cached by the spellbook app
- code and results: [brennercruvinel/mtg-nest-benchmark](https://github.com/brennercruvinel/mtg-nest-benchmark)
- total on the hub: 11.7 GB in ten `.nest` files plus sidecars, and 4.0 GB of parquet under `data/` for the viewer

## how to open

the `nest` cli reads a file straight off disk. install it from the [nest](https://github.com/hoffresearch/nest) readme, then:

```sh
hf download brennercruvinel/mtg-nest-benchmark release/v0.3/stills-5models/mtgdataset.nest --local-dir .
```

```sh
nest inspect --json release/v0.3/stills-5models/mtgdataset.nest    # identity, sections, the six spaces, the blob
```

```sh
nest validate release/v0.3/stills-5models/mtgdataset.nest          # every checksum, the inlined blob
```

```sh
nest retrieve release/v0.3/stills-5models/mtgdataset.nest "a white creature that gains life when it enters" -k 3 --format jsonl
```

`retrieve` and `ask` embed the query offline with the potion table declared in the manifest and return cited hits; they need the embedder scripts of a nest checkout (`nest doctor` tells you). a text query against an image space goes through `nest search-space --space siglip2` with the model's text-tower vector, or from python through `nest.open(path).search_space(name, vector, k)`; `python/tools/nest_model_bench.py` and the benchmark's `bench_full_corpus.py` show the whole path.

the `.nest` is not a parquet and `datasets.load_dataset` will not parse it. what the viewer above shows is `data/cards-*.parquet`: the same 38,627 rows, one per card, with the scan as an image column, the fields the text was rendered from (name, portuguese name, mana cost, type line, rarity, set, oracle text), an `art_series` flag, the jpeg sha256, and the `ordinal` that maps the row to its chunk in every release. `load_dataset("brennercruvinel/mtg-nest-benchmark")` gives that table; it is a view of the corpus with no vectors and no index, and `benchmark/tools/export_parquet.py` writes it from the release's `items.jsonl.gz`. the card text is also inside every `.nest` (section `chunks_canonical`, 1.4 MB zstd) and comes out with `nest inspect` or through the python api.

## contents

every file holds the same 38,627 chunks. a chunk is the card name, the portuguese printed name where scryfall has one, the mana cost, the type line, rarity, set code and oracle text. every file holds potion-base-8M for the text (256d int8, hnsw, bm25, graph) and at least clip-vit-b32 for the image (512d int8). the source is 3,975,063,106 bytes of jpeg, normal front scans at 488x680.

| release | image spaces | media | file | file_hash |
| --- | --- | --- | ---: | --- |
| `stills-5models` | clip, siglip2 (768d), jina-v5-omni-nano@256, wemm-2b@256, plus jina and wemm text | av1 crf35 tune still, one stream | 1.44 GB | `6b2bc21a` |
| `archive` | clip | jpeg xl byte-reversible repack, 38,627 blobs | 3.61 GB | `88242709` |
| `neardup` | clip | av1 crf35 tune still, clustered order, 19 shards | 1.37 GB | `071233c5` |
| `stills` | clip | av1 crf35 tune still, one stream | 1.37 GB | `6f12cadb` |
| `retrieval` | clip | av1 crf50 tune still, one stream | 533 MB | `73f814b7` |

| candidate | image spaces | media | file | file_hash |
| --- | --- | --- | ---: | --- |
| `v03-retrieval` | clip | av1 crf40, the gate's own pick | 981 MB | `1fa37ef5` |
| `v03-retrieval-crf50` | clip | av1 crf50, byte-identical to the retrieval release | 533 MB | `73f814b7` |
| `v03-retrieval-crf55` | clip | av1 crf55 | 370 MB | `43451a4c` |
| `v03-retrieval-crf60` | clip | av1 crf60 | 230 MB | `b08ab27d` |
| `v03-avif-q48` | clip | avif q48 speed 8, one blob per card | 1.20 GB | `dbc5734a` |

`file_hash` is the sha256 of the bytes on disk, the first eight hex digits above, in full in each release's `SHA256SUMS` and in the lfs metadata here. it is the identifier of a file. all ten share `content_hash sha256:cb8fdf8f13fa50f93969de7603386f1c2b117a5e4946c60ac9894a3c5a1f062b`, because the content hash covers the text and the default text vectors and not the media bytes or the extra spaces; it says two files answer the same `nest://` citation, not that they are the same file.

### text-to-image search on the five-model file

every card as a query, "artwork of the card {name}", searched in each model's image space; a hit is the card's own chunk in the top k (experiment 20 in the repository):

| image space | hit@1 | 95% interval | hit@5 | hit@10 | build, images per s |
| --- | ---: | ---: | ---: | ---: | ---: |
| siglip2 | 0.750 | 0.745 to 0.755 | 0.861 | 0.888 | 53 |
| wemm-2b@256 | 0.744 | 0.740 to 0.748 | 0.886 | 0.913 | 1.0 |
| jina-v5-omni-nano@256 | 0.336 | 0.332 to 0.341 | 0.514 | 0.582 | 3.5 |
| clip-vit-b32 | 0.098 | 0.095 to 0.101 | 0.164 | 0.193 | 36 to 49 |

2,246 rows of the corpus (5.8%) are art-series cards: full art, no frame, no printed name, labeled `name // name` in the source. they take 61% of siglip2's misses, and as queries they hit 23%. with those rows out of the gallery, plain-name queries score 0.881 (siglip2) and 0.869 (wemm) on a 2,000-card slice. on 512 cards the same models scored 0.93 and 0.91; the difference is the gallery.

### the compression ladder, clip only

text-to-image hit@1 with clip on 1,000 queries, per file (experiment 14). clip encodes the painting and not the name, so the level is 0.09 on every file and the table can only say where the codec starts to hurt:

| file | hit@1 | drift p10 |
| --- | ---: | ---: |
| archive (lossless) | 0.092 | 0.997 |
| stills, neardup | 0.096 | 0.967 |
| avif q48 | 0.096 | 0.968 |
| crf40 | 0.089 | 0.959 |
| crf50 | 0.093 | 0.939 |
| crf55 | 0.074 | 0.912 |
| crf60 | 0.069 | 0.887 |

standard error is about 0.009 per cell; through crf50 nothing moves, crf60 is two standard errors under lossless. on 512 cards the name-reading models hold at crf50 too (experiment 15). the cosine drift of the vector falls the whole way and never says where the edge is, which is why the retrieval profile is gated on hit@k.

## files

each release directory holds:

| file | what it is |
| --- | --- |
| `mtgdataset.nest` | the artifact |
| `build.lock.json` | resolved spec, pinned model hashes, package versions, tool binaries with sha256, platform |
| `manifest.json` | the forge manifest with the 38,627-entry `items` list stripped out: encoder parameters, per-model recipe hashes, timings, and for gated builds the crf ladder with per-bucket ssimulacra2 and drift |
| `items.jsonl.gz` | the stripped items, one json per card: key, label, media uri, ordinal |
| `SHA256SUMS` | sha256 of the four files above |
| `CITATION_KEY` | content_hash, file_hash, chunker version, title, chunk count, read from inside the file with `nest inspect --json` |

candidate directories hold the `.nest`, the build lock and the stripped manifest under the `mtgdataset.` prefix. all paths inside the sidecars are portable: `${MTG_DATA}` stands for the spellbook data root on the machine that built them.

## build

the source is the spellbook app's local cache of scryfall bulk data: `mtg.sqlite` (38,627 cards with a front image, 100,452 printings, 181,053 localized names) and the normal front scans. the nest forge reads a toml spec and pulls the rows from sqlite in a total order by (image id, oracle id). it renders the text template, letterboxes each scan to 488x680 yuv420 and hands the frames to the media backend: svt-av1 through ffmpeg for the av1 files, avifenc for avif, cjxl with `--lossless_jpeg=1` for the archive, where the round trip of every jpeg is verified by sha256. the image models embed the decoded frames, potion embeds the text, and the forge writes one file with the vectors, an hnsw index, bm25, a graph, the source spans and the media inlined.

the recipes are `profiles/*.toml` in the repository; `nest build --spec profiles/stills-5models.toml` with `MTG_DATA` exported rebuilds the five-model file, in about 35 hours on an m4 (7 for the av1 encode, 21 for wemm-2b at 1.0 image per second, 6 for jina). builds are reproducible on one toolchain: the same spec, the same model snapshots and `reproducible = true` give the same `file_hash`, and the worker count does not change the bytes since nest #139 (experiment 18). across encoder versions they are not: aom 3.14 to 3.15 moved the same avif knob by 1.5% of bytes (experiment 19). the toolchain is in every build lock: apple silicon, ffmpeg 9 with svt-av1 4.2, avifenc 1.4, cjxl 0.12.

## limits

the media inside the lossy files is meant for the model, not for display. crf50 at 488x680 has ssimulacra2 p10 between 9 and 34 per bucket: card text is soft and small art is degraded. applications that show the card should use `stills`, `stills-5models` or `archive`.

the nine single-model files carry clip only, and clip is the wrong model for finding a card by name (0.10 hit@1 against 0.75 for siglip2 on the same media). they are the compression ladder; the five-model file is the one to search.

reading one card back costs 27 ms from the av1 stream on a quiet m4, 23 of them the ffmpeg process start; 32 ms from the avif blobs and 16 ms from the jxl blobs (experiment 17). all-intra av1 has no keyframe walk. the batched frame path in the forge walks every frame between the first and the last hit and is the wrong call for hits spread over the corpus.

`neardup` and `stills` differ by 14 kB. every card here is unique art (one image per oracle id, and the 2,787 "reprints" the sqlite knows are framed and borderless printings of the same painting at different scales), so inter prediction and the clustered order have nothing to work with. the profile gains 29% on a corpus of same-artwork reprints (experiment 09), not on this one.

the avif candidate is 13% smaller than the stills stream in bytes and 4.6 ssimulacra2 points worse; at matched quality libaom speed 8 is 1% larger than the av1 still stream and speed 6 is 5% smaller (experiment 19).

every vector in every file is int8. against exact f32 search, the int8 rows keep 0.97 of the top-10 neighbours on siglip2 and 0.92 on clip (experiment 16, image to image); the text-to-image numbers above are measured through the int8 spaces the files serve.

`manifest.json` has its `items` list removed to keep the sidecar small; the full list is in `items.jsonl.gz`. the avif candidate's manifest was patched by hand on 2026-09-12 after a forge bug that recorded the letterboxed png bytes as `source_bytes` (fixed in nest #132); the `patched` key in its media block says so.

## not included

- the jpeg scans as loose files: they are inside `data/cards-*.parquet` as an image column and inside the archive release, which reconstructs each one bit for bit with `nest media --export`; the images belong to wizards of the coast and are served by scryfall under [its terms](https://scryfall.com/docs/api)
- the sqlite database
- the model weights: potion-base-8M is vendored in the nest checkout, clip-vit-b32 and siglip2 come from open_clip, jina-v5-omni-nano and wemm-2b from their hub repositories (remote code, opt-in in the spec)
- the sample builds of the 2048-card battery and of the 512-card model experiments; their numbers are in the repository

## license

the `.nest` files, the sidecars and this card are released under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). the code and the results in the github repository are MIT. the card images and text inside every file are scryfall's rendering of wizards of the coast's material and remain under their terms; this dataset is a derived encoding for retrieval research.

## citation

```bibtex
@misc{cruvinel2026mtgnest,
  title        = {mtg-nest-benchmark: 38,627 card scans in one searchable file, and what it cost},
  author       = {Cruvinel, Brenner},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/brennercruvinel/mtg-nest-benchmark}},
  note         = {stills-5models file_hash sha256:6b2bc21a2057bccea054fa331ee91c04f2b7ee80156f01144399c3065e7d4b3f}
}
```

cite scryfall as the source of the cards and nest as the engine.

## credits

Brenner Cruvinel, [Hoff Research](https://www.hoffresearch.com/)

- github: https://github.com/brennercruvinel
- contact: brenner@hoffresearch.com

Felipe Navarro

- contact: aoscuidadosde@felipenavarro.com.br