Specification
Goethe Format 1
The open file format of Goethe Write: the project package (.goethe) and the exchange file (.goethex)
| Status | Version 1.0 (format 1), published 2026 |
|---|---|
| Describes | exactly what Goethe Write writes and reads today |
| Names | .goethe, .goethex, com., com. and application/ are final. They never change. |
| Licence | This specification: CC BY 4.0, © 2026 ICSL FZE. The JSON Schemas (schema/) and the reference reader (reference/): MIT. See section 12. |
| Publisher | ICSL FZE, Sharjah, United Arab Emirates; questions to hello@lexxington.com |
| Address | https:// |
| Short German version | Goethe-Format 1 – Kurzfassung |
The key words MUST, MUST NOT, SHOULD, SHOULD NOT and MAY are used as in RFC 2119 and RFC 8174.
1. Overview
A Goethe Write project holds a manuscript (a novel, a non-fiction book, a legal brief, a screenplay) together with everything around it: the outline, characters and places, research files, comments and tracked changes, saved versions, the story's facts and timeline, the settings for export, and the place where the writer stopped.
The format has one content in two forms:
| Project (package) | Exchange file | |
|---|---|---|
| What it is | a folder with the extension .goethe, shown by macOS and iOS as one document | the same entries as one ZIP file with the extension .goethex |
| What it is for | working: quick to save, good for Git and Time Machine | sending: mail, cloud, agencies, other programs |
| First entry | – | mimetype, stored, holding application/ (as in EPUB and OpenDocument) |
| Equal when | the files are equal | the unpacked entries are equal (not the ZIP bytes) |
The content of both forms is the same: manifest. (version), project. (outline, knowledge, settings), texts/ (one RTF text per entry), files/ (research files), snapshots/ (saved versions), and a few optional parts.
1.1 Names and type identifiers
| Project | Exchange file | Older projects | |
|---|---|---|---|
| Extension | .goethe | .goethex | .lexwrite |
| Uniform Type Identifier | com. | com. | com. |
| Conforms to | com., public. | public., public. | com., public. |
| MIME type | – (a folder; send the exchange file instead) | application/ (not yet registered, Appendix A) | – |
| Name in the Finder (English) | Goethe Write Project | Goethe Write Exchange File | Goethe Write Project (old) |
| How Goethe Write declares it | exported; document type with role Editor, rank Owner | exported; role Editor, rank Owner | imported; role Editor, rank Alternate |
- The exchange file deliberately does not conform to
public.: otherwise the Finder would offer to unpack it with the Archive Utility instead of opening it in Goethe Write.zip-archive - The names are declared in the
Info.of the Mac app and of the iPhone and iPad app. The document icons are drawn by the system from the app icon.plist .lexwriteis the extension Goethe Write used before the format had its name. Such a project is the same format (version 1). Goethe Write opens it and saves it in place under its old name. The first time the person saves it with ⌘S, Goethe Write asks once whether it should take the new extension; if yes, it is saved under the new name with "Save As", and the old file stays as it was. Nothing is ever renamed without asking.
1.2 Terms
| Term | Meaning |
|---|---|
| package | the .goethe folder (or .lexwrite) |
| exchange file | the .goethex ZIP file |
| entry | a file or folder of the package, named by its path relative to the package (texts/); in the exchange file a ZIP entry with the same path |
| node | an entry of the outline (project.): a root, a folder, a text, a character, a place or a research file |
| text | the formatted text of a node, an RTF file in texts/ |
| anchor | a passage in a text, given by the node, a start and a length (section 6.4) |
| Goethe Write 1 | the app version this specification describes |
2. Versions: manifest.json
2.1 The manifest
manifest. lies at the top of the package. Goethe Write writes it on every save:
{
"format" : 1,
"generator" : "Goethe Write 1.0 (100)",
"kind" : "project",
"readableFrom" : 1
}
| Key | Type | Meaning |
|---|---|---|
format | integer ≥ 1 | The version of this specification the package was written in. |
readableFrom | integer ≥ 1 | A reader of at least this version may open, edit and save the package without losing anything. Never greater than format. |
kind | string | What the package holds. Version 1 knows only "project". |
generator | string | The app and version that wrote it. Informative only; never a person's or device's name. |
- Goethe Write writes the keys in byte order, two spaces of indentation,
"key" : value, a line feed at the end. The same manifest gives the same bytes on every device. - A package without
manifest.is version 1. Every project saved before the manifest existed is such a package. A manifest that is not a JSON object counts as missing. A missing or non-integerjson formatorreadableFromcounts as 1. - The manifest is rewritten on every save. Keys a writer does not know are not kept (they might no longer be true).
- In version 1 the manifest lists no files and no checksums. A later version adds them (section 10).
2.2 Reading rules
A reader that implements version R of this specification:
| Manifest says | The reader |
|---|---|
readableFrom > R | MUST NOT open the package for editing. Goethe Write refuses it with the sentence "This project needs a newer version of Goethe Write (format n). Please update Goethe Write to open it." |
kind is present and not a kind it knows | MUST NOT open it as a project. |
format > R, readableFrom ≤ R | MAY open and edit it. It MUST keep every file and folder it does not know, MUST NOT lower format when saving, and SHOULD set generator to itself. |
format ≤ R | reads it normally. |
2.3 Rules for later versions
- A later version that only adds (a new file or folder, a new optional key in a file older writers do not rewrite) raises
formatand keepsreadableFrom. - A later version that would be damaged by an older writer, or that older readers would misread, raises
readableFromas well. - Important: Goethe Write 1 does not keep keys it does not know inside
project.(section 5.1). A later version that adds data which must survive Goethe Write 1 therefore puts it into a new file, which Goethe Write 1 keeps byte for byte, or raisesjson readableFrom. - Version numbers are never reused, and the meaning of a key is never changed.
2.4 project.json › format is not the package version
project. has a key format of its own. It is the layout number of that one file and is 2 in every package of version 1. Goethe Write requires the key but does not look at its value. Readers decide by manifest., never by this number.
3. The project package (.goethe)
3.1 Layout
Mein Roman.goethe/
manifest.json version (section 2); written by Goethe Write 1, may be missing in older packages
project.json outline, knowledge, settings, the person's window (section 5); required
texts/ always present, may be empty
<NODE-ID>.rtf the text of a node (section 6)
<NODE-ID>.rtfd/ … or, when it holds pictures, an RTFD folder: TXT.rtf and the pictures
files/ always present, may be empty
<NODE-ID>[.<ext>] the bytes of a research file (PDF, picture, document) (section 7.1)
snapshots/ always present, may be empty
<SNAPSHOT-ID>.rtf | .rtfd/ saved versions of texts (project.json › bible.snapshots)
deleted/ only when not empty
<DELETED-ID>.rtf | .rtfd/ deleted passages with their formatting (project.json › bible.deleted)
guides.json optional: page guides (section 7.3)
watermarks/ optional: the picture of the watermark, <sha256>.png (section 7.2)
… anything else: kept by Goethe Write byte for byte (section 3.3)
<NODE-ID>and the other ids are UUIDs, written in upper case (0B5E2A9C-342B-429E-82C0-D92D21910489). Goethe Write reads them in any case.- The extensions
rtfandrtfdare lower case; Goethe Write ignores a text file with another extension. - Every node that is not a research file has a text file, also the roots and folders, also when the text is empty (an empty text is a short RTF with only its header). A node without a text file has an empty text.
- Text, research, snapshot and deleted files that no node or entry of
project.refers to are dropped by Goethe Write on the next save.json
3.2 Reserved names
These names at the top of the package are reserved. A writer MUST NOT use them for anything else:
| Name | Use |
|---|---|
manifest., project., texts, files, snapshots, deleted, guides., watermarks | version 1 (this specification) |
mimetype | only in the exchange file; a package never has it. Goethe Write removes it from a package when it saves. |
scripts, media, sync, migration, QuickLook, goethe. | reserved for planned versions (screenplays as their own part, media, working together, previews) |
Names are case-sensitive in the format. Because the usual file systems of macOS and iOS are not, a writer MUST NOT create two names that differ only by case or by Unicode normalization.
3.3 Unknown entries
- An entry at the top of the package that Goethe Write 1 does not know is kept byte for byte on every save (files, and folders with everything in them).
- Inside
texts/,files/,snapshots/anddeleted/nothing unknown survives: Goethe Write rebuilds these folders fromproject..json - Two known entries Goethe Write manages itself:
guides.is rewritten when a guide is edited (section 7.3), and pictures injson watermarks/that no setting names are removed when the project is opened (section 7.2).
3.4 Saving safely
A writer SHOULD write a complete new package beside the old one and then replace the old one in one step, so that a reader never sees half a package. Goethe Write does this through the system's safe saving of documents. Unchanged files may be reused (hard links, clones).
4. The exchange file (.goethex)
4.1 ZIP profile
The exchange file is a ZIP archive (PKWARE APPNOTE) restricted as follows:
| Rule | |
|---|---|
| First entry | MUST be mimetype: stored (method 0), no extra field, no data descriptor, content exactly application/ (ASCII, no line feed). Its name thus stands at byte 30 and the type at byte 38 of the file, where programs can recognise it. |
| Second entry | SHOULD be manifest., so a reader learns the version first. |
| Other entries | every file of the package with its path; folders as entries of their own whose names end in / (writers SHOULD write them, so empty folders come back; readers MUST NOT need them). Goethe Write writes them in the byte order of their paths. |
| Packing | only stored (0) and DEFLATE (8). Goethe Write packs an entry with DEFLATE when it gets smaller and is larger than 64 bytes. |
| Names | UTF-8 (general purpose bit 11 set when a name is not ASCII), / as separator, relative. Section 4.3 lists what is not allowed. |
| Not allowed | encryption (bits 0, 6 and 13), other packing methods, symbolic links, ZIP64, archives on several disks |
| Size in version 1 | below 4 GB and below 65,535 entries (no ZIP64). Larger projects cannot be exchanged in version 1. |
| Times | the time of writing, as the ZIP fields allow (informative) |
| Permissions | made by Unix: folders 0755, files 0644 (informative) |
The mimetype entry is not part of the package. Unpacking an exchange file gives the package without it; packing a package adds it.
4.2 Equality
Two exchange files are equal when their unpacked entries are equal: the same paths with the same bytes, mimetype left aside. Their ZIP bytes differ with the time of writing and the packer, and nothing may depend on them. Goethe Write's own tests compare the unpacked entries (section 11).
4.3 Reading safely
A reader MUST refuse an exchange file, with a reason, when:
- it is no ZIP archive, it has no entry
mimetype, ormimetypeholds another type (after trimming white space); - an entry name is empty, absolute (
/…), contains..or.as a part, an empty part (a//), a backslash, a drive (b C:), a control character (U+0000–U+001F, U+007F), or a part longer than 255 bytes; - two entries have the same name, also when they differ only by case or Unicode normalization (except a folder listed twice);
- a path runs below a file (
ais a file anda/an entry);b - an entry is a symbolic link (made by Unix with file type
0120000), encrypted, or packed with another method; - a checksum (CRC-32) does not match, an entry unpacks to more or fewer bytes than its central directory says, two entries share bytes ("overlapping" entries), or the local header disagrees with the central directory;
- it uses ZIP64 or several disks;
project.is missing;json manifest.asks for a newer reader (section 2.2).json
A reader SHOULD ignore entries below __MACOSX/ and entries named .DS_Store (what the Finder adds when it packs a folder), and SHOULD accept mimetype at another place than first, as long as its content is right.
Limits. A reader SHOULD set limits and MUST NOT unpack more than an entry declares. Goethe Write 1 refuses an exchange file with more than 50,000 entries, more than 2 GiB unpacked, paths longer than 1,024 bytes or deeper than 32 folders, or an entry of 16 MiB or more that unpacks to more than 200 times its packed size. These limits belong to the reader, not to the format; another reader may choose others.
Goethe Write never follows a link, never writes outside the package, needs no network and runs nothing from the file.
4.4 Opening and writing an exchange file in Goethe Write
- Mac: Opening a
.goethex(double-click, File ▸ Open, Open Recent) makes its project a new, untitled project with the file's name. The person saves it where they like; closing asks where to keep it, and until then autosave keeps it safe. The exchange file itself is never written to. Opened again while that copy is unsaved, the copy comes to the front. - iPhone and iPad: Opening a
.goethexcopies its project into the app's folder ("On My iPhone › Goethe") as a.goethepackage, under the file's name (with a number if that name is taken), and opens it. - Writing: File ▸ Export As ▸ "Goethe Write Exchange File (.goethex)" writes the whole project as it is at that moment, with its manifest, into a temporary file and then moves it into place.
- What an exchange file carries: everything in the project, including saved versions, deleted passages, comments with names, tracked changes and the research files (section 9).
5. project.json
project. holds everything of the project except the texts and files: the outline (tree), the knowledge about the story or the case (bible), the settings (settings), the window as the person left it (window), and a few values beside them. The JSON Schema schema/ describes every key below.
5.1 Encoding
- UTF-8 JSON, one object. Goethe Write writes it with Apple's JSON encoder: indented by two spaces,
"key" : value, keys sorted. Key order has no meaning; the sort order is the encoder's and need not be plain code-point order. /inside strings is written as\/. Other characters stand as UTF-8.- No
nullis written. A key that is absent means "not set". Readers treatnulllike an absent key for every optional value. - Numbers: integer keys hold whole numbers. Decimal keys hold numbers; a whole decimal value is written without a fraction (
12), so readers MUST accept integers where a number is expected. NaN and infinities never occur. - Times: ISO 8601 in UTC with whole seconds,
"2026-11-12T10:00:00Z". Readers SHOULD also accept fractional seconds and offsets. Older files wrote times as a number: seconds since 2001-01-01T00:00:00Z (not 1970). - Days (
days,goals.) are local calendar daysdeadline yyyy-MM-ddwithout a time zone. - Ids are UUIDs written in upper case; readers compare them without regard to case.
- Unknown keys are ignored by Goethe Write 1 at every level and are not kept on the next save (section 2.3).
- Order of arrays is meaningful (outline, paragraphs, lists the person sorted) except where this section says otherwise. The top-level
expandedis written from a set: its order changes between saves and means nothing. Apart from that array, the same project gives the same bytes.
In the tables below, Req "yes" means Goethe Write 1 refuses to open a file without that key (or with a value of the wrong type there). All other keys may be absent; "Default" says what absence means. Types: uuid (a string), time (a string as above), int, number, bool, string, [T] an array of T, {string: T} an object whose values are T.
5.2 Top level
| Key | Type | Req | Default | Meaning |
|---|---|---|---|---|
format | int | yes | – | Layout number of this file: 2 (section 2.4). |
tree | [Node] | yes | – | The roots of the outline in sidebar order (5.5). An empty array opens as a new blank project. |
dailyGoal | int | yes | – | Words a day for the manuscript; 0: none. |
days | {day: int} | yes | – | Manuscript words when each day began (at most the latest 60 days). Words written today = words now − days[today]. |
expanded | [uuid] | yes | – | Legacy copy of window. for older versions of the app; order without meaning. Read only when window. is absent. |
selection | uuid | the first text of the manuscript | The selected node. | |
bible | Bible | empty | Knowledge about the story or the case (5.6). | |
settings | Settings | defaults, with storyTools: true | Settings of the project (5.7). | |
collapsed | [uuid] | – | Legacy: folded sidebar sections; read only when window. is absent; never written. | |
window | Window | defaults | The window as the person left it (5.8). | |
goetheLog | [LogEntry] | [] | What the assistant Goethe changed, if the person keeps a record (5.9). Written only when not empty. | |
manuscriptGoal | Goal | taken over once from the reading Mac's preferences | The manuscript's goal or limit (5.9). |
5.3 What makes Goethe Write 1 refuse a file
Goethe Write 1 refuses to open a project, rather than guess, when:
- a key marked Req is missing or has the wrong type, at the top level or in any object of
tree,bible(outsidecurves,orderandgoals) orgoetheLog(insidesettings.andstyles settings.andauthorWorkspace. beats draftssuch a fault only empties that list, see below); - a value of a strict list of words (5.10) is unknown;
- a time string cannot be read, also in an optional key.
Some places are forgiving and fall back instead (marked "lenient" below). Where a whole list falls back because one element is broken, the next save makes that loss permanent: settings. (back to the five default styles), settings. and drafts (empty), bible. (empty), bible. (empty). Writers of other programs MUST therefore write every Req key, also those whose meaning is "empty".
5.4 Migrations on reading
Goethe Write 1 changes a few things once when it reads a project; the next save writes the result. A project that was read and saved once does not change again when it is read and saved (Goethe Write's tests check this, section 11).
| What | Change |
|---|---|
bible. (older character beats) | each becomes entries of bible. (fields "Ziel", "Angst", "Beziehungen", or "Notiz"); beats is then written empty |
bible./page, bible./page | where the item has an anchor of length > 0, they become an entry of bible. and are cleared |
settings., settings. | the tools shown by their groups are written down once, and "tools" goes into takenOver |
settings./selectedDraft | move to window./window. |
legacy keys of window (5.8) | move to this Mac's own store and are no longer written |
watermarks/ | pictures no setting names are removed (7.2) |
manuscriptGoal absent | a character limit kept in the Mac's preferences becomes the project's goal |
5.5 The outline: tree
tree holds the roots. Each root has a kind; the first root of each kind counts:
| Root kind | Holds |
|---|---|
manuscript | what is exported, in reading order (depth first) |
characters | nodes of kind character |
places | nodes of kind place |
research | research texts, files and links |
trash | "Recently Deleted": deleted nodes, newest on top; created when needed |
Root titles are stored in German (Manuskript, Figuren, Orte, Recherche, Zuletzt gelöscht) and shown in the person's language; programs find roots by their kind, never by title.
Node
| Key | Type | Req | Default | Meaning |
|---|---|---|---|---|
id | uuid | yes | – | Identity. Names texts/ and files/. Unique in the whole tree. |
kind | NodeKind | text | lenient: an unknown kind is read as text. | |
title | string | "" | Shown as "Untitled" when empty. | |
synopsis | string | "" | Short description (on the card). | |
status | WriteStatus | none | How far the text is; lenient. With ownStatus, the step that status counts as. | |
label | WriteLabel | none | Colour tag; lenient; written only when set. | |
includeInExport | bool | true | ||
children | [Node] | [] | Children in outline order. Texts may have children too. | |
notes | string | "" | Notes beside the text; not exported. | |
target | int | 0 | Word goal; 0: none. For a folder or a text with children it counts all words below. | |
pov | string | "" | Point of view: a name, not an id. | |
place | string | "" | Where the scene takes place: free text, not an id. | |
when | string | "" | The time as the writer writes it ("Tag 3, abends"). | |
date | time | none | The date on the timeline. | |
threads | [string] | [] | Plot lines. | |
links | [uuid] | [] | Characters, places and research linked by hand. | |
aliases | [string] | [] | Other names of a character or place. | |
fields | [Field] | [] | Named values: profile fields, values of the project's own fields (keyed by MetadataDefinition.), the ratings "Spannung" and "Stimmung" (0–5) and "Konflikt". | |
file | string | none | Original file name of a research file ("Kaufvertrag.), for display. The bytes are in files/ (7.1). | |
url | string | none | A web page; a node with url and no file is a web link. | |
origin | uuid | none | In the trash: the parent it was deleted from. | |
lockedForGoethe | bool | not locked | The assistant Goethe never reads this node or anything below it. Written only as true. | |
keywordList | [string] | [] | Keywords; written only when there are some. | |
ownStatus | uuid | none | A status of the project's own (bible.); lenient. |
Field: id (uuid, Req), name (string, Req), value (string, Req). Names are compared trimmed and without regard to case.
5.6 The knowledge: bible
All keys of bible are optional (default: empty). Goethe Write writes every list, also when empty, and order and goals only when they hold something.
| Key | Type | Meaning |
|---|---|---|
characterRelations | Relations | the relationship map |
facts | [Fact] | setups and payoffs |
knowledge | [Knowledge] | who learns or uses which fact, and where |
beats | [CharacterBeat] | legacy (5.4) |
changes | [Change] | how characters and places develop |
travel | [Travel] | travel times between places |
rules | [WorldRule] | rules of the story's world |
sources | [SourceLink] | evidence for passages |
comments | [Comment] | comments with replies |
collections | [Collection] | saved selections |
rounds | [Round] | revision rounds, in creation order |
snapshots | [Snapshot] | saved versions, newest first |
deleted | [Deleted] | deleted passages, newest first, at most 200 |
intended | [string] | ids of warnings marked as intended (opaque strings) |
arguments | [Argument] | the argument map |
clauses | [Clause] | text modules |
variables | [Variable] | values used in texts |
terms | [Term] | defined terms |
events | [CaseEvent] | the case's chronology with statements |
roles | [RoleMark] | roles of passages (own submission, the other side's …) |
approvals | [Approval] | approvals of texts |
tracked | [TrackedChange] | tracked changes |
literature | [LegalSource] | the bibliography |
statements | [Statement] | statements of the text and how they relate |
relations | [Relation] | relations between statements, passages, nodes and questions |
questions | [Question] | open questions |
reviews | [Review] | review state per node and dimension |
metadata | [FieldDefinition] | the project's own fields |
clauseUses | [ClauseUse] | where text modules were inserted |
curves | [Curve] | curves the writer drew (lenient as a whole list) |
order | OrderLists | own names of statuses and colours, own statuses, keywords (lenient) |
goals | GoalPlan | deadline and writing days (lenient) |
Every anchor in the bible moves with the text when the text is edited (section 6.4).
Anchor: node (uuid, Req), location (int, Req), length (int, Req; 0 marks a position), quote (string, Req: the passage when the anchor was made or last refreshed).
Relations (characterRelations; every key optional): edges [Relation edge]; groups [Group]; positions {string: {x: number, y: number}} (key: a character's node id in upper case; the card's top-left corner in canvas points, placed by hand; used only when finite and within ±1,000,000); dismissed [string] (declined suggestions: two upper-case ids, sorted, joined by |).
- Relation edge:
id(uuid; missing: a new one),from,to(uuid, Req: character nodes;roledescribesfromin relation toto),kind(string:family,love,friendship,rivalry,work,other, or an own word; missing: derived fromrole),role,inverseRole,note(string),directed(bool, defaulttrue),startScene,endScene(uuid: the scenes between which it holds, inclusive). - Group:
id(uuid),title(string),members([uuid]),color(int, one of 8 colours, modulo 8).
Fact: id (uuid), kind (FactKind), title, detail (string), openOnPurpose (bool) — all Req; setup (uuid: the scene that introduces it), payoff (uuid: the scene that resolves it; absent: still open).
Knowledge: id, fact (a Fact id), character, scene (uuid), kind (learns or uses) — all Req.
CharacterBeat (legacy): id, character, scene (uuid), goal, fear, relationships, note (string), turningPoint (bool) — all Req.
Change: entity (uuid: a character or place), scene (uuid: from this scene on) — Req; id (uuid; missing: a new one), field, value, note (string), turningPoint (bool). The value at a point of the reading order is the last change at or before it.
Travel: id, from, to (uuid: places), hours (number; both directions) — all Req.
WorldRule: id, title, detail, kind (forbidden: none of the patterns may appear; requires: where the first pattern appears, one of the others must appear in the same scene), patterns ([string]: words, or regular expressions in slashes /teleport\w*/), threads ([string]: only these plot lines; empty: everywhere), enabled (bool) — all Req.
SourceLink: anchor (Req); id (uuid; missing: a new one), research (uuid: the research node), page, quote, note, checkedText (string: the passage as it read when checked), sourceDigest (string: lower-case hex SHA-256 of the research item when checked — its file bytes, else its URL, else its text, as UTF-8), verified (bool), checkedAt (time).
Comment: id, anchor — Req; text, author (string), date (time; missing: the time of reading), resolved (bool), replies ([Reply], oldest first). Reply: id, author, text, date — all Req.
Collection: id, title, statuses ([WriteStatus], strict), labels ([WriteLabel], strict), pov, thread, place, text (string), openWork (bool) — all Req, an empty value means the rule is not used; optional: character (uuid), manual ([uuid]: when present, even empty, the collection holds exactly these nodes in this order and the rules are ignored), ownStatuses ([uuid]), keywords ([string]: a node must have all), fieldRules ([{field: uuid of a FieldDefinition, value: string}], both Req: text, number and person fields contain the value; a choice equals it; a multiple choice has it among its comma-separated values; check and date fields: "1" set, "0" not set).
Round: id, title, goal, color (int 0–5: blue, red, green, purple, orange, teal), started (time), targetWords (int; 0: none) — all Req; finished (time; absent: still running — the last running round is the active one).
Snapshot: id (its text is snapshots/), node, title, date, words (int), variant (bool: true an alternative, false a backup) — all Req.
Deleted: id (newer entries also have deleted/), node, text (the words, fields as their values), date — all Req.
Argument: id, kind (claim, evidence, counter, rebuttal, conclusion), title, detail, page — Req; parent (uuid: the argument it supports, attacks, answers or concludes; absent: a main claim), anchor, research (uuid; see 5.4).
Clause: id, title, category, note (string), variants ([Variant]) — all Req. Variant (all optional): id, title, body (text with variables {{Name}} and conditions {{#wenn Name}} … {{/), approved (bool), approvedBy (string), approvedDate (time), version (int, default 1), history ([{version: int, body: string, date: time, note: string}], all Req: earlier wordings).
Variable (all optional): id, name (the key texts use: ⟦var:<name>⟧, section 6.3; the first variable with that name counts), value, note (string), research (uuid), history ([{value: string, validFrom: time}], both Req: earlier values with the day they began to hold; the value at a date is the last entry with validFrom ≤ that date, else value).
Term: id, term, definition (string), aliases ([string]) — Req; anchor (where the text defines it), changed (time).
CaseEvent: id, title, when (string, as written), participants ([uuid]), statements ([Statement of the case]), note — Req; date (time). Statement of the case: id, party ("Kläger", "Zeuge Müller"), claim, when, page — Req; research (uuid; see 5.4), anchor.
RoleMark: id, anchor, role (ownSubmission, opposingSubmission, undisputed, evidence, assessment) — all Req.
Approval: id, node, by, date, note — Req; snapshot (uuid: the approved version).
TrackedChange: id, kind (insertion: the anchored text was inserted; deletion: the anchored text is deleted but stays in the text, struck through, until accepted), anchor, author, date — Req; round (uuid: the round active at the time).
LegalSource (lenient; all 16 keys always written, all strings unless said): id (uuid), kind (book, commentary, article, chapter, online; default book), authors ("Medicus, Dieter; Petersen, Jens"; names without a comma are institutions), edited (bool: the names are editors), title, shortTitle, edition ("3" is printed "3. Aufl." or "3rd edn"), volume, place (place of publication or publisher), year, journal, page, container (the book a chapter appears in), containerEditors, url, accessed.
Statement: id, anchor, kind (claim, evidence, assumption, conclusion, event, belief, falseBelief, data, interpretation, recommendation), title, participants ([uuid]), occurred, knownSince (strings, as written), created (time), checked (bool), checkedText, checkedBy, note — Req; occurredDate, knownDate, validFrom, validUntil, checkedAt (time), knownScene (uuid).
Relation: id, from (Ref), kind (supports, contradicts, requires, supersedes, conditional, resolves: reads "from kind to"), to (Ref), confirmed (bool; false: a suggestion found by the app), note, created — all Req. Ref is an object with exactly one of these keys, its value under "_0": {"statement": {"_0": <uuid>}}, {"passage": {"_0": <Anchor>}}, {"node": {"_0": <uuid>}}, {"question": {"_0": <uuid>}}.
Question: id, title, detail, anchors ([Anchor]), owner, state (open, decided, dropped), decision, reasoning, decidedBy, created — Req; decidedAt (time).
Review: node, dimension (content, sources, language, approval), done (bool), openPoints (int), by, reason — Req; date (time). It has no id: one entry per node and dimension.
FieldDefinition: id (referred to by fieldRules), name (the key under which nodes store the values in fields), type (text, date, choice, multiChoice, person, number, check), options ([string]), showInOutline (bool) — all Req.
ClauseUse: id, clause, variant (uuid), version (int), anchor, insertedText (the wording as inserted, fields as tokens ⟦…⟧), keepLocal (bool), date — all Req.
Curve: kind (tension, storyTime, mood, tempo, presence; one unknown kind drops the whole list) — Req; id (uuid), character (uuid: for presence), points ([{id: uuid, at: number 0–1 (start to end of the manuscript), value: number 0–5}], all Req; one broken point empties that curve).
OrderLists (lenient; all four written when present): statusNames ({WriteStatus: string}: the project's own names of the steps), ownStatuses ([{id: uuid, title: string, countsAs: WriteStatus}]), labelNames ({WriteLabel: string}), keywords ([string]).
GoalPlan (lenient): deadline (day), writingDays ([int]: 1 Sunday … 7 Saturday; default all), dailyFromDeadline (bool: the daily goal follows from the deadline), sessionGoal (int: words per session).
5.7 Settings: settings
Settings (all optional). Goethe Write writes every key (authorWorkspace and workKind only when set). A wrong type of title, subtitle, author, caseNumber, language, the four …Tools, annexPrefix, trackChanges, goetheRules or a non-object authorWorkspace makes the file unreadable; the other keys are lenient.
| Key | Type | Default | Meaning |
|---|---|---|---|
workKind | novel, nonfiction, legal, screenplay | derived from the tools | The kind of work; decides the phases and the screenplay features. |
title, subtitle, author | string | "" | For the title page, PDF and EPUB metadata, the watermark, and the fields {title}, {subtitle}, {author}. |
caseNumber | string | "" | Case number (Aktenzeichen); {case}. |
language | string | "de" | Output language; a value starting with en gives English wording, anything else German. |
storyTools, legalTools, scienceTools, consultingTools | bool | true, false, false, false | Tool groups: story (timeline, analysis, story, relationships), legal (arguments, chronology, clauses, terms, literature), science (literature, terms), consulting (clauses, terms). |
shownTools, hiddenTools | [string] | [] | Tool ids shown beyond their groups, or hidden although their group is on (hidden wins): overview, timeline, story, analysis, rules, arguments, chronology, clauses, terms, literature, questions, comments, relationships. |
annexPrefix | string | "K" | As in "Anlage K 1". |
styles | [Style] | the five default styles | Paragraph styles; lenient as a whole list. |
trackChanges | bool | false | Tracked changes are recorded. |
export | Export | defaults | Page setup and export. |
goetheRules | string | "" | House rules for the assistant Goethe. |
takenOver | [string] | [] | One-time migrations done: tools. |
authorWorkspace | Workspace | empty | The phases Idee, Recherche, Beats and Drehbuch. |
Style (all Req): style (int: 0 body, 1–3 headings 1–3, 4 quotation, 5–7 headings 4–6; the first entry of a number counts), family (string), size (number, points), bold, italic (bool), lineSpacing (number, a multiple of the line), spaceBefore, spaceAfter, indent (number, points; for 4 also the right indent), alignment (left, center, justified). The default set: 0 Charter 15 pt, line 1.3, after 8; 1–3 Helvetica Neue bold 21, 17, 15 pt, line 1.15, before 22, 16, 12, after 8; 4 Charter italic 15 pt, indent 28.
Four optional keys of a Style (written since 13 November 2026, only when set; a value of another type counts as absent and the rest of the style still applies) say how every paragraph of the style breaks across pages, as Word's paragraph dialog („Zeilen- und Seitenumbruch“) and Pages' „Umbruch“ do:
| Key | Type | Absent | Meaning | In Word |
|---|---|---|---|---|
keepWithNext | bool | on for headings (1–3, 5–7), off otherwise | the paragraph's last line stays on the page where the next paragraph begins | w:keepNext |
keepLines | bool | on for headings, off otherwise | the paragraph does not break across pages (unless it is longer than a page) | w:keepLines |
pageBreakBefore | bool | off | the paragraph begins a page | w:pageBreakBefore |
widowControl | bool | on | no first line of a paragraph alone at a page's foot, no last line alone at the next page's top | w:widowControl |
Absent, a paragraph does what Goethe Write's pages always did: headings (and short paragraphs all in bold) stay with the text after them and whole, and no paragraph leaves its first or last line alone. A paragraph's own value (6.2, addition 6) overrides its style's.
Export (all optional and lenient; Goethe Write writes all 44 keys, customPaper, mirrored, headerDistance, footerDistance, scope and watermark only when set). Lengths of the page are centimetres, of type points.
| Key | Type | Default | Meaning |
|---|---|---|---|
format | pdf, docx, epub, markdown, rtf | pdf | Last export format. |
preset | string | text | The look: text (as written), standard, buch, normseite, schriftsatz, gutachten; any other value acts as standard. |
titleHeadings | folders, all, none | from titles | Which outline titles become headings. |
titles | bool | true | Legacy; read only when titleHeadings is absent. |
separator | string | blank | Between texts whose titles are not printed: blank, stars, or text:<mark> (one line, at most 24 characters). |
titlePage, tableOfContents, chapterNewPage, pageNumbers | bool | true | |
tocDepth | int | 2 | Heading levels in the table of contents. |
numberPosition | string | center | left, center, right (footer), topleft, topcenter, topright (header). |
numberFormat | string | number | number ("3"), page ("Seite 3"), pageOf ("Seite 3 von 12"). |
headerLeft, headerCenter, headerRight, footerLeft, footerCenter, footerRight | string | "" | Running heads; may hold {title}, {subtitle}, {author}, {case}, {chapter}, {date}, {page}, {pages}. |
furnitureFirstBare, furnitureMirrored, furnitureLines | bool | false | First page without head and foot; left and right swapped on even pages; hairlines. |
furnitureFamily | string | "" | Font of head and foot; empty: as the look. |
furnitureSize | number | 0 | Points; 0: as the look. |
font | string | Charter | Body font when preset is not text. |
size | number | 12 | Body size in points (used within 6–48). |
lineSpacing | number | 1.3 | Multiple of the line. |
justified | bool | false | |
marginTop, marginBottom, marginLeft, marginRight | number | 2.5 | Centimetres; left and right are inner and outer when mirrored. |
paper | string | a4 | A paper id (a3, a4, a5, a6, a7, b4, b5, b6, c4, c5, c6, dl, letter, legal, tabloid, executive, statement, book-…, uk-…, pod-…), or custom-<lower-case uuid> for an own size. Readers lower-case it and read buch- as book-. Unknown: A4. |
customPaper | Paper | none | The own size, so the project prints alike on another Mac: id (equals paper), name, width, height (numbers), unit (mm, cm, in, pt, pica, cicero), all Req; sides 70–1,500 mm. |
landscape | bool | false | |
mirrored | bool | as the look | Mirrored margins (absent: only buch mirrors). |
gutter | number | 0 | Binding allowance, centimetres (0–5). |
headerDistance, footerDistance | number | automatic | Centimetres from the paper's edge. |
marginNumbers, bibliography, numberHeadings | bool | false | Paragraph numbers in the margin; a bibliography; numbered headings. |
scope | uuid | the whole manuscript | Export only this part. |
includeReview | bool | the reading Mac's preference, else true | Word export carries comments and tracked changes. |
watermark | Watermark | none | See below. |
Watermark (lenient, all keys written except picture when unset): kind (text, picture), text (one line, may hold {title}, {subtitle}, {author}, {case}, {date}, {recipient}), font (default "Helvetica Neue"), bold, size (points; 0 automatic), color (#RRGGBB, default #C0C0C0), opacity (0.05–1, default 0.5), slant (rising −45°, falling +45°, level), picture (<sha256>. in watermarks/, section 7.2), scale (percent; 0 automatic), washout (bool, default true), pages (all, notTitle, textOnly), recipient (string), recipients ([string]: one copy per name).
Workspace (authorWorkspace; Goethe Write writes exactly the first seven keys, each falls back on its own): logline, premise, genre, audience, notes (string), beats ([Beat]), drafts ([Draft]); legacy, read only: stage, selectedDraft (5.4). One broken beat or draft makes the whole list empty.
- Beat:
id(uuid),title,summary(string),act(int, from 1),threads([string]) — Req;color(WriteLabel),scene(uuid: the linked text),x,y(number: the card's place on the board in points; absent: automatic). - Draft (a screenplay in Final Draft's model):
id(uuid),title(string),sourceScenes([uuid]: the manuscript's scenes it comes from),blocks([Block]),modified(time) — Req;originalData(string, base64: the imported file's bytes exactly as read — an FDX, a Fountain file, or the text of a PDF),originalFormat(fdxorfountain; anything else is read as Fountain),titlePage([{spans: [Span], alignment: Left|Center|Right|Full}]),numbering(scene numbers:left,right,autoHideRight(bool),scheme(1AorA2),leftLocation,rightLocation(inches), all Req),revisions(revision state:mode(bool),active(int),shown(ActiveorAll),location(inches),pageColors(bool),sets([{id: int, name, mark, pageColor, style: string, full: bool, color?: string}], colours#RRRRGGGGBBBB), all Req). Absent optional keys mean "as in the original file". - Block (a paragraph):
id(uuid),element(the Final Draft paragraph type:Scene Heading,Action,Character,Parenthetical,Dialogue,Transition,Shot,General, …, an open list),text(string) — Req;sourceIndex(int: the paragraph's index in the document read fromoriginalData),sourcePath([int, int]: a voice of a dual dialogue),dualGroup(uuid),dualVoice(int 0 or 1),spans([Span]: the formatted runs; when present they are what counts),status(WriteStatus of a scene),number(string: scene number;""none),omitted([Block]: an omitted scene's old paragraphs),deletions([{offset: int (UTF-16 code units in the paragraph), revision?: int}]). - Span:
text(string),styles([string]:Bold,Italic,Underline,Strikeout,AllCaps,HiddenTextand names a file brings) — Req;attributes({string: string}: the FDX<Text>attributes as read).
Screenplays live here only for now; a later version gives them a part of their own (section 10).
5.8 The person's window: window
window holds what one person needs to find their place again: open folders, the caret in each text, the panels chosen. It never holds the window's frame or the panels' sizes; those belong to the device and live in the device's own store. A reader MAY ignore window entirely. Every key is optional and lenient.
| Key | Type | Meaning |
|---|---|---|
expanded | [uuid] (sorted) | Open folders and texts in the sidebar, and 00000000-0000-4000-8000-0000000000A1 while the section "Werkzeuge" is open. Goethe Write always writes it; its presence tells Goethe Write that the file has the current layout. |
sidebarFolded | [uuid] (sorted) | Folded sidebar sections: root ids, and …0000000000A1 (Werkzeuge), …0000000000A2 (Sammlungen), …0000000000A3 (Projekt). |
infoFolded | [string] (sorted) | Folded sections of the inspector (synopsis, notes, details, scene, connections, revision, profile, file, rules, page, deleted, …). |
infoPage | string | The open page of the inspector, up to two steps joined by / (entities/). |
places | {uuid: Place} | Caret and scroll per text. Place: location, length (int, Req: the selection in UTF-16 code units, section 6.4), top (int: first visible character), offset, width, scale (number: scroll position and the view's width and magnification in points). |
timeline | Timeline | The timeline's state (below). |
review | Review | The review list: filter (all, hints, comments, questions, changes, sources), sort (place, date, kind, person), showDone, showIntended (bool), person (string), part (uuid). |
parts | {string: string} | The part chosen on a tool page ("story": "knowledge"). |
tool | string | The tool page shown in the middle (a tool id, 5.7). |
collection | uuid | The collection shown. |
board | {mode: cards|outline, folder: uuid} | A folder shown as cards or table (both Req). |
stage | string | The phase shown: idea, research, beats, screenplay, revision, output (never manuscript, which is the default). |
draft | uuid | The screenplay draft chosen. |
Timeline: mode (reading, chronology, analysis), x, y (number: the first column in view of the older board), measure (even, pages, words; absent: even), zoom (work, part, chapter), anchor (uuid: the first scene in view), collapsed ([string]: units shown as one block: work, a folder id, <uuid>#<n>, loose#<n>, day:yyyy-MM-dd, undated), lanes (strands, characters, places, pov), hidden ([string]: lane ids), solo (string), curves ([string], order meaningful; absent: tension and story time; []: none), presence (uuid), more (newer state: viewports ({string: {rest, anchor, into, scale, fallback}}), places, laneHeights ({lane: title|card}), laneColours ({lane: 1–8}), laneOrder ({kind: [lane]}), laneSort (name, count, manual), locked, columnsOff, groups, opened, curvesOpen, propsOff ([string]), alwaysDark (bool; absent: on), curveHeight (int, default 72)). Lane ids: strand:<name>, character:<uuid>, place:<uuid>, place-text:<name>, pov:character:<uuid>, pov:<name>, none.
Legacy keys (read once from older files, then moved to the device's store and never written again): frame (string "{{x, y}, {w, h}}"), sidebar, info ({width: number, dragged: bool}), columns ({string: {sidebar: bool, info: bool}}), ribbonPinned, spread, sceneStrip, inspector (bool), ribbonTab, inspectorTab (string), presentation (draft, pages), zoom (fit, pageWidth, wholePage, or a positive number), lineWidth (narrow, medium, wide).
5.9 Goethe's record and the manuscript's goal
LogEntry (goetheLog, oldest first, at most 2,000; written only when the person keeps a record): id, date, model (the engine or model), action (what was asked), context (what it was about), result (what happened), texts ([{node: uuid, before: string, after: string}]: lower-case hex SHA-256 of the text before and after) — all Req. The record never holds the text itself.
Goal (manuscriptGoal, lenient): amount (int; 0: no goal), unit (words, characters), bound (atLeast: a goal; atMost: a limit), withNotes (bool, default true: footnotes count).
5.10 Lists of words
| Name | Values |
|---|---|
| NodeKind | manuscript, characters, places, research, trash (roots); folder, text, character, place, file |
| WriteStatus | none, idea, draft, revised, done |
| WriteLabel | red, orange, yellow, green, blue, purple, gray |
| FactKind | secret, clue, promise, question, fact |
Strict (an unknown value makes Goethe Write 1 refuse the file): FactKind, Knowledge., WorldRule., Collection. and labels, Argument., RoleMark., TrackedChange., Statement., Relation., the keys of Ref, Question., Review., FieldDefinition.. Strict for their list only (an unknown value empties the whole list): the values inside settings. and drafts, bible., bible.. Lenient (an unknown value falls back and is rewritten on the next save): Node. (to text), Node. (to none), Node. (dropped), LegalSource. (to book), ownStatuses[]. (to draft), the Goal, workKind (dropped) and every value of settings., window and watermark.
6. Texts
6.1 Files
- The text of node
<id>istexts/, or<id>. rtf texts/when it holds pictures: an RTFD folder with<id>. rtfd/ TXT.(found without regard to case) and the picture files.rtf - Saved versions (
snapshots/) and deleted passages (deleted/) are written the same way, named by their own id. - Version 1 stores texts as RTF so that every word processor can open them. A later version moves to an open JSON model (section 10); RTF stays readable.
6.2 The RTF that Goethe Write writes
Goethe Write writes RTF through the macOS text system ("Cocoa RTF") and adds six things. A text with content begins like this:
{\rtf1\ansi\ansicpg1252\cocoartf2907
\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fnil\fcharset0 Charter-Roman;}
{\colortbl;\red255\green255\blue255;}
{\*\expandedcolortbl;;}{\*\lexxstyles v1 n=3 0*3}
\deftab708
\pard\pardeftab708\sl312\slmult1\sa160\pardirnatural\partightenfactor0
\f0\fs30 \cf0 Der Kaufvertrag vom 14. M\'e4rz 2024 …\
- Characters: a paragraph ends with
\and a line feed; characters of code page 1252 are\'hh; all others\uc0\uN(withN≥ 32,768 written as such; characters above U+FFFF as two surrogate units);\\,\{,\}; tabs as a tab byte or\tab. Fonts are PostScript names; text colour is automatic (\cf0); line spacing\slN\slmult1. - No page setup in the text (no
\paperw,\margl): the page is a setting of the project (settings.).export - Not in the text: comments (
bible.) and tracked changes (comments bible.). Text deleted while changes are tracked stays in the RTF as ordinary text until the deletion is accepted.tracked - Links are standard RTF fields:
{\field{\*\fldinst{HYPERLINK "…"}}{\fldrslt …}}.
Addition 1: footnotes as Word writes them:
\uc0{\super\chftn{\footnote\pard\plain\uc0\f0\fs20 {\super\chftn} \u167 444 BGB, {\i Palandt}.}}
The note's text uses {\b …}, {\i …}, {\ul …}, {\super …}, {\sub …}, \par, \tab, and \uN for every character outside ASCII (N as a signed 16-bit number). Notes hold no footnotes, fields or pictures. Endnotes are never written. Readers SHOULD also accept {\*\footnote …} (LibreOffice) and {\footnote\ftnalt …} (Word endnotes, read as footnotes).
Addition 2: paragraph styles, a destination other programs skip:
{\*\lexxstyles v1 n=<P> <run> <run> …}
<P> is the number of paragraphs; a run is <code> or <code>*<count>; <code> is the style of the paragraph (0 body, 1–3 headings 1–3, 4 quotation, 5–7 headings 4–6, - none; settings. says how they look). Paragraphs end at LF, CR, CRLF and U+2029 (not at U+2028 or U+000C); no empty paragraph follows the last break; an empty text has no record. The Mac app writes the record after the header tables, the iPhone and iPad app before the final }: readers search for it anywhere. It applies only when its count, n and the real number of paragraphs agree.
Addition 3: fields are written as plain text tokens between U+27E6 and U+27E7, never as RTF fields:
| Token | Shown as |
|---|---|
⟦var:<name>⟧ | the value of the variable of that name (bible.), or ‹<name>› |
⟦var:<name>@yyyy-MM-dd⟧ | its value on that day |
⟦ref:<node id>⟧ | a cross-reference to a text: its label in the export (B. II. 1., Abschnitt 2., or its title in quotes), or ‹Verweis fehlt› |
⟦ref:<node id>#<heading words>⟧ | a cross-reference to a heading in it (words normalized, at most 80 characters) |
⟦anlage:<node id>⟧ | an annex: Anlage <settings., n its place among the children of the first research folder whose title begins with "Anlage" (else of the research root), or ‹Anlage fehlt› |
In the RTF a token looks like \uc0အ4 var:Aktenzeichenအ5 . A reader finds tokens with the expression ⟦(var|ref|anlage):([^⟧\n]{1,120})⟧.
Addition 4: pictures (only in RTFD). Each picture character is
{{\NeXTGraphic Bild.png \width2400 \height1200 \appleattachmentpadding0 \appleembedtype0 \appleaqc
}¬}
where ¬ is the single byte 0xAC, the picture's own character; \width and \height are the size shown, in twips (1/20 point). The file name is that of a file in the RTFD folder; one file may serve several pictures, so a reader takes the name from the reference and never guesses it. When a picture is placed on the page, TXT. also holds, right after its first line feed,
{\*\goethepictures <base64 of JSON>}
with {"version":1,"entries":[{"ordinal":0,"width":160,"height":80,"placement":{"mode":"inline|paragraph|page", "side":"left|right","slot":"top|bottom|whole","page":0,"x":0,"y":0,"gap":10,"angle":25,"bleed":false}}]}; ordinal counts the pictures of the text only (not footnotes or fields).
Addition 5: character formats that RTF as the macOS text system writes it cannot carry, a destination other programs skip (written since 12 November 2026; a text without it has none of these formats):
{\*\lexxchars v1 len=<L> <start>+<length>:<mark>[,<mark>…] …}
<L> is the length of the text in UTF-16 code units as it is written: each footnote and each picture one character, each field token (addition 3) as its characters; in the reference reader that is raw, not text (6.4). Each run names a stretch, <start> and <length> in the same units (<length> at least 1, <start> + <length> at most <L>), and the marks of all of its characters, separated by commas. Goethe Write writes one run for every stretch of characters with the same marks, in ascending order, without characters that have none; readers accept any order. The marks of version 1:
| Mark | Meaning | In Word |
|---|---|---|
sc | Kapitälchen (small capitals): lower-case letters as small capitals, the letters stay as typed | w:smallCaps |
caps | Versalien (all capitals): shown in capitals, the letters stay as typed (copying and searching find them as written) | w:caps |
hidden | hidden text: not printed, not in PDF, EPUB, RTF or Markdown, not counted; shown in Goethe Write only with the formatting marks | w:vanish |
lang=<tag> | the language of the passage, a BCP 47 tag (en-GB, de-CH, la); spelling and hyphenation follow it | w:lang |
sc and caps exclude each other in Goethe Write; a reader that finds both shows capitals. The record is written after the header tables by the Mac app (the iPhone and iPad app does not write it yet); readers search for it anywhere. It applies only when <L> is the length of the text read; otherwise, or when a run breaks these rules, none of it applies (the text was changed by another program, and the places would be wrong). Marks a reader does not know are skipped. Three formats of the same package need no record, because Cocoa RTF writes and reads them itself: the tracking (Laufweite) as \expndN\expndtwN (quarter points and twips; in Word w:spacing), the double strike as \striked1 (Word w:dstrike), and no ligatures as \CocoaLigature0 (Word w14:ligatures w14:val="none"; \CocoaLigature1 or nothing: the font's ligatures).
Addition 6: Umbruch and tab leaders of paragraphs, which Cocoa RTF cannot carry (it writes no \keepn, \keep, \pagebb, \widctlpar and no leader \tldot; it reads none of them either), a destination other programs skip (written since 13 November 2026; a text without it has none of these values):
{\*\lexxparas v1 n=<P> <run> <run> …}
<P> is the number of paragraphs, counted as for addition 2; a run is <marks> or <marks>*<count>; <marks> is - for a paragraph without values or the paragraph's marks joined by , (no spaces):
| Mark | Meaning | In Word |
|---|---|---|
keepNext, keepNext=0 | Nicht vom nächsten trennen, on or explicitly off | w:keepNext, w:keepNext w:val="0" |
keepLines, keepLines=0 | Zeilen nicht trennen | w:keepLines |
pageBreakBefore, pageBreakBefore=0 | Seitenumbruch oberhalb | w:pageBreakBefore |
widowControl, widowControl=0 | Absatzkontrolle | w:widowControl |
tab<twips>=dot|hyphen|underscore | the leader of the paragraph's tab stop at that place (twips = 1/20 point, as the RTF's own \txN; one twip either way matches): dots, dashes, a line | w:tab w:leader="dot|hyphen|underscore" |
A mark without = (or with =1) is on. A value the paragraph does not have is not written: its style decides (5.7). Goethe Write writes the marks in this order, tab marks by place; readers accept any order. The record is written after the header tables by the Mac app; readers search for it anywhere. It applies only when <P>, the runs' total and the real number of paragraphs agree; otherwise, or when a run breaks these rules, none of it applies. Marks a reader does not know, values it does not know and leaders of tab stops the paragraph does not have are skipped.
{\*\lexxsources …} is reserved (sources kept in a text); Goethe Write 1 does not write it.
When the text does not fit these rules (footnote groups and footnote characters disagree, as in damaged or foreign files), Goethe Write reads the RTF with the system's reader alone: footnotes then vanish and the styles record is not applied.
6.3 Plain text
To get the text as a person reads it, a reader:
- reads the RTF, skipping destinations that start with
\*and the tables (fonttbl,colortbl,stylesheet,info,pict,object,header…,footer…,listtable,listoverridetable,revtbl,rsidtbl,fldinst, …), keepingfldrsltandlisttext; - maps
\par,\cellto a line feed,\lineto U+2028,\pageto U+000C,\tabto a tab,\uN(with\uc) and\'hh(in the code page of\ansicpg) to their characters,\~to U+00A0,\-to U+00AD,\_to U+2011; - takes each footnote group out as a note, leaving one character U+FFFC in its place;
- takes each
\NeXTGraphicgroup as one U+FFFC (and drops the0xACafter it); - leaves out hidden text (
hidden, addition 5), with the footnotes and pictures in it, as Goethe Write's export does; - shows each field token as its value (6.2).
The reference reader (section 11) does exactly this and prints footnotes as [^n] with the notes below the text, numbered as they are shown (a footnote in hidden text gets no number). Anchors (6.4) still count the hidden text: it is part of the text as Goethe Write holds it.
6.4 How Goethe Write counts the text: anchors
Many keys of project. point into texts: every anchor (location, length) in bible (comments, sources, roles, tracked changes, arguments, terms, statements, questions, clause uses, passages in relations), and window.. They count UTF-16 code units of the text as Goethe Write holds it, which is the plain text of 6.3 with these rules:
- a footnote is one character (U+FFFC); the note's own text is not counted;
- a field is one character (U+FFFC), not its token;
- a picture is one character (U+FFFC);
- list markers (a tab,
•or the number, a tab) and outline labels count as written, and so does text deleted while changes are tracked; - a character above U+FFFF counts as two; nothing is normalized.
quote (and checkedText) is the passage with these U+FFFC characters in it, as it was when the anchor was made or last refreshed. Edits move location and length, but not every edit refreshes quote. A reader therefore takes the passage at location when it equals quote, else the occurrence of quote nearest to location, else the range clipped to the text. (Goethe Write's sample project has one anchor made before a footnote went into its passage: its quote lacks that footnote's character.)
The mapping of \line, \page, \cell and list markers in item 2 of 6.3 follows the RTF specification and the macOS text system; the files tested so far hold none of them, so a later revision confirms them against files with lists, tables, line and page breaks.
7. Research files, watermarks, guides
7.1 Research files: files/
A research node (kind: "file") has its bytes in files/, where <ext> is the extension of its original file name (Node., e.g. "Kaufvertrag.); a file without an extension has none. Readers find a node's file by matching the id against the part of the name before the extension and never rebuild the name from Node., which is only the name shown. A node with url and no file is a web link and has no bytes.
7.2 Watermarks: watermarks/
The picture of a picture watermark lies in watermarks/: the 64 lower-case hex digits of the SHA-256 of the file's exact bytes. It is PNG (other formats are converted, at most 2,400 pixels on the long side). settings. names it (the bare file name). The name is the picture's identity; a writer MUST NOT store other bytes under it. When Goethe Write opens a project it removes every other file from the folder, and the folder when nothing is left.
7.3 Page guides: guides.json
Blue-pencil guides on the pages, with a version of their own. The file exists only after a guide was edited; opening or showing never creates it.
{
"entries" : [ { "axis" : "vertical", "base" : "textArea", "colour" : "bluePencil", "edge" : "inner",
"id" : "2D3F5B8E-7C41-4C1A-9E0B-5A1F2C3D4E5F", "locked" : false, "mirrorInBook" : true,
"offset" : 14.173228346456693, "owner" : "manuscript", "scope" : "all" } ],
"format" : 1,
"readableFrom" : 1
}
Goethe Write 1 accepts only format 1 with readableFrom 1. Otherwise, or when an entry is invalid, it shows no guides, refuses to edit them, and keeps the file's bytes unchanged. Every key of an entry is required:
| Key | Meaning |
|---|---|
id | uuid, unique in the file |
owner | manuscript; also valid: script:<x>, page:<x>, cover:<x> (no :, space or control character in <x>, at most 256 bytes in all) |
axis | horizontal (measured on y) or vertical (measured on x) |
base | sheet (the paper) or textArea (the page's type area, mirrored on left-hand pages when margins are mirrored) |
edge | horizontal: top, bottom, centre; vertical: inner, outer, left, right, centre |
offset | points from that edge, finite, may be negative |
scope | all, left or right pages (left-hand pages have even printed numbers) |
mirrorInBook | inner and outer follow mirrored margins |
locked | cannot be moved or deleted by hand |
colour | bluePencil |
At most 2,000 guides in all and 200 per owner.
8. What readers and writers must do
A reader
- MUST apply the rules of
manifest.(2.2).json - MUST read the outline from
treeand find each node's text intexts/by its id (.rtf, orTXT.in anrtf .rtfdfolder), and its research file infiles/by its id. - MUST NOT depend on the order of keys, on the order of
expanded, or on ZIP bytes; MUST ignore keys and top-level entries it does not know. - SHOULD read the RTF additions of 6.2. A general RTF reader shows the text, but footnotes then stand in the text or are lost, and anchors no longer fit.
- MUST follow 4.3 when it reads an exchange file.
A writer (a program that changes a package)
- MUST write
manifest.by the rules of section 2, and MUST NOT lowerjson formatof a package it may edit. - MUST write every key marked Req (section 5), ids as UUIDs, times in UTC as in 5.1.
- MUST keep every top-level entry it does not know, byte for byte (3.3), and the files of nodes it does not change.
- SHOULD NOT add keys to
project.: Goethe Write 1 drops keys it does not know. A program that wants to keep data of its own in a package SHOULD use a top-level entry named by its reverse domain name (json com.orexample. tool/ com.); Goethe Write keeps it.example. tool. json - SHOULD keep anchors valid when it changes a text (move
locationandlengthof the anchors in that node), and MUST NOT put files intotexts/,files/,snapshots/ordeleted/thatproject.does not refer to.json - SHOULD save safely (3.4).
A writer of exchange files MUST follow 4.1; Goethe Write never reads back what it cannot write.
9. Security and privacy
Reading. An exchange file comes from someone else. The rules of 4.3 protect against names that lead out of the package ("zip slip"), links, archives that unpack to far more than they say ("zip bombs", also by overlapping entries), and encryption. Readers MUST NOT follow links, write outside the package, start programs, or load anything from the network because of a file's content. RTF is read with the system's text reader; RTF from other programs can contain embedded objects (\object, \pict), which Goethe Write never writes; a reader SHOULD NOT run or display embedded objects. JSON SHOULD be read with limits on size and depth.
What a project contains. A package, and so every exchange file made from it, holds the whole project:
- every text, also those in "Recently Deleted";
- saved versions of texts (
snapshots/,bible.) and deleted passages (snapshots deleted/,bible., up to 200);deleted - comments and replies with their authors' names, and tracked changes with names and times;
- the research files, and the bytes of every imported screenplay as they were read (
originalData), including parts later deleted in Goethe Write; - the record of what the assistant Goethe changed, if the person keeps one (
goetheLog: actions and checksums, never the text); - where the person stopped (
window: open folders, caret positions).
It also holds the project's house rules for the assistant (settings.). It never holds device values (window frames, panel sizes), API keys, passwords or account data. "Für Goethe sperren" (lockedForGoethe) keeps the assistant away from a part; it is not encryption, and the part is in the file like any other. A person who sends an exchange file SHOULD know what it carries; a later version of Goethe Write may offer to leave parts out (section 10).
10. What is stable in version 1, and what later versions change
Stable. Every later version of Goethe Write reads what version 1 describes. Since version 1.0 of this specification these stay as they are, and later versions only add to them:
- the two forms, their names, type identifiers and media type (final since version 1.0);
- the rules of
manifest.(section 2) and the ZIP profile of the exchange file (section 4);json - the layout of the package and the reserved names (section 3);
- the keys of
project.and their meaning (section 5);json - the RTF of texts with its six additions, and how anchors count (section 6).
Planned for later versions (not promises; each comes with a new format, and readableFrom rises where older writers would lose data):
| Change | Why |
|---|---|
| Texts as an open JSON block model (paragraphs with their style, runs with marks, footnotes, comments and changes as ranges) instead of RTF; RTF stays readable for older projects | one exact meaning on every device and in every program; anchors without the RTF reader's rules |
Screenplays as a part of their own, scripts/ (a head, one part per scene, comments and changes as records, the original FDX or Fountain bytes in sources/, versions), instead of settings. | loss-free Final Draft round trips, working together scene by scene |
manifest. lists every part with its SHA-256 and is written last | a package is complete or it is not; damage is found |
| Knowledge in parts of its own (characters and places, timeline, comments and changes as records) | several people and devices change different files |
expanded written in a fixed order, keys of project. that a version does not know kept | the same project gives the same bytes; newer data survives older writers |
The person's window state outside project. | a shared project carries nobody's caret |
| ZIP64 for exchange files over 4 GB | large research collections |
| Quick Look previews and Spotlight data, the media type registered with the IANA | the file shows its content outside Goethe Write |
11. Schemas, reference reader and tests
| File | What it is |
|---|---|
schema/ | JSON Schema (2020-12) of manifest. |
schema/ | JSON Schema (2020-12) of project., every key of section 5, with its meaning |
reference/ | Reference reader: prints the outline and the plain text of a .goethe, .lexwrite or .goethex (without hidden text); --json for programs, with each text's paragraph styles, character formats and Umbruch (styles, chars, paras) |
reference/ | Checks packages and exchange files against the schemas; --strict lists keys the schemas do not describe |
reference/ | Tests of both; with GOETHE_SAMPLES=<folder> also every project Goethe Write wrote into that folder |
reference/ | How to use the three scripts |
LICENSE. | Which licence covers which file (section 12) |
All three scripts need Python 3.9 or later and nothing but its standard library:
python3 docs/format/reference/goethe_read.py "Mein Roman.goethex"
python3 docs/format/reference/check_schema.py --strict "Mein Roman.goethe"
python3 docs/format/reference/test_goethe_read.py
The schemas are open: they allow keys they do not list, because readers must ignore unknown keys. They are checked against every sample project and every template Goethe Write can create, in both forms, and against a package written before the manifest existed; --strict finds no key without a description.
Goethe Write's own checks (launch argument -goetheFormatTest, check goetheFormatTest of write/):
- the registration in the app's
Info.;plist - every sample and template →
.goethe→ read → the same outline and texts; after the first reading, read and written again byte for byte the same (only the documented migrations of 5.4 happen once); - every one →
.goethex→ read → the same unpacked entries;mimetypefirst and stored; written twice the same; read back as a project and saved, the same package; - a text with every character format of addition 5 (and tracking, a double strike, no ligatures) →
.goetheand.goethex→ read → the same formats in the same places; a record written for another length, against the rules, of another version or with a mark of a later version changes nothing it should not; a package without records reads as before; - a text with paragraphs carrying every value of addition 6 and a tab stop with a leader, and styles with the keys of 5.7 →
.goetheand.goethex→ read → the same values at the same paragraphs, the same styles; the macOS RTF reader alone and a reader of the ten older keys of Style read without error; a record for another number of paragraphs, of another version or against the rules applies not at all, unknown marks are skipped; - unknown entries travel along in both forms;
- a
.lexwritepackage (also one without a manifest) opens, saves in place under its name and gets a manifest; - a
.goethexopens as an untitled project and is not written to; - damaged, foreign and hostile files are refused with a sentence (not a ZIP, a PDF, a Word file, an EPUB, an OpenDocument file, cut off, a changed byte, a wrong checksum, names that lead out, absolute names, drives, backslashes, doubled names also by case, a file and a folder of the same name, links, encryption, unknown packing, ZIP64, overlapping entries, too many entries, too large, packed suspiciously far, too deep, an entry that unpacks to more than it says); never a crash;
- the reader limits of 4.3, the manifest's rules (a newer
formatis kept, a newerreadableFromand anotherkindare refused).
12. Licence
This specification and the files that come with it are published by ICSL FZE, Sharjah, United Arab Emirates. LICENSE. lists which licence covers which file.
- The specification (this text,
GOETHE_FORMAT_1., and the German short version,md GOETHE_FORMAT_1.): © 2026 ICSL FZE, licensed under the Creative Commons Attribution 4.0 International licence (CC BY 4.0): licence deed, legal code. You may copy, share, translate and adapt it, for any purpose, also commercially, as long as you give credit, link to the licence and say whether you changed it. Suggested credit:de. md Goethe Format 1, © 2026 ICSL FZE, CC BY 4..0, https:// goethecloud. com/ format/ - The JSON Schemas (
schema/) and the reference reader with its tests (reference/): Copyright (c) 2026 ICSL FZE, licensed under the MIT License (schema/,LICENSE reference/). Each of these files names its licence in an SPDX line.LICENSE - The format itself: other programs are free to read and write files in Goethe Format 1.
Questions about the format and its licences: hello@lexxington.com.
Appendix A: Registration of the media type (draft)
application/ is not registered yet. The registration in the IANA's vendor tree (RFC 6838) is submitted by the publisher, ICSL FZE; this is the text to submit. The contact person, the e-mail address and the author are filled in by the publisher when it submits the registration.
| Field | Value |
|---|---|
| Type name | application |
| Subtype name | vnd. |
| Required parameters | none |
| Optional parameters | none |
| Encoding considerations | binary |
| Security considerations | section 9 of this specification: ZIP containers from others can hold names that lead out of the folder, links, and entries that unpack to far more than they say; readers refuse them (section 4.3). The format holds no executable content. Texts are RTF; embedded objects are never written. |
| Interoperability considerations | a ZIP archive (PKWARE APPNOTE) restricted as in section 4.1; the first entry mimetype holds the type, stored, as in EPUB and OpenDocument |
| Published specification | this document, https:// |
| Applications that use this media type | Goethe Write (macOS, iOS, iPadOS) |
| Fragment identifier considerations | none |
| Magic number | 50 4B 03 04 at offset 0, mimetype at offset 30, application/ at offset 38 |
| File extension | .goethex |
| Macintosh file type code | none; Uniform Type Identifier com. |
| Person and e-mail to contact | (filled in by the publisher at submission) |
| Intended usage | COMMON |
| Restrictions on usage | none |
| Author | (filled in by the publisher at submission) |
| Change controller | ICSL FZE, Sharjah, United Arab Emirates |
Appendix B: Examples
An exchange file as zipinfo lists it (the sample project "Der Fall Berger", shortened):
-rw-r--r-- 2.0 unx 39 b- stor 26-Nov-07 05:20 mimetype
-rw-r--r-- 2.0 unx 103 b- defN 26-Nov-07 05:20 manifest.json
drwxr-xr-x 2.0 unx 0 b- stor 26-Nov-07 05:20 files/
-rw-r--r-- 2.0 unx 24787 b- defN 26-Nov-07 05:20 files/178F6E39-5D77-4AF9-901D-C307C0BFF67E.pdf
-rw-r--r-- 2.0 unx … defN … project.json
drwxr-xr-x 2.0 unx 0 b- stor … snapshots/
-rw-r--r-- 2.0 unx … defN … snapshots/….rtf
drwxr-xr-x 2.0 unx 0 b- stor … texts/
-rw-r--r-- 2.0 unx … defN … texts/….rtf
Its manifest.:
{
"format" : 1,
"generator" : "Goethe Write 0.1 (1)",
"kind" : "project",
"readableFrom" : 1
}
Its project. (shortened, written on one line where the file has several):
{
"bible" : {
"comments" : [ { "anchor" : { "length" : 42, "location" : 0, "node" : "07659DCD-19AC-4112-B426-CBF5047F0824",
"quote" : "Der Gutachter sprach leise und sehr genau." },
"author" : "Lektorat", "date" : "2026-11-12T11:27:07Z", "id" : "A200F17B-707C-46F8-8417-437940156263",
"replies" : [ ], "resolved" : false, "text" : "Name des Gutachters einführen?" } ],
…
},
"dailyGoal" : 750,
"days" : { "2026-11-12" : 172 },
"expanded" : [ … ],
"format" : 2,
"manuscriptGoal" : { "amount" : 0, "bound" : "atLeast", "unit" : "words", "withNotes" : true },
"selection" : "0B10D7BE-8DB1-487C-AF98-612DFF02B1EB",
"settings" : { "language" : "de", "legalTools" : true, "storyTools" : true, "title" : "Der Fall Berger",
"workKind" : "novel", … },
"tree" : [ { "id" : "270943A9-3193-4FC7-8701-3E1E9EC9FD47", "kind" : "manuscript", "title" : "Manuskript",
"children" : [ … ], … }, … ],
"window" : { "expanded" : [ "182FF84D-E431-45B4-AD96-82AE169812A0", … ], "timeline" : { "measure" : "pages" } }
}