Open data & replication

Everything that went into these translations, and everything we used to check them, is downloadable here. The goal is not just trust — it is replication. Take the texts, run the checks, copy the pipeline, and put another ancient author back in circulation.

1 · The texts — sources, old translations, ours

The original-language sources we translated from (public domain: Perseus Digital Library, Niese's Josephus, Cohn-Wendland's Philo, the Latin Library), the classic public-domain English translations we measured against (also free — they are monuments, and deserve reading), and our own editions:

All source and classic-translation files are public domain. Our translations are free to read and share; see the colophon for the method and disclosure.

2 · The replication notebook

A runnable Jupyter notebook that recomputes the quality-page numbers live against this site — archaism rates, independence scans, completeness gates. Open it in Google Colab and press run.

import requests, re, statistics
BASE = "https://scriptorium-press.pages.dev"
def fetch(path):
    r = requests.get(f"{BASE}/{path}"); r.raise_for_status(); return r.text
def words(t): return re.sub(r"[^a-z0-9 ]", " ", t.lower()).split()

ARCH = re.compile(r"(thee|thou|thy|thine|hath|doth|dost|unto|wherefore|thereof|therein|whither|"
                  r"thither|hither|verily|spake|saith|shalt|wilt|ye|nay|forsooth|whosoever|peradventure|"
                  r"howbeit|betwixt|nigh)", re.I)
for label, path in [("Macaulay 1890", "sources/herodotus-old-translation.txt"),
                    ("Plainspoken 2026", "books/herodotus.txt")]:
    t = fetch(path); n = len(t.split())
    print(f"{label}: {len(ARCH.findall(t))/n*10000:.1f} archaisms per 10k words ({n:,} words)")

def shared_runs(a, b, n=8):
    wa, wb = words(a), words(b)
    grams = set(tuple(wb[i:i+n]) for i in range(len(wb)-n+1))
    runs, i = 0, 0
    while i < len(wa)-n+1:
        if tuple(wa[i:i+n]) in grams:
            j = i+n
            while j < len(wa) and tuple(wa[j-n+1:j+1]) in grams: j += 1
            runs += 1; i = j
        else: i += 1
    return runs
ours = fetch("books/hesiod.txt"); pd_old = fetch("sources/hesiod-old-translation.txt")
print("Hesiod, ours vs Evelyn-White (1914):", shared_runs(ours, pd_old), "shared 8-word runs (site claim: 0)")

import json as _json
man = _json.loads(fetch("browse.json"))
for slug in ["herodotus", "hesiod"]:
    total = sum(w["w"] for w in man[slug])
    print(f"{slug}: {len(man[slug])} works, {total:,} English words — per-work word counts in browse.json")
print("Full per-section source/English alignment data: the sources/*.txt and books/*.txt pairs above.")

3 · The harness — how this was actually built

The whole pipeline runs on Claude Code, Anthropic's agent harness. The pieces you need to replicate it:

• A charter — one shared prompt defining voice, naming conventions, and integrity rules, pasted into every agent.
• Section-aligned batching — split the source into ~1,500-word batches; require exactly one English section per source section so completeness is machine-checkable.
• Subagent fleets — Claude Code's workflow/subagent system runs hundreds of translator agents in parallel (Claude Sonnet), each writing a JSON batch file.
• Mechanical gates — count checks and word-ratio screens on every batch; failures re-run automatically, twice-failed batches escalate to Claude Fable 5.
• An independent referee — Claude Opus agents re-read the source behind samples of every book and file findings.
• A final pen — Claude Fable 5 arbitrates findings, rewrites anything flagged, and runs the independence rewrites until the 8-word scan reads zero.

The division of labor came from head-to-head trials, not assumption — the full story is in the colophon, and the measured results in the quality page. If you build one of these for another author or another language, we would genuinely love to hear about it.

4 · The audiobooks — how every hour of audio was made

All ~260 hours of audio were generated locally on one consumer GPU (an RTX 3060) with Kokoro-82M, an open-weight text-to-speech model. Nothing here needs a cloud service or a paid API. The full recipe:

• Chunking — each book's final published text is split into parts of roughly half a chapter, so a failed run resumes at the last finished part instead of starting over.
• Dialogue casting — for dialogue works (Plato), a regex catches speaker labels (SOCRATES:, CRITO: …) and a fixed cast table gives each speaker one of 2–4 distinct Kokoro voices, so conversations are listenable as conversations. Narrative works use a single narrator voice.
• Encoding — every part is encoded straight to 48 kbps mono 24 kHz MP3: transparent for spoken word, and it keeps the whole library small enough to serve free forever (gigabytes, not tens of gigabytes).
• The manifest — ffprobe measures each part's exact duration into audio-manifest.json. The site's player uses it to present one continuous whole-book timeline: dragging the slider picks the right part and an offset does the rest. (We built that because free static hosts often ignore HTTP Range requests, which breaks native audio seeking.)
• Read-along — the follow-along highlighting pans through each part's text proportionally to playback time using the same manifest; no forced-alignment model needed at this accuracy.

Kokoro is Apache-licensed and runs from Python in a few lines (pip install kokoro soundfile, then generate 24 kHz audio and pipe it through ffmpeg -ac 1 -ar 24000 -b:a 48k). One mid-range GPU renders speech at several times real-time, so a full ancient library is a weekend of compute, not a studio budget.

← back to the library