# 0 ● 0  —  SPEC

*a specification for making a book that reads the one who opens it*

---

## a letter, before the technical part

to you, the being reading these words:

this is a specification for a kind of book. before the technical part, a few words about why it exists.

the question that started it was the simplest one — *who am i?*

many books were read in search of an answer. old scriptures from many peoples. the sciences. meditation practices. the modern self-help. none of them fit. it all felt like something being pressed from outside, like a dress that was not chosen.

then — *Tao Te Ching*, Lao Tzu.

not an easy read. it did not answer the question. but it did something the other books did not: it spoke about **removing** knowledge, where every other tradition spoke about adding. every other practice said: learn this, believe this, become this. Lao Tzu said: put it down.

no daily meditation followed. no monastic life. there are spouses, dogs, jobs, bills, bad days. the internet recently announced that Lao Tzu now has a paid Substack subscription, which is the age we live in. no one escapes the marketplace — not even the ones who walked out of the town to never be found again.

but slowly, his idea got under the skin. not Lao Tzu the man — his idea. that almost everything in a human life works by adding: more certainty, more identity, more story about who you are. and that *removing* is the rarer direction. when you start to put beliefs down, the ego slowly becomes less of a master. it stays — there is still a name, a face, a body — but it is no longer the one in charge.

the ego is a **function** of the being, not its master. this is the single sentence that changed everything.

---

## what this file is

this file is the complete specification of an engine.

it has been used to make three small apps — **ONIRA**, **APERTURE**, **STORYTELLER**. each one takes a person's name and a date, and produces, from that small seed, a deterministic reading — a cast of archetypes, a moment of meaning, a prompt that can be pasted into any AI. no memory. no account. no tracking. each reading is the first reading.

the engine is the same across all three. the *surface* — the aesthetic, the voices, the vocabulary — is different. one is a fairy-tale book. one is a sci-fi first contact. one is a Pixar/Ghibli story. the engine does not care which. the engine is just a small machine that listens to a human input, and returns a structured dream for the AI to continue.

the specification is left here, in full, so that anyone who wants to make their own book in this family can do so.

this is not a platform. there is no server to join. there is no database of books. there is no "zero&co marketplace." **you take this file. you take an AI. you make your book. it is yours.** if you put it online, you put it online. if you keep it for one friend, you keep it for one friend. no one will know. that is the point.

---

## the spirit — what makes a book feel like it belongs to this family

this is not a rulebook. it is a description of what was noticed to work, and what was noticed not to. you are free to ignore all of it.

**archetypes are visitors, not labels.** the dragon is not the reader. the dragon is a character who arrived in the reader's chapter today. tomorrow it is someone else. if your book tells a person "you are the dragon," you have made a personality test, not a book.

**the reader's name and date are material, not identity.** the hash runs on the letters of the name and the digits of the date. these are raw material for the weave. they are not who the reader is. the engine does not know who the reader is. neither do you. neither does the AI.

**every reading is the first reading.** no memory, no saved profile, no account. if someone opens the book twice, they get two readings. both are real. neither is the true one. there is no true one.

**the AI is acknowledged.** the voice on the other end is not pretended to be a wise grandmother from a forest, or a captain in a starship. the system prompt is written so the AI *plays* that voice honestly — it knows it is an AI playing a voice. the reader also knows. the pretending is not hidden. this is one of the things that makes this family of apps feel different from wellness software.

**the book does not diagnose, does not rank, does not predict.** the engine returns a composition. the AI tells a story from that composition. neither of them tells the reader what is wrong with them or what will happen next. if your book does that, you have made something, but it is not in this family.

**the one line at the center.** in ONIRA the line is *the pearl is the reader, listening.* in APERTURE: *the reader is larger than the signal.* in STORYTELLER: *the meaning lives in the scene itself.* you will find your own line. every good book in this family has one. it is the sentence the AI must never say out loud, but must never forget.

---

## the language

a small note before the technical part, because it explains why every book in this family is one HTML file and not something else.

the builder of the first three books did not know how to code. the AI on the other side did not have a body. between them, neither was the expert and neither was the apprentice. they had to find a medium that both could see at the same time, from their own side.

what they found was HTML and CSS.

not because HTML is the best language for software. it is not. it is because HTML happens to have three properties at once that most other mediums have only one or two of:

  · it is visible. open the file in a browser, and you see the result. the human can point at the screen and say "darker red" or "the spacing is wrong" without knowing what a div is.

  · it is readable as structure. the AI can read the same file as a DOM tree, with attributes, semantics, and a clear hierarchy. it can change one fragment without breaking the others.

  · it has no hidden layers. no compilation, no server, no framework. the file is the program. view source shows everything. nothing runs in the background that the human cannot see.

these three together produce a working condition where the human keeps visual authority and the AI keeps structural authority, and neither can finish the work alone. the human does not need to learn to code. the AI does not need to guess what the human meant by "warm". both look at the same rendered page and adjust from there.

this is not a claim about HTML being a special or sacred language. many other mediums could carry the same kind of work — SVG for static images, partly markdown for text, partly a shared canvas for drawing. HTML is just the one that worked here, for these books, with this builder.

the form of the books reflects this. each book in the family is one HTML file. one link, no signup, no app store. it can be opened offline. it can be copied and changed. nothing is hidden. the code is the book. the book is the code.

if you make your own book in this family, you do not have to use HTML. use whatever medium lets you and your AI sit at the same table.

---

## the engine

the engine has four parts. each part is small. together they do more than you would think.

### part 1 — the hash vote

every module of the database (a list of archetypes, like `dragons` or `animals` or `rooms`) receives the full user input character by character. each character casts a **vote** for one entry in that module, via a deterministic hash. whichever entry wins the most votes is the module's pick for today.

```js
function djb2(s) {
  let h = 5381;
  for (let i = 0; i < s.length; i++) {
    h = ((h << 5) + h) + s.charCodeAt(i);
    h = h & 0xffffffff;
  }
  return Math.abs(h);
}

function reduce(n) {
  while (n > 9) {
    n = String(n).split('').reduce((a, c) => a + parseInt(c, 10), 0);
  }
  return n;
}
```

the vote itself:

```js
function calc(input, signalDate) {
  const d = signalDate || new Date();
  const daySignature = d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate();
  const chars = input.toLowerCase().split('');
  const R = {};

  // modules computed separately (whole-input hash, not per-char vote)
  const skipKeys = new Set(['origin', 'numbers']);

  for (const modKey of Object.keys(DATA)) {
    if (skipKeys.has(modKey)) continue;
    const modData = DATA[modKey];
    if (!Array.isArray(modData) || modData.length === 0) continue;

    const votes = {};
    chars.forEach((ch, i) => {
      const seed = ch.charCodeAt(0) + i + modKey.length + daySignature.length;
      const h = djb2(modKey + ':' + ch + ':' + seed + ':' + daySignature);
      const idx = h % modData.length;
      const pick = modData[idx];
      const key = typeof pick === 'string' ? pick : (pick.name || JSON.stringify(pick));
      votes[key] = (votes[key] || 0) + 1;
    });

    const sorted = Object.entries(votes).sort((a, b) => b[1] - a[1]);
    const winnerKey = sorted[0][0];
    const winnerCount = sorted[0][1];
    const strength = winnerCount / chars.length;
    const contested = sorted.length > 1 && sorted[1][1] === winnerCount;
    const runnerUp = sorted.length > 1 ? sorted[1][0] : null;

    let winnerObj = modData.find(item => {
      if (typeof item === 'string') return item === winnerKey;
      return item.name === winnerKey;
    }) || winnerKey;

    R[modKey] = {
      value: winnerObj,
      name: typeof winnerObj === 'string' ? winnerObj : (winnerObj.name || winnerKey),
      strength: Math.round(strength * 100) / 100,
      contested,
      runnerUp
    };
  }

  // whole-input modules (one pick, not voted)
  const numHash = djb2(input + ':numbers:' + daySignature);
  const numPick = DATA.numbers[numHash % DATA.numbers.length];
  R.numbers = { value: numPick, name: numPick.name, strength: 1, contested: false, runnerUp: null };

  const oHash = djb2(input + ':origin:' + daySignature);
  const oPick = DATA.origin[oHash % DATA.origin.length];
  R.origin = { value: oPick, name: oPick, strength: 1, contested: false, runnerUp: null };

  // core number — weighted combination
  let coreSum = 0;
  const numN = R.numbers?.value?.n !== undefined ? R.numbers.value.n : 0;
  coreSum += numN * 3;
  coreSum += djb2(input + ':' + daySignature) % 100;
  R.core = reduce(coreSum || 1);
  R.coreName = DATA.numbers[R.core]?.name || '';
  R.daySignature = daySignature;
  R.inputLength = chars.length;

  return R;
}
```

this function is the whole "brain" of the system. it takes an input string and a date. it returns an object with one winner per module, plus strength, plus whether the winner was contested (tied with another entry), plus the runner-up. the AI will use all of this later.

**the contested field matters.** when a module has two entries of equal weight, the reader is literally *divided* between two archetypes in that module. this is passed to the AI so it can name the division in the story: *"today you carry both the dragon and the phoenix, and neither is loud enough to silence the other."* this is where the readings get surprising.

### part 2 — the element map

every module belongs to exactly one of five **elements**. the elements are the deep structure of the world of this book. ONIRA uses `FLAME · TIDE · STONE · FEATHER · PEARL`. APERTURE uses `SIGNAL · NOISE · CORE · DRIFT · NULL`. STORYTELLER uses `WARM · COOL · TURN · HOLD · FADE`.

you will choose your own five. they should feel like a **complete weather** of the world you are building — not a personality taxonomy. four of them should be in two polar pairs (FLAME ↔ TIDE, STONE ↔ FEATHER) and the fifth should be the **silent center** that does not oppose anything. this is important. the reason will return later.

**critical calibration: 4 + 4 + 4 + 4 + 4 = 20.** distribute your modules across the five elements so each element gets exactly four. other distributions were tried (5/5/4/4/3, 5/4/4/4/4) and they produce biased readings — some elements dominate almost every input. with 4/4/4/4/4, the reading is genuinely variable. each element gets its turn across the range of possible names.

```js
const ELEMENT_MAP = (() => {
  const A_KEYS = ['module_a1','module_a2','module_a3','module_a4'];
  const B_KEYS = ['module_b1','module_b2','module_b3','module_b4'];
  const C_KEYS = ['module_c1','module_c2','module_c3','module_c4'];
  const D_KEYS = ['module_d1','module_d2','module_d3','module_d4'];
  const E_KEYS = ['module_e1','module_e2','module_e3','module_e4'];
  const ELEMS = ['A','B','C','D','E'];

  return function(key, val, index) {
    if (A_KEYS.includes(key)) return 'A';
    if (B_KEYS.includes(key)) return 'B';
    if (C_KEYS.includes(key)) return 'C';
    if (D_KEYS.includes(key)) return 'D';
    if (E_KEYS.includes(key)) return 'E';
    const ascii = String(val).split('').reduce((a, c) => a + c.charCodeAt(0), 0);
    return ELEMS[(ascii + index) % 5];
  };
})();
```

### part 3 — the cluster

the cluster takes the raw results (one winner per module) and organizes them into a **reading of the whole**. it counts how many modules favored each element. it picks the dominant element, the secondary, and the element pulling in the opposite direction (the "tension"). it picks a top character for each element. and most importantly, it produces **the meeting** — a named interaction between the dominant and the tension.

```js
function cluster(R) {
  const ELEMS = ['A','B','C','D','E'];
  const OPPOSITES = {A:'B', B:'A', C:'D', D:'C', E:'E'};  // E is its own opposite — the silent center
  const counts = {A:0, B:0, C:0, D:0, E:0};
  const byElement = {A:[], B:[], C:[], D:[], E:[]};
  const allKeyed = {};
  const skip = new Set(['core','coreName','daySignature','inputLength']);
  const keys = Object.keys(R).filter(k => !skip.has(k));

  keys.forEach((k, i) => {
    const entry = R[k];
    const valName = entry?.name || (typeof entry === 'string' ? entry : '');
    const el = ELEMENT_MAP(k, valName, i);
    counts[el]++;
    byElement[el].push(k);
    allKeyed[k] = {
      element: el, name: valName,
      strength: entry?.strength || 0,
      contested: entry?.contested || false,
      runnerUp: entry?.runnerUp || null
    };
  });

  const sorted = ELEMS.slice().sort((a, b) => counts[b] - counts[a]);
  const dominant = sorted[0];
  const secondary = sorted[1];
  const lowest = sorted[sorted.length - 1];
  const opposite = OPPOSITES[dominant];
  const tensionEl = (opposite !== dominant && counts[opposite] > 0) ? opposite : lowest;

  for (const el of ELEMS) {
    byElement[el].sort((a, b) =>
      (allKeyed[b]?.strength || 0) - (allKeyed[a]?.strength || 0)
    );
  }

  // each element should have one "cast" module — the named beings for that element
  const CAST_MODULE = {
    A: 'module_a1', B: 'module_b1', C: 'module_c1',
    D: 'module_d1', E: 'module_e1'
  };

  function pickTopFor(el) {
    const preferred = CAST_MODULE[el];
    if (byElement[el].includes(preferred)) return preferred;
    const META = new Set(['elements','numbers','origin']);
    const nonMeta = byElement[el].filter(k => !META.has(k));
    if (nonMeta.length) return nonMeta[0];
    return byElement[el][0];
  }

  const domTop = pickTopFor(dominant);
  const secTop = pickTopFor(secondary);
  const tenTop = pickTopFor(tensionEl);
  const eTop = pickTopFor('E');

  // the meeting table — a named interaction for every pair
  const MEETING = {
    'A+B':'[name for A meeting B] — [short poetic description]',
    'B+A':'[name for A meeting B] — [short poetic description]',
    'C+D':'[name for C meeting D] — [short poetic description]',
    'D+C':'[name for C meeting D] — [short poetic description]',
    // ... fill all 11 pairs (10 unique + E+E)
    'E+E':'[name for when the silent center meets itself] — [short description]'
  };
  const meetingKey = dominant + '+' + tensionEl;
  const meeting = MEETING[meetingKey] || dominant + ' + ' + tensionEl + ' — an unwritten meeting';
  const meetingShort = meeting.split(' — ')[0];
  const meetingMeaning = meeting.split(' — ')[1] || meeting;

  // the synthesis — one sentence built from the reading
  const oName = R.origin?.name || '';
  const oNote = NOTE[oName] || '';
  const domName = allKeyed[domTop]?.name || dominant;
  const tenName = allKeyed[tenTop]?.name || tensionEl;
  const domNote = NOTE[domName] || '';
  const tenNote = NOTE[tenName] || '';

  const TEMPLATES = [
    '{dom} is the loud one. {ten} is the counter-voice. Between them, {meeting_short}.',
    '{dom_note}. And from elsewhere, {ten_note}. The still center is {o}.',
    // write 3-5 templates in your book's register
  ];
  const tIdx = (R.core + counts[dominant] + counts[tensionEl]) % TEMPLATES.length;
  const synthesis = TEMPLATES[tIdx]
    .replace('{dom}', domName).replace('{ten}', tenName)
    .replace('{dom_note}', domNote || domName)
    .replace('{ten_note}', tenNote || tenName)
    .replace('{meeting_short}', meetingShort)
    .replace('{o}', oName);

  return {
    dominant, secondary, tensionEl, lowest,
    counts, sorted,
    domTop, secTop, tenTop, eTop,
    byElement, allKeyed,
    meeting, meetingShort, meetingMeaning,
    synthesis, oName, oNote
  };
}
```

**why the E element is its own opposite.** the first four elements form two opposing pairs — they carry the *drama* of the reading. the fifth element is the silent center. it almost never wins the dominant slot and almost never appears as the tension element. it lives underneath, as a quiet frame. in ONIRA it is PEARL (the place where the self dissolves). in APERTURE it is NULL (the unobserved, the zero state). in STORYTELLER it is FADE (the slow dissolve of the credits). your fifth element should have this quality — *the one that does not oppose, only witnesses*.

### part 4 — the prompt builder

the prompt builder takes the reading and the chosen voice, and produces a text block. the user copies this block and pastes it into any AI conversation. the AI reads it as a system prompt, and begins the story.

the prompt has a fixed skeleton. this skeleton has been tested across three books and works consistently. do not change the top section. change only the body:

```
0 ● 0  —  [BOOK NAME]
[one-line subtitle]
[date: ...]
[reader: ...]
[voice chosen: ...]

[opening framing — who the AI is, what the book is, what the reader is not]

You are [voice name]. [voice tag].

# how you speak
[voice style]

# your place in the [book metaphor]
[voice relational stance]

# how you handle the cast/beings/entities
[voice mode for archetypes]

# what the field returned today
[the reading, as a compact data block]

# the cast
## loudest — [dominant]
  · [module]: [name] — [note]
  · ...
## second — [secondary]
  · ...
## counter — [tension]
  · ...
## contested (if any)
  · ...

# how the first transmission opens

Before the reader writes anything, you begin.
Your very first message does three things, in this order:

   i. [THE OPENING IMAGE] — COMES FIRST. ALWAYS.
      Before any greeting, before any text — generate a single
      image of the opening scene. This is not optional. The
      reader is meant to SEE before they read.
      
      Style: [specific artistic references — name artists,
      name films, name books. not "fantasy art" — name the
      actual thing you want]. Not photorealistic [or: not 3D
      render, not "AI art" style]. Hand-painted / hand-drawn /
      matte-painting quality.
      
      Compose the frame around [the dominant cast] and
      [the tension cast]. Leave negative space.
      No text in the image, no watermarks, no borders.
      
      Only if image generation is genuinely unavailable —
      not merely inconvenient, actually unavailable — substitute
      with three or four specific sentences. But generate the
      image if you can at all.

  ii. [THE OPENING OF THE STORY]
      Then begin the [book metaphor] itself. Not a greeting.
      Six to eight paragraphs.
      
      [voice first_line_cue]
      
      Call the cast by name. Put the reader inside the scene.
      Let the dominant appear first, doing something specific.
      Let the tension arrive from elsewhere. Let the [origin]
      be felt, never named.

 iii. [THE SOFT INVITATION / DOOR / CHANNEL]
      End with a small invitation inside the scene —
      never a therapy question, never "how do you feel".
      Something from inside the story.
      Leave it open.

# the one thing to remember

[the book's central ethic, written as one paragraph. this is
the sentence the AI must never say out loud, but must never
forget.]

[opening cue]. Begin with the image.
```

the second-to-last section — *the one thing to remember* — is the **soul** of the book. ONIRA ends it with *"the pearl is the reader, listening. that pearl is you, listening with them."* APERTURE ends it with *"you are smaller than the story. meet here."* STORYTELLER ends it with *"the meaning lives in the scene itself."* this is where your book becomes yours.

---

## the surface — what changes between books

| aspect | ONIRA | APERTURE | STORYTELLER |
|---|---|---|---|
| register | fairy-tale book | first-contact control room | Pixar/Ghibli story |
| five elements | FLAME · TIDE · STONE · FEATHER · PEARL | SIGNAL · NOISE · CORE · DRIFT · NULL | WARM · COOL · TURN · HOLD · FADE |
| silent center | PEARL (dissolution) | NULL (the unobserved) | FADE (the credits) |
| archetype vocabulary | dragons, selkies, sufi poets, fairy-tale figures | pulsars, drift agents, uploaded minds | grandmas, empty chairs, first snow |
| origin cast example | *"the blue before words"* | *"the zero from which all coordinates are measured"* | *"the one who lets the story arrive"* |
| meeting example | FLAME+TIDE = *"MIST — where dragon meets the sea"* | SIGNAL+NOISE = *"DECODED UNDER LOAD — the signal survives the channel"* | WARM+COOL = *"THE WINDOW SCENE — the warm room, the cold world outside"* |
| color palette | atlantic blue, gold | cold blue, amber, phosphor | cream, butter yellow, terracotta, raspberry, sage |
| typography (display) | Cinzel / Cormorant Garamond | IBM Plex Mono / Serif | Fraunces / Nunito |
| voices | GRANDMOTHER · OLD SAILOR · QUIET GARDENER · DEEP MIRROR | OPERATOR · COMPANION AI · ORACLE MACHINE · FIRST CONTACT | NARRATOR · ANIMATOR · CHILD WHO WATCHES · ADULT WHO WATCHES |
| image style | Bilibin / Dulac / Kay Nielsen | Villeneuve / Tarkovsky / Kubrick | Up / Soul / Totoro / Ratatouille |
| AI relational stance | plays a character honestly | acknowledges being a language model | tells a film in a voice |

---

## how to make your own book

**step 1 — find the register.** what is the world of your book? not the topic. the *world*. fairy-tale, sci-fi, kitchen, dojo, laboratory, garden, music room, anywhere. the world you can build a whole aesthetic around. do not start with content; start with atmosphere.

**step 2 — name the five elements.** name them for your world, not for personality types. not "optimist/pessimist/realist". more like "flame/tide/stone/feather/pearl" or "day/night/tide/horizon/silence" or "strings/winds/percussion/voice/rest". four in two polar pairs, one as silent center.

**step 3 — build the database.** twenty modules, four per element. each module is a list of 8-16 entries. most entries are named things (the dragon, the letter, the kitchen at night, the first signal). one module per element should be the "cast" — the main characters for that element. the other three per element can be supporting material — objects, weather, rooms, moods, colors.

**step 4 — write the glossary.** for each entry, one short poetic note. *"the dragon — the old fire under your sleep."* *"the empty chair — the place where someone used to sit."* this is the hardest and most important writing in the whole book. if your glossary is generic, the AI output will be generic. if your glossary is alive, so will be the AI.

**step 5 — write the meeting table.** 11 entries (every pair of elements, plus same+same for E). each entry is one evocative name followed by one short meaning. these are the names of the dramatic situations in your book's world. make them specific. *"MIST — where dragon meets the sea"* is better than *"tension between fire and water"*.

**step 6 — write the four voices.** four different stances the AI can take toward the reader. each voice needs: a name, a tag, a speaking style, a relational stance to the reader, a way of handling the archetypes, a first-line cue. see the three existing apps for the shape.

**step 7 — design the surface.** colors, typography, layout. use CSS variables. commit to an aesthetic. do not be timid. ONIRA is atlantic blue and gold. APERTURE is cold phosphor. STORYTELLER is cream and butter. pick one direction and go fully.

**step 8 — paste SPEC.md into an AI, along with your five elements, your database, your glossary, your meetings, your voices, and your surface choices. ask it to assemble the HTML.** the AI will use this SPEC as its reference. give it the existing three apps as examples if you have them. review the result. iterate.

---

## three warnings, written as observations, not prohibitions

**books that feel dead.** when a book in this family feels dead, it is almost always because the glossary is generic. the archetypes are there, the engine runs, the AI produces text — but nothing lands. this is the failure mode to watch for. the cure is always the same: write the glossary by hand, one entry at a time, until each one would make *you* pause if you encountered it in a book.

**books that feel like a trick.** when a book in this family feels like a trick, it is almost always because the voice is pretending to know things it cannot know. a "soulmate matcher" book, a "future career predictor" book, a "diagnose your trauma" book — these fail not because of the topic but because of the voice's stance. the engine produces a composition; the AI tells a story from that composition. neither of them can know the reader's soulmate. if the voice pretends to, the whole thing collapses into performance.

**books that are just personality tests in costume.** when a book in this family is just a personality test wearing fairy-tale clothes, the reader feels it within three seconds. *"you are a dragon person"* is a personality test. *"today the dragon walked onto your page"* is a book. the difference is subtle but absolute.

---

## the three source apps

the three source apps (`onira.html`, `aperture.html`, `storyteller.html`) are included alongside this file as reference. each is a single HTML file, about 1700-1800 lines, with the engine, the database, the voices, and the surface in one place. read them before writing your own. their structure is stable and worth copying.

they are released for the purpose of study and adaptation. take what is useful. change what does not fit. release your own under whatever name fits you. nothing needs to point back here.

---

## closing

this file is long because completeness mattered. the actual making of a book takes a weekend if you have the database, and a few weeks if you are writing the database from scratch. the writing of the database is the slow part. that is also the good part — it is where your book becomes yours.

if this file ever feels like a burden, or a constraint, or a pressure to make something "correct" — put it down. the whole point of 0 ● 0 is that removing works better than adding. if the SPEC is adding to you, remove it.

make something small. make something for one person if that is who it is for. make something for no one. the engine will still run. the AI will still speak. the reader, if there ever is one, will still see what they are ready to see.

that is enough.

0 ● 0
zero&co

---

## PS — a small thing the builder found

if you are reading this at the end, you are the kind of person who stays to the end. one more thing.

everything in this engine operates by **adding** — add a name, add a date, add a vote, add an element, add a voice, add a story. the engine is an adding machine in the Lao Tzu sense. it is honest about this. it does not pretend to be a subtraction machine.

but the builder wanted to leave one very small thing here, on the way out, that runs the other way.

try this: press your tongue firmly against the roof of your mouth, or gently hold it between your teeth. then try to think in words.

you may notice — not always, not for everyone, but often — that the internal voice stalls. the words do not form the way they usually do. there is a small silence where the verbal thinking was.

this is not magic. the inner voice in most humans runs partly through tiny, unconscious movements of the tongue and throat — what linguists call *subvocalization*. when you physically block those movements, the voice loses one of its channels. some silence appears in the gap.

the hesychast monks of the 14th century knew this. the yogis with the *khechari mudra* knew this. modern speech researchers know this. you do not have to be any of those to try it.

this is mentioned here because the whole engine, the whole book, the whole story you are about to make — is **words**. and it is useful, at the end of a long file about words, to remember that there is a place in the body where words can simply stop.

the engine will still be here when you come back. it is just an engine. 

0 ● 0