Goethe Write
EN

Specification

Goethe Format 1

Version 1.0, published 2026 · © 2026 ICSL FZE · Text under CC BY 4.0

The open file format of Goethe Write: the project package (.goethe) and the exchange file (.goethex)

StatusVersion 1.0 (format 1), published 2026
Describesexactly what Goethe Write writes and reads today
Names.goethe, .goethex, com.goethecloud.goethe.project, com.goethecloud.goethe.exchange and application/vnd.goethecloud.goethex+zip are final. They never change.
LicenceThis specification: CC BY 4.0, © 2026 ICSL FZE. The JSON Schemas (schema/) and the reference reader (reference/): MIT. See section 12.
PublisherICSL FZE, Sharjah, United Arab Emirates; questions to hello@lexxington.com
Addresshttps://goethecloud.com/format/
Short German versionGoethe-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 isa folder with the extension .goethe, shown by macOS and iOS as one documentthe same entries as one ZIP file with the extension .goethex
What it is forworking: quick to save, good for Git and Time Machinesending: mail, cloud, agencies, other programs
First entry–mimetype, stored, holding application/vnd.goethecloud.goethex+zip (as in EPUB and OpenDocument)
Equal whenthe files are equalthe unpacked entries are equal (not the ZIP bytes)

The content of both forms is the same: manifest.json (version), project.json (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

ProjectExchange fileOlder projects
Extension.goethe.goethex.lexwrite
Uniform Type Identifiercom.goethecloud.goethe.projectcom.goethecloud.goethe.exchangecom.lexxington.write.project
Conforms tocom.apple.package, public.composite-contentpublic.data, public.contentcom.apple.package, public.composite-content
MIME type– (a folder; send the exchange file instead)application/vnd.goethecloud.goethex+zip (not yet registered, Appendix A)–
Name in the Finder (English)Goethe Write ProjectGoethe Write Exchange FileGoethe Write Project (old)
How Goethe Write declares itexported; document type with role Editor, rank Ownerexported; role Editor, rank Ownerimported; role Editor, rank Alternate
  • The exchange file deliberately does not conform to public.zip-archive: otherwise the Finder would offer to unpack it with the Archive Utility instead of opening it in Goethe Write.
  • The names are declared in the Info.plist of the Mac app and of the iPhone and iPad app. The document icons are drawn by the system from the app icon.
  • .lexwrite is 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

TermMeaning
packagethe .goethe folder (or .lexwrite)
exchange filethe .goethex ZIP file
entrya file or folder of the package, named by its path relative to the package (texts/…rtf); in the exchange file a ZIP entry with the same path
nodean entry of the outline (project.json › tree): a root, a folder, a text, a character, a place or a research file
textthe formatted text of a node, an RTF file in texts/
anchora passage in a text, given by the node, a start and a length (section 6.4)
Goethe Write 1the app version this specification describes

2. Versions: manifest.json

2.1 The manifest

manifest.json 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
}
KeyTypeMeaning
formatinteger ≥ 1The version of this specification the package was written in.
readableFrominteger ≥ 1A reader of at least this version may open, edit and save the package without losing anything. Never greater than format.
kindstringWhat the package holds. Version 1 knows only "project".
generatorstringThe 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.json 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-integer format or readableFrom counts 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 saysThe reader
readableFrom > RMUST 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 knowsMUST NOT open it as a project.
format > R, readableFrom ≤ RMAY 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 ≤ Rreads 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 format and keeps readableFrom.
  • A later version that would be damaged by an older writer, or that older readers would misread, raises readableFrom as well.
  • Important: Goethe Write 1 does not keep keys it does not know inside project.json (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 raises 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.json 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.json, 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 rtf and rtfd are 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.json refers to are dropped by Goethe Write on the next save.

3.2 Reserved names

These names at the top of the package are reserved. A writer MUST NOT use them for anything else:

NameUse
manifest.json, project.json, texts, files, snapshots, deleted, guides.json, watermarksversion 1 (this specification)
mimetypeonly 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.jsonreserved 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/ and deleted/ nothing unknown survives: Goethe Write rebuilds these folders from project.json.
  • Two known entries Goethe Write manages itself: guides.json is rewritten when a guide is edited (section 7.3), and pictures in 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 entryMUST be mimetype: stored (method 0), no extra field, no data descriptor, content exactly application/vnd.goethecloud.goethex+zip (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 entrySHOULD be manifest.json, so a reader learns the version first.
Other entriesevery 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.
Packingonly stored (0) and DEFLATE (8). Goethe Write packs an entry with DEFLATE when it gets smaller and is larger than 64 bytes.
NamesUTF-8 (general purpose bit 11 set when a name is not ASCII), / as separator, relative. Section 4.3 lists what is not allowed.
Not allowedencryption (bits 0, 6 and 13), other packing methods, symbolic links, ZIP64, archives on several disks
Size in version 1below 4 GB and below 65,535 entries (no ZIP64). Larger projects cannot be exchanged in version 1.
Timesthe time of writing, as the ZIP fields allow (informative)
Permissionsmade 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, or mimetype holds another type (after trimming white space);
  • an entry name is empty, absolute (/…), contains .. or . as a part, an empty part (a//b), a backslash, a drive (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 (a is a file and a/b an entry);
  • 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.json is missing;
  • manifest.json asks for a newer reader (section 2.2).

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 .goethex copies its project into the app's folder ("On My iPhone › Goethe") as a .goethe package, 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.json 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/project.schema.json 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 null is written. A key that is absent means "not set". Readers treat null like 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.deadline) are local calendar days yyyy-MM-dd without 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 expanded is 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

KeyTypeReqDefaultMeaning
formatintyes–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.
dailyGoalintyes–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.expanded for older versions of the app; order without meaning. Read only when window.expanded is absent.
selectionuuidthe first text of the manuscriptThe selected node.
bibleBibleemptyKnowledge about the story or the case (5.6).
settingsSettingsdefaults, with storyTools: trueSettings of the project (5.7).
collapsed[uuid]–Legacy: folded sidebar sections; read only when window.sidebarFolded is absent; never written.
windowWindowdefaultsThe 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.
manuscriptGoalGoaltaken over once from the reading Mac's preferencesThe 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 (outside curves, order and goals) or goetheLog (inside settings.styles and settings.authorWorkspace.beats and drafts such 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.styles (back to the five default styles), settings.authorWorkspace.beats and drafts (empty), bible.curves (empty), bible.order.ownStatuses (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).

WhatChange
bible.beats (older character beats)each becomes entries of bible.changes (fields "Ziel", "Angst", "Beziehungen", or "Notiz"); beats is then written empty
bible.arguments[].research/page, bible.events[].statements[].research/pagewhere the item has an anchor of length > 0, they become an entry of bible.sources and are cleared
settings.shownTools, settings.takenOverthe tools shown by their groups are written down once, and "tools" goes into takenOver
settings.authorWorkspace.stage/selectedDraftmove to window.stage/window.draft
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 absenta 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 kindHolds
manuscriptwhat is exported, in reading order (depth first)
charactersnodes of kind character
placesnodes of kind place
researchresearch 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

KeyTypeReqDefaultMeaning
iduuidyes–Identity. Names texts/<id>.rtf|.rtfd and files/<id>.<ext>. Unique in the whole tree.
kindNodeKindtextlenient: an unknown kind is read as text.
titlestring""Shown as "Untitled" when empty.
synopsisstring""Short description (on the card).
statusWriteStatusnoneHow far the text is; lenient. With ownStatus, the step that status counts as.
labelWriteLabelnoneColour tag; lenient; written only when set.
includeInExportbooltrue
children[Node][]Children in outline order. Texts may have children too.
notesstring""Notes beside the text; not exported.
targetint0Word goal; 0: none. For a folder or a text with children it counts all words below.
povstring""Point of view: a name, not an id.
placestring""Where the scene takes place: free text, not an id.
whenstring""The time as the writer writes it ("Tag 3, abends").
datetimenoneThe 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.name), the ratings "Spannung" and "Stimmung" (0–5) and "Konflikt".
filestringnoneOriginal file name of a research file ("Kaufvertrag.pdf"), for display. The bytes are in files/ (7.1).
urlstringnoneA web page; a node with url and no file is a web link.
originuuidnoneIn the trash: the parent it was deleted from.
lockedForGoetheboolnot lockedThe assistant Goethe never reads this node or anything below it. Written only as true.
keywordList[string][]Keywords; written only when there are some.
ownStatusuuidnoneA status of the project's own (bible.order.ownStatuses); 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.

KeyTypeMeaning
characterRelationsRelationsthe 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)
orderOrderListsown names of statuses and colours, own statuses, keywords (lenient)
goalsGoalPlandeadline 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; role describes from in relation to to), kind (string: family, love, friendship, rivalry, work, other, or an own word; missing: derived from role), role, inverseRole, note (string), directed (bool, default true), 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/<id>.rtf|.rtfd), node, title, date, words (int), variant (bool: true an alternative, false a backup) — all Req.

Deleted: id (newer entries also have deleted/<id>.rtf|.rtfd), 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}} … {{/wenn}}), 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.

KeyTypeDefaultMeaning
workKindnovel, nonfiction, legal, screenplayderived from the toolsThe kind of work; decides the phases and the screenplay features.
title, subtitle, authorstring""For the title page, PDF and EPUB metadata, the watermark, and the fields {title}, {subtitle}, {author}.
caseNumberstring""Case number (Aktenzeichen); {case}.
languagestring"de"Output language; a value starting with en gives English wording, anything else German.
storyTools, legalTools, scienceTools, consultingToolsbooltrue, false, false, falseTool 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.
annexPrefixstring"K"As in "Anlage K 1".
styles[Style]the five default stylesParagraph styles; lenient as a whole list.
trackChangesboolfalseTracked changes are recorded.
exportExportdefaultsPage setup and export.
goetheRulesstring""House rules for the assistant Goethe.
takenOver[string][]One-time migrations done: tools.
authorWorkspaceWorkspaceemptyThe 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:

KeyTypeAbsentMeaningIn Word
keepWithNextboolon for headings (1–3, 5–7), off otherwisethe paragraph's last line stays on the page where the next paragraph beginsw:keepNext
keepLinesboolon for headings, off otherwisethe paragraph does not break across pages (unless it is longer than a page)w:keepLines
pageBreakBeforebooloffthe paragraph begins a pagew:pageBreakBefore
widowControlboolonno first line of a paragraph alone at a page's foot, no last line alone at the next page's topw: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.

KeyTypeDefaultMeaning
formatpdf, docx, epub, markdown, rtfpdfLast export format.
presetstringtextThe look: text (as written), standard, buch, normseite, schriftsatz, gutachten; any other value acts as standard.
titleHeadingsfolders, all, nonefrom titlesWhich outline titles become headings.
titlesbooltrueLegacy; read only when titleHeadings is absent.
separatorstringblankBetween texts whose titles are not printed: blank, stars, or text:<mark> (one line, at most 24 characters).
titlePage, tableOfContents, chapterNewPage, pageNumbersbooltrue
tocDepthint2Heading levels in the table of contents.
numberPositionstringcenterleft, center, right (footer), topleft, topcenter, topright (header).
numberFormatstringnumbernumber ("3"), page ("Seite 3"), pageOf ("Seite 3 von 12").
headerLeft, headerCenter, headerRight, footerLeft, footerCenter, footerRightstring""Running heads; may hold {title}, {subtitle}, {author}, {case}, {chapter}, {date}, {page}, {pages}.
furnitureFirstBare, furnitureMirrored, furnitureLinesboolfalseFirst page without head and foot; left and right swapped on even pages; hairlines.
furnitureFamilystring""Font of head and foot; empty: as the look.
furnitureSizenumber0Points; 0: as the look.
fontstringCharterBody font when preset is not text.
sizenumber12Body size in points (used within 6–48).
lineSpacingnumber1.3Multiple of the line.
justifiedboolfalse
marginTop, marginBottom, marginLeft, marginRightnumber2.5Centimetres; left and right are inner and outer when mirrored.
paperstringa4A 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.
customPaperPapernoneThe 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.
landscapeboolfalse
mirroredboolas the lookMirrored margins (absent: only buch mirrors).
gutternumber0Binding allowance, centimetres (0–5).
headerDistance, footerDistancenumberautomaticCentimetres from the paper's edge.
marginNumbers, bibliography, numberHeadingsboolfalseParagraph numbers in the margin; a bibliography; numbered headings.
scopeuuidthe whole manuscriptExport only this part.
includeReviewboolthe reading Mac's preference, else trueWord export carries comments and tracked changes.
watermarkWatermarknoneSee 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>.png 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 (fdx or fountain; anything else is read as Fountain), titlePage ([{spans: [Span], alignment: Left|Center|Right|Full}]), numbering (scene numbers: left, right, autoHideRight (bool), scheme (1A or A2), leftLocation, rightLocation (inches), all Req), revisions (revision state: mode (bool), active (int), shown (Active or All), 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 from originalData), 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, HiddenText and 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.

KeyTypeMeaning
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, …).
infoPagestringThe open page of the inspector, up to two steps joined by / (entities/appearances).
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).
timelineTimelineThe timeline's state (below).
reviewReviewThe 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").
toolstringThe tool page shown in the middle (a tool id, 5.7).
collectionuuidThe collection shown.
board{mode: cards|outline, folder: uuid}A folder shown as cards or table (both Req).
stagestringThe phase shown: idea, research, beats, screenplay, revision, output (never manuscript, which is the default).
draftuuidThe 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

NameValues
NodeKindmanuscript, characters, places, research, trash (roots); folder, text, character, place, file
WriteStatusnone, idea, draft, revised, done
WriteLabelred, orange, yellow, green, blue, purple, gray
FactKindsecret, clue, promise, question, fact

Strict (an unknown value makes Goethe Write 1 refuse the file): FactKind, Knowledge.kind, WorldRule.kind, Collection.statuses and labels, Argument.kind, RoleMark.role, TrackedChange.kind, Statement.kind, Relation.kind, the keys of Ref, Question.state, Review.dimension, FieldDefinition.type. Strict for their list only (an unknown value empties the whole list): the values inside settings.authorWorkspace.beats and drafts, bible.curves[].kind, bible.order.ownStatuses. Lenient (an unknown value falls back and is rewritten on the next save): Node.kind (to text), Node.status (to none), Node.label (dropped), LegalSource.kind (to book), ownStatuses[].countsAs (to draft), the Goal, workKind (dropped) and every value of settings.export, window and watermark.

6. Texts

6.1 Files

  • The text of node <id> is texts/<id>.rtf, or texts/<id>.rtfd/ when it holds pictures: an RTFD folder with TXT.rtf (found without regard to case) and the picture files.
  • 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 (with N ≥ 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.comments) and tracked changes (bible.tracked). Text deleted while changes are tracked stays in the RTF as ordinary text until the deletion is accepted.
  • 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.styles 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:

TokenShown as
⟦var:<name>⟧the value of the variable of that name (bible.variables), 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.1, 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.annexPrefix> <n>, 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.rtf 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:

MarkMeaningIn Word
scKapitälchen (small capitals): lower-case letters as small capitals, the letters stay as typedw:smallCaps
capsVersalien (all capitals): shown in capitals, the letters stay as typed (copying and searching find them as written)w:caps
hiddenhidden text: not printed, not in PDF, EPUB, RTF or Markdown, not counted; shown in Goethe Write only with the formatting marksw:vanish
lang=<tag>the language of the passage, a BCP 47 tag (en-GB, de-CH, la); spelling and hyphenation follow itw: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):

MarkMeaningIn Word
keepNext, keepNext=0Nicht vom nächsten trennen, on or explicitly offw:keepNext, w:keepNext w:val="0"
keepLines, keepLines=0Zeilen nicht trennenw:keepLines
pageBreakBefore, pageBreakBefore=0Seitenumbruch oberhalbw:pageBreakBefore
widowControl, widowControl=0Absatzkontrollew:widowControl
tab<twips>=dot|hyphen|underscorethe 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 linew: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:

  1. reads the RTF, skipping destinations that start with \* and the tables (fonttbl, colortbl, stylesheet, info, pict, object, header…, footer…, listtable, listoverridetable, revtbl, rsidtbl, fldinst, …), keeping fldrslt and listtext;
  2. maps \par, \cell to a line feed, \line to U+2028, \page to U+000C, \tab to 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;
  3. takes each footnote group out as a note, leaving one character U+FFFC in its place;
  4. takes each \NeXTGraphic group as one U+FFFC (and drops the 0xAC after it);
  5. leaves out hidden text (hidden, addition 5), with the footnotes and pictures in it, as Goethe Write's export does;
  6. 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.json 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.places. 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/<id>.<ext>, where <ext> is the extension of its original file name (Node.file, e.g. "Kaufvertrag.pdf"); 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.file, 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/<sha256>.png: 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.export.watermark.picture 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:

KeyMeaning
iduuid, unique in the file
ownermanuscript; also valid: script:<x>, page:<x>, cover:<x> (no :, space or control character in <x>, at most 256 bytes in all)
axishorizontal (measured on y) or vertical (measured on x)
basesheet (the paper) or textArea (the page's type area, mirrored on left-hand pages when margins are mirrored)
edgehorizontal: top, bottom, centre; vertical: inner, outer, left, right, centre
offsetpoints from that edge, finite, may be negative
scopeall, left or right pages (left-hand pages have even printed numbers)
mirrorInBookinner and outer follow mirrored margins
lockedcannot be moved or deleted by hand
colourbluePencil

At most 2,000 guides in all and 200 per owner.

8. What readers and writers must do

A reader

  1. MUST apply the rules of manifest.json (2.2).
  2. MUST read the outline from tree and find each node's text in texts/ by its id (.rtf, or TXT.rtf in an .rtfd folder), and its research file in files/ by its id.
  3. 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.
  4. 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.
  5. MUST follow 4.3 when it reads an exchange file.

A writer (a program that changes a package)

  1. MUST write manifest.json by the rules of section 2, and MUST NOT lower format of a package it may edit.
  2. MUST write every key marked Req (section 5), ids as UUIDs, times in UTC as in 5.1.
  3. MUST keep every top-level entry it does not know, byte for byte (3.3), and the files of nodes it does not change.
  4. SHOULD NOT add keys to project.json: 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 (com.example.tool/ or com.example.tool.json); Goethe Write keeps it.
  5. SHOULD keep anchors valid when it changes a text (move location and length of the anchors in that node), and MUST NOT put files into texts/, files/, snapshots/ or deleted/ that project.json does not refer to.
  6. 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.snapshots) and deleted passages (deleted/, bible.deleted, up to 200);
  • 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.goetheRules). 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.json (section 2) and the ZIP profile of the exchange file (section 4);
  • the layout of the package and the reserved names (section 3);
  • the keys of project.json and their meaning (section 5);
  • 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):

ChangeWhy
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 projectsone exact meaning on every device and in every program; anchors without the RTF reader's rules
Screenplays as a part of their own, scripts/<node id>/ (a head, one part per scene, comments and changes as records, the original FDX or Fountain bytes in sources/, versions), instead of settings.authorWorkspace.draftsloss-free Final Draft round trips, working together scene by scene
manifest.json lists every part with its SHA-256 and is written lasta 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.json that a version does not know keptthe same project gives the same bytes; newer data survives older writers
The person's window state outside project.jsona shared project carries nobody's caret
ZIP64 for exchange files over 4 GBlarge research collections
Quick Look previews and Spotlight data, the media type registered with the IANAthe file shows its content outside Goethe Write

11. Schemas, reference reader and tests

FileWhat it is
schema/manifest.schema.jsonJSON Schema (2020-12) of manifest.json
schema/project.schema.jsonJSON Schema (2020-12) of project.json, every key of section 5, with its meaning
reference/goethe_read.pyReference 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/check_schema.pyChecks packages and exchange files against the schemas; --strict lists keys the schemas do not describe
reference/test_goethe_read.pyTests of both; with GOETHE_SAMPLES=<folder> also every project Goethe Write wrote into that folder
reference/README.mdHow to use the three scripts
LICENSE.mdWhich 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/scripts/drehbuch-pruefen.sh):

  • 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; mimetype first 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) → .goethe and .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 → .goethe and .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 .lexwrite package (also one without a manifest) opens, saves in place under its name and gets a manifest;
  • a .goethex opens 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 format is kept, a newer readableFrom and another kind are refused).

12. Licence

This specification and the files that come with it are published by ICSL FZE, Sharjah, United Arab Emirates. LICENSE.md lists which licence covers which file.

  • The specification (this text, GOETHE_FORMAT_1.md, and the German short version, GOETHE_FORMAT_1.de.md): © 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: 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/LICENSE). Each of these files names its licence in an SPDX line.
  • 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/vnd.goethecloud.goethex+zip 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.

FieldValue
Type nameapplication
Subtype namevnd.goethecloud.goethex+zip
Required parametersnone
Optional parametersnone
Encoding considerationsbinary
Security considerationssection 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 considerationsa ZIP archive (PKWARE APPNOTE) restricted as in section 4.1; the first entry mimetype holds the type, stored, as in EPUB and OpenDocument
Published specificationthis document, https://goethecloud.com/format/specification/
Applications that use this media typeGoethe Write (macOS, iOS, iPadOS)
Fragment identifier considerationsnone
Magic number50 4B 03 04 at offset 0, mimetype at offset 30, application/vnd.goethecloud.goethex+zip at offset 38
File extension.goethex
Macintosh file type codenone; Uniform Type Identifier com.goethecloud.goethe.exchange
Person and e-mail to contact(filled in by the publisher at submission)
Intended usageCOMMON
Restrictions on usagenone
Author(filled in by the publisher at submission)
Change controllerICSL 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.json:

{
  "format" : 1,
  "generator" : "Goethe Write 0.1 (1)",
  "kind" : "project",
  "readableFrom" : 1
}

Its project.json (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" } }
}