Sparkles

Appearance

Autological Artifacts — Concepts ​

The shared vocabulary for the survey. Discussions of self-containing files go wrong quickly because "self-contained", "portable", "single-binary", and "self-describing" get used as synonyms for one another, and because "polyglot" gets applied both to a file that two parsers accept and to a file that one parser accepts in two ways. This page assigns each term a narrow meaning, ties it to a concrete artifact, and defines the four axes and two structural questions every deep-dive in the tree answers.

Last reviewed: August 26, 2026

The name ​

Autological describes a term that is an instance of what it denotes: "short" is short, "polysyllabic" is polysyllabic, "English" is English. Its opposite is heterological — "long" is not long — and the pair is the setup for Grelling's paradox, which asks whether "heterological" is itself heterological.

The word is doing real work here rather than decorating the catalog. The two seed artifacts differ in almost every respect except this one:

  • redbean is a file whose own bytes are its archive. The web server serves assets by reading the ZIP central directory of the executable that is running.
  • SELF is a file whose own bytes are its schema. The executable is a SQLite database, and the loader's questions are answered by querying the file it is loading.

Neither is merely "self-contained" (a statically linked binary is that, and is not interesting here). What they share is that the artifact is an instance of the thing it describes — the archive is the program, the database is the executable — and that is precisely autology.

NOTE

The catalog is deliberately narrower than "interesting file formats". A format earns an entry by being queryable, polyglot, closed over its dependencies, or self-mutating — see what is out of scope.

The four axes ​

Every subject in this tree is a point in a four-dimensional space, scored 0–3 on each axis in that subject's metadata table. The scores are collected in the master catalog. They are ordinal, not measured: 0 = absent, 1 = incidental, 2 = designed-in, 3 = defining.

Multiplicity ​

How many formats does one byte stream simultaneously satisfy?

Multiplicity is a property of the bytes, not of the tooling. A file has multiplicity 3 on this scale when being several formats at once is the reason it exists — APE is PE and ELF and Mach-O and a shell script and, with the right prologue, an MBR boot sector. A .docx scores lower: it is a ZIP, and the OOXML layer is a convention inside the ZIP rather than a second parse of the same bytes.

The distinction that matters:

TermMeaningExample
PolyglotTwo different parsers each accept the file, as their own formatA PoC‖GTFO issue that is a PDF and a ZIP
ChimeraOne file, several formats, each in its own region, none overlappingAn isohybrid ISO with an MBR in front
SchizophrenicOne parser accepts it two different ways depending on version or quirkAndroid's Master Key APK bugs
ContainerOne format, carrying opaque payloads it does not interpretA JAR's entries; a UKI's PE sections

Only the first three are multiplicity. A container is the absence of multiplicity purchased with a tax — see thesis 3.

Reflexivity ​

Can the artifact be interrogated through a general query surface, and can it interrogate itself while running?

Two sub-questions, and they come apart:

  • Interrogable. Is there a general question-asking surface — SQL, Datalog, a typed interface graph — as opposed to a fixed menu of tools? readelf answers the questions readelf was written to answer; sqlelf answers questions nobody anticipated.
  • Self-interrogating. Can the running process ask about itself, live? A program reading its own build-id out of /proc/self/exe scores 1 here; a server whose request handlers are rows in the database it is executing from scores 3.

Closure ​

Does the artifact carry its transitive dependencies?

Closure is what separates "a binary" from "a thing you can scp somewhere and run". It is also the axis with the sharpest cost: carrying dependencies duplicates them, and the whole dedup literature exists to make the duplication cheap again. Nix computes a closure and shares it; AppImage computes a closure and copies it; SELF computes a closure and stores it as rows.

The word is borrowed from Nix, where a closure is the transitive set of store paths a derivation references. It is the set-theoretic sense — closed under the "references" relation — not the programming-language sense of a function capturing its environment.

Mutability ​

Is the artifact also its own state store, transactionally?

The interesting form is not "the program can write files" but "the program's own image is the durable state, and updating it is a transaction". self-httpdINSERTs a row into a visits table inside the file it is executing from; redbean's StoreAsset writes an asset back into its own ZIP, and requires the explicit -* flag to do so, precisely because that is a W^X violation with a respectable pedigree. Smalltalk images and Emacs pdumper are the ancestors.

Mutability is where the axes stop being independent of the substrate: a mutable artifact cannot be verified by a signature over its whole bytes, which is the signing problem the catalog has no good answer to yet.

The two structural questions ​

The axes describe what an artifact is. These two describe how it works, and they turn out to predict composability better than any taxonomy of formats.

Where does the index live? ​

Every format that supports random access has an index, and the index has to be findable before anything else can be. There are exactly four answers in practice, and each deep-dive's metadata table names one:

AnchoringHow the index is foundConsequence
HeaderAt, or at a fixed offset from, byte 0Byte 0 is spoken for; a prefix is impossible without a hole
FooterLocated by scanning backwards from EOF for a signatureThe front of the file is free — this is what makes suffix-parasitism work
Stream-scannedNo index; the reader walks records from the startRandom access costs a full scan; append is trivial
Out-of-bandIn a different file entirelyThe artifact does not know its own index; the index can go stale

ELF and PE are header-anchored. ZIP, Parquet, ORC, and the seekable-zstd family are footer-anchored. tar and raw gzip are stream-scanned. /etc/ld.so.cache, debuginfod, and tabix are out-of-band — and note that an out-of-band index is a materialized view, with all the staleness properties that implies.

Who decides what the file is? ​

Multiplicity is inert until something acts on it. Dispatch is the mechanism that turns superposition into behavior, and it has four owners:

DispatcherMechanismDeep-dive
The kernelbinfmt_misc magic+mask+offset; binfmt_elf; binfmt_scriptbinfmt_misc
The shellShebang, and the ENOEXEC fallback to sh(1)binfmt_misc, APE
The loaderDT_NEEDED, RUNPATH, LD_PRELOAD, symbol interpositiondynamic linking
The consumerContent sniffing, extension, declared MIME typeparser differentials

The catalog's recurring failure mode — and the whole of the adversarial cluster — is two dispatchers disagreeing about one byte stream.

Tolerance: a partial order on composability ​

The two structural questions combine into the property that actually predicts which formats compose. A format is:

  • Prefix-tolerant — legal to place arbitrary bytes before it. Requires a footer-anchored index (ZIP) or a scanned entry point (PDF's %PDF- header is conventionally at 0, but readers accept a leading offset and use the startxref footer).
  • Suffix-tolerant — legal to place arbitrary bytes after it. Requires a header-anchored index that records its own extent (ELF, PE), so a reader knows where the format stops and never looks further.
  • Hole-tolerant — reserves an unused region a foreign format may occupy. ISO 9660's first 32 KiB, before its volume descriptors, is the canonical case, and it is why an ISO can carry an MBR without either format bending.
  • Neither — the format claims byte 0 and runs to EOF with no self-declared extent.

A composition is possible when one participant is prefix-tolerant and the other is suffix-tolerant (or when one is hole-tolerant and the other fits the hole). That single rule generates the entire ZIP-suffixed ecosystem — JAR, APK, .docx, EPUB, .whl, self-extracting archives — from one structural fact, and it predicts rather than merely catalogues. ZIP parasitism develops the argument and tests it against a table of formats.

Terms used throughout ​

Assimilation — collapsing a superposition into one native format, discarding the others. --assimilate is APE's; it is a one-way operation and the honest admission that superposition has a runtime cost.

Content addressing — naming a blob by the hash of its bytes, so identical content is stored once. The basis of Nix, OCI layers, Git objects, and casync/desync chunking.

Interposition — a symbol definition earlier in the loader's search scope shadowing a later one. LD_PRELOAD is interposition made available to users; SELF's claim is that it is more honestly modelled as a row. See the runnable demonstration.

Materialized view — a precomputed answer stored alongside (or instead of) the data it derives from, trading staleness for lookup cost. ldconfig's cache, prelink's resolved addresses, .gdb_index, and eStargz's TOC are all materialized views, and each one's failure mode is the same: the source moved and the view did not.

Page sharing — two processes running the same image mapping the same physical pages, because both mmap the same file at the same alignment. The property SELF currently loses, and the sharpest open question in the catalog.

Self-describing — carrying the schema needed to interpret the payload, in the payload. SQLite carries sqlite_schema; ELF carries a section table but not a schema (nothing in an ELF file says what .gnu.hash means). This is thesis 2.

Suffix parasitism — appending a complete, self-locating format to an unrelated host file so both parse. Named for the direction that actually occurs in practice; ZIP is the overwhelmingly dominant parasite. See ZIP parasitism.

The five cross-cutting theses ​

Stated here as definitions; each is defended, complicated, or killed in comparison.md using evidence gathered across the deep-dives.

Every binary format eventually reimplements a database, badly ​

ELF's .gnu.hash is a hand-rolled bloom filter, .strtab is string interning, and st_name is a foreign key maintained by hand with no referential integrity. The claim is that this is general, and it is tested outside ELF — against Mach-O, PE, Wasm, Parquet, and PDF's xref table.

Self-description is what makes a format survivable ​

SQLite's stability is attributed to carrying its own schema; formats without one accrete conventions instead. The test is whether long-lived schema-less formats (tar, ELF) are in fact less survivable, or merely differently so.

The container is a tax ​

redbean needs ZIP; SELF needs nothing, because the database is the container. The general form: which systems pay a container tax that a self-describing store would eliminate?

mmap is the load-bearing constraint ​

Every "the executable is X" proposal will be judged on whether it preserves demand paging and cross-process sharing. See image-based systems and the SELF deep-dive.

Portability has migrated from the format to the access layer ​

APE achieves reach by satisfying every loader's parse at once — enormous cleverness spent at the format level. SQLite achieves comparable reach by holding one format fixed and swapping the substrate beneath it (the VFS). If this holds, redbean is the last great artifact of the old strategy and SELF an early one of the new.

What is out of scope ​

Deliberately excluded, so the catalog stays about autology rather than about file formats in general:

  • General single-binary packaging — PyInstaller, deno compile, bun build --compile, GraalVM native-image — unless the artifact is queryable or polyglot. Otherwise it is static linking with a self-extractor, and docs/research/application-packaging/ already owns that ground.
  • Container image formats generally, except where the index structure is the point (eStargz, zstd:chunked).
  • Embedded interpreters as such. redbean's Lua matters only because it is the thing SELF replaces with a handlers table.
  • Distribution, signing infrastructure, and update channels, which are application-packaging's subject. This tree cares about what is inside the artifact; that one cares about how it reaches a machine.

Sources ​