@@ -1108,6 +1108,45 @@ Preset: `calendar-a4` (`ctrlgrid show calendar-a4`), which turns on every view;
 worked example: [`12-calendar-year.yaml`](examples/12-calendar-year.yaml) — 405
 pages, and the one example that ships without its PDF.
 
+#### The language of the sheet
+
+The tool ships no translations and never will (§3.4) — but it writes no word of
+its own on your sheet either. Everything printed comes from the definition:
+
+```yaml
+months: [Jänner, Februar, März, April, Mai, Juni,
+         Juli, August, September, Oktober, November, Dezember]
+weekdays: [Mo, Di, Mi, Do, Fr, Sa, So]
+notes: [{count: 40, label: Notizen}]
+words:
+  index: Inhalt
+  year: Jahr
+  month: Monat
+  week: Woche
+  notes: Notizen
+  contents: Inhaltsverzeichnis
+  full_year_overview: Jahresübersicht
+  half_year: Halbjahr
+  full_year: ganzes Jahr
+```
+
+`words:` names the calendar's own vocabulary — the navigation strip at the top of
+every page and the headings. Leave it out and you get the English above, so no
+existing definition changes. A notebook's one word is `contents_title`.
+
+**One limit to know about**, and it is the same one the README lists first: the
+standard PDF fonts reach Latin-1. German, French, Spanish, Italian, Portuguese,
+Dutch and the Nordic languages are covered. Polish, Czech, Hungarian, Turkish,
+Romanian and Croatian are not — `ń`, `ř`, `ő`, `ğ`, `ă`, `č` need a font of your
+own:
+
+```yaml
+font: {file: "~/Library/Fonts/NotoSans-Regular.ttf", size: 9pt}
+```
+
+A character the font cannot draw is refused before the first page, naming the
+character and the word it came from — it is never printed as a box.
+
 ### `notebook` — several papers in one linked document
 
 The other document generator, and the one that composes the rest: sections, each
 
@@ -57,14 +57,14 @@ def _inline_date(item) -> datetime.date | None:
     return None
 
 
-def notes_name(pads, index: int) -> str:
+def notes_name(pads, index: int, word: str = "Notes") -> str:
     """What a pad is called (§ 7). Its own label, else `Notes` when it is the
     only one and a numbered `Notes n` when it is not — two pads must never
     answer to the same name in the contents."""
     label = pads[index].label
     if label:
         return label
-    return "Notes" if len(pads) == 1 else f"Notes {index + 1}"
+    return word if len(pads) == 1 else f"{word} {index + 1}"
 
 
 def notes_index_dest(pad: int, page_no: int = 1) -> str:
@@ -241,13 +241,39 @@ class NotesSpec(Section):
     label: str | None = None
 
 
+class Words(Section):
+    """The calendar's own words on the sheet (§ 7.12, § 7.8).
+
+    § 7.12 already took month and weekday names from the definition, on § 7.8's
+    rule: the labels belong to the language of the sheet, so the tool receives
+    them and never invents them. The rest of its vocabulary — the navigation
+    strip, the headings — stayed English, so a German calendar came out with
+    `Jänner` under `Index Year Month Notes`.
+
+    These are the same rule applied to the same words. The defaults are the
+    English the tool has always printed, so an existing definition is unmoved;
+    this is not a locale table and there is none to ship (§ 3.4).
+    """
+
+    index: str = "Index"
+    year: str = "Year"
+    month: str = "Month"
+    week: str = "Week"
+    notes: str = "Notes"
+    contents: str = "Contents"
+    full_year_overview: str = "Full-year overview"
+    half_year: str = "Half-year"
+    full_year: str = "full year"
+
+
 class CalendarConfig(BaseModel):
     """The definition section for the calendar (§ 3.6, seam 2)."""
 
     model_config = ConfigDict(extra="forbid", frozen=True)
 
     year: int = Field(ge=1, le=9999)
     week_start: Literal["monday", "sunday"] = "monday"
+    words: Words = Words()
     months: tuple[str, ...] | None = None
     weekdays: tuple[str, ...] | None = None
     holidays: tuple[Holiday, ...] = ()
@@ -446,7 +472,8 @@ def describe(self, cfg: CalendarConfig) -> list[str]:
             lines.append(f"{len(cfg.holidays)} holidays")
         for index, pad in enumerate(cfg.notes):
             lines.append(
-                f"{pad.count} {notes_name(cfg.notes, index)!r} pages, {pad.surface}"
+                f"{pad.count} {notes_name(cfg.notes, index, cfg.words.notes)!r} pages, "
+                f"{pad.surface}"
             )
         return lines
 
@@ -544,7 +571,7 @@ def _notes_index_toc(self, cfg, layout, area) -> list[tuple[str, str]]:
         index pages already lead to each other.
         """
         return [
-            (notes_name(cfg.notes, index), notes_index_dest(index))
+            (notes_name(cfg.notes, index, cfg.words.notes), notes_index_dest(index))
             for index in range(len(cfg.notes))
         ]
 
@@ -571,7 +598,7 @@ def make() -> layout.Page:
         def nav(month: int = 1, week_no: int = 1) -> layout.Nav:
             return layout.Nav(
                 month=f"month-{month:02d}", week=f"week-{week_no:02d}",
-                has_week=has_week, has_notes=has_notes,
+                has_week=has_week, has_notes=has_notes, words=cfg.words,
             )
 
         def wk(date: datetime.date) -> int:
@@ -618,7 +645,8 @@ def _notes_pages(self, cfg, layout, page, nav) -> Iterator[DocumentPage]:
         # Every pad's index links to every other one, so the pads are reachable
         # from each other and not only through the contents (§ 7).
         others = [
-            (notes_name(cfg.notes, i), notes_index_dest(i)) for i in range(len(cfg.notes))
+            (notes_name(cfg.notes, i, cfg.words.notes), notes_index_dest(i))
+            for i in range(len(cfg.notes))
         ]
         for pad_no, pad in enumerate(cfg.notes):
             count = pad.count
@@ -628,15 +656,15 @@ def _notes_pages(self, cfg, layout, page, nav) -> Iterator[DocumentPage]:
             for page_no, numbers in enumerate(chunks, start=1):
                 yield layout.notes_index_page(
                     page(), cfg, nav, pad=pad, pad_no=pad_no,
-                    name=notes_name(cfg.notes, pad_no), others=others,
+                    name=notes_name(cfg.notes, pad_no, cfg.words.notes), others=others,
                     page_no=page_no, page_count=len(chunks), numbers=numbers,
                     prev=notes_index_dest(pad_no, page_no - 1) if page_no > 1 else None,
                     nxt=notes_index_dest(pad_no, page_no + 1) if page_no < len(chunks) else None,
                 )
             for i in range(1, count + 1):
                 yield layout.note_page(
                     page(), cfg, nav, pad=pad, pad_no=pad_no,
-                    name=notes_name(cfg.notes, pad_no), num=i,
+                    name=notes_name(cfg.notes, pad_no, cfg.words.notes), num=i,
                     prev=note_dest(pad_no, i - 1, count) if i > 1 else None,
                     nxt=note_dest(pad_no, i + 1, count) if i < count else None,
                 )
@@ -104,6 +104,15 @@ class Nav:
     week: str
     has_week: bool = False
     has_notes: bool = False
+    words: object | None = None
+    """The calendar's own vocabulary (§ 7.12). `None` keeps the English the
+    tool has always printed, which is what a caller without a config wants."""
+
+    @property
+    def w(self):
+        from ctrlgrid.generators.calendar import Words
+
+        return self.words or Words()
 
 
 def nav(page: Page, n: Nav) -> None:
@@ -115,11 +124,12 @@ def nav(page: Page, n: Nav) -> None:
     title owns the left, and the two no longer compete for the same corner.
     """
     size = pt(9)
-    entries = [("Index", "index"), ("Year", "year"), ("Month", n.month)]
+    words = n.w
+    entries = [(words.index, "index"), (words.year, "year"), (words.month, n.month)]
     if n.has_week:
-        entries.append(("Week", n.week))
+        entries.append((words.week, n.week))
     if n.has_notes:
-        entries.append(("Notes", "notes-1"))
+        entries.append((words.notes, "notes-1"))
     gap = pt(14)
     widths = [page.q.text_width(label, family="sans", size=size) for label, _ in entries]
     # Ranged against the right edge: on the left it shared the corner with the
@@ -216,9 +226,9 @@ def contents_page(page: Page, cfg, n: Nav, months, notes_index) -> DocumentPage:
     nav(page, n)
     groups = [
         [
-            ("Full-year overview", "year"),
-            (f"Half-year 1 · {months[0][:3]}–{months[5][:3]}", "half-1"),
-            (f"Half-year 2 · {months[6][:3]}–{months[11][:3]}", "half-2"),
+            (cfg.words.full_year_overview, "year"),
+            (f"{cfg.words.half_year} 1 · {months[0][:3]}–{months[5][:3]}", "half-1"),
+            (f"{cfg.words.half_year} 2 · {months[6][:3]}–{months[11][:3]}", "half-2"),
         ],
         [(months[i], f"month-{i + 1:02d}") for i in range(12)],
         list(notes_index),
@@ -248,7 +258,7 @@ def contents_page(page: Page, cfg, n: Nav, months, notes_index) -> DocumentPage:
     block = contents_height(entries, len(groups) + (1 if legend else 0))
     top = CONTENTS_NAV + max(0, round((page.H - CONTENTS_NAV - block) / 2))
 
-    page.text(round(page.W / 2), top, "Contents", pt(20), INK, "center")
+    page.text(round(page.W / 2), top, cfg.words.contents, pt(20), INK, "center")
     top += _CONTENTS_TITLE_GAP
     for index, group in enumerate(groups):
         if index:
@@ -266,7 +276,7 @@ def contents_page(page: Page, cfg, n: Nav, months, notes_index) -> DocumentPage:
                      0.2, GUIDE, entry.color)
             page.text(left + _KEY_PATCH + _KEY_GAP, top, entry.label, size, INK)
             top += _CONTENTS_LINE
-    return page.done("index", "index", "Contents")
+    return page.done("index", "index", cfg.words.contents)
 
 
 def year_overview_page(page: Page, cfg, n: Nav, months, weekdays) -> DocumentPage:
@@ -278,7 +288,7 @@ def year_overview_page(page: Page, cfg, n: Nav, months, weekdays) -> DocumentPag
     zooms (§ 8.2)."""
     nav(page, n)
     top = pt(16)
-    page.text(0, top, f"{cfg.year} · full year", pt(15), INK)
+    page.text(0, top, f"{cfg.year} · {cfg.words.full_year}", pt(15), INK)
     top += pt(22)
     cols, rows = 3, 4
     gutter = _YEAR_GUTTER
@@ -290,7 +300,7 @@ def year_overview_page(page: Page, cfg, n: Nav, months, weekdays) -> DocumentPag
         _mini_month(page, cfg, months, weekdays, m + 1,
                     c * (cell_w + gutter), top + r * (cell_h + gutter), cell_w, cell_h,
                     n.has_week, marked)
-    return page.done("year", "year", f"{cfg.year} full year")
+    return page.done("year", "year", f"{cfg.year} {cfg.words.full_year}")
 
 
 #: The air between two day columns. The mini-month is built from its content
@@ -417,9 +427,10 @@ def half_year_page(page: Page, cfg, n: Nav, months, half: int) -> DocumentPage:
     span = f"{months[first_month - 1][:3]}–{months[first_month + 4][:3]}"
     prev = "half-1" if half == 2 else None
     nxt = "half-2" if half == 1 else None
-    top = crumb(page, title=f"Half-year {half} · {span}", prev=prev, nxt=nxt, up="year")
+    title = f"{cfg.words.half_year} {half} · {span}"
+    top = crumb(page, title=title, prev=prev, nxt=nxt, up="year")
     _half_table(page, cfg, months, top, page.H - top - pt(2), first_month=first_month)
-    return page.done(f"half-{half}", "half", f"Half-year {half}")
+    return page.done(f"half-{half}", "half", f"{cfg.words.half_year} {half}")
 
 
 def _half_table(page: Page, cfg, months, top, h, *, first_month: int) -> None:
 
@@ -209,7 +209,7 @@ def pages(
             if section.divider:
                 yield layout.divider_page(
                     name, section, area, dest=_section_dest(index), q=q,
-                    placeholders=placeholders,
+                    placeholders=placeholders, contents_title=cfg.contents_title,
                 )
             for number in range(1, section.pages + 1):
                 dest = (
 
@@ -95,7 +95,8 @@ def contents_page(cfg, starts: list[int], area: Area, *, q: WriterQuery) -> Docu
 
 
 def divider_page(
-    name: str, section, area: Area, *, dest: str, q: WriterQuery, placeholders
+    name: str, section, area: Area, *, dest: str, q: WriterQuery, placeholders,
+    contents_title: str = "Contents",
 ) -> DocumentPage:
     """A sheet before a section: its name, a rule to write a subtitle under, and
     the way back to the contents."""
@@ -106,7 +107,7 @@ def divider_page(
     page.hline(0, area.width, top + pt(26) + pt(52), 0.25, GUIDE)
     # The way back, at the top right — where the calendar's nav strip sits, so
     # the two documents are read the same way.
-    back = "Contents"
+    back = contents_title
     width = q.text_width(back, family="sans", size=pt(10))
     page.link_text(area.width - width, TOP_MARGIN, back, CONTENTS_DEST, pt(10))
     return DocumentPage(
 
@@ -816,3 +816,78 @@ def test_unlabelled_pads_are_still_told_apart(self) -> None:
     def test_no_link_dangles_across_the_pads(self) -> None:
         _pages, dests_, edges = _graph(cfg(notes=self.PADS))
         assert sorted(t for _s, t in edges if t not in dests_) == []
+
+
+class TestEveryWordOnThePageComesFromTheDefinition:
+    """§ 7.12 takes month and weekday names from the definition and ships no
+    translation table (§ 3.4, § 7.8). It did that for the *names* and not for the
+    rest, so a German calendar came out mixed: `Jänner` under a nav strip reading
+    `Index Year Month Notes`, beside `Contents`, `Full-year overview` and
+    `Half-year 1 · Jän–Jun`.
+
+    Those are the tool's words on the user's sheet, which is the thing § 7.8
+    rules out. They are configurable now, with today's English as the default so
+    no existing definition moves.
+    """
+
+    GERMAN = (
+        "version: 1\n"
+        "page: {format: a4, margin: 12mm}\n"
+        "generator: calendar\n"
+        "year: 2027\n"
+        "months: [Jänner, Februar, März, April, Mai, Juni, Juli, August,\n"
+        "         September, Oktober, November, Dezember]\n"
+        "weekdays: [Mo, Di, Mi, Do, Fr, Sa, So]\n"
+        "notes: [{count: 2, label: Notizen}]\n"
+        "words:\n"
+        "  index: Inhalt\n"
+        "  year: Jahr\n"
+        "  month: Monat\n"
+        "  notes: Notizen\n"
+        "  contents: Inhaltsverzeichnis\n"
+        "  full_year_overview: Jahresübersicht\n"
+        "  half_year: Halbjahr\n"
+        "  full_year: ganzes Jahr\n"
+    )
+
+    def test_no_english_word_survives_on_the_first_pages(self, tmp_path: Path) -> None:
+        from pdfread import text_on
+
+        from ctrlgrid.loader import loads
+        from ctrlgrid.pages import build
+        from ctrlgrid.writers.pdf import PdfWriter
+
+        path = tmp_path / "de.pdf"
+        build(loads(self.GERMAN, source="test"), PdfWriter(path))
+        pages = " ".join(text_on(path, page) for page in range(4))
+        for english in ("Index", "Year", "Month", "Notes", "Contents",
+                        "Full-year", "Half-year", "full year"):
+            assert english not in pages, english
+
+    def test_and_the_german_words_are_there_instead(self, tmp_path: Path) -> None:
+        from pdfread import text_on
+
+        from ctrlgrid.loader import loads
+        from ctrlgrid.pages import build
+        from ctrlgrid.writers.pdf import PdfWriter
+
+        path = tmp_path / "de2.pdf"
+        build(loads(self.GERMAN, source="test"), PdfWriter(path))
+        pages = " ".join(text_on(path, page) for page in range(4))
+        for german in ("Inhalt", "Jahr", "Monat", "Inhaltsverzeichnis",
+                       "Jahresübersicht", "Halbjahr", "ganzes Jahr"):
+            assert german in pages, german
+
+    def test_the_english_default_is_unchanged(self, tmp_path: Path) -> None:
+        # No `words:` block at all: every existing definition must be untouched.
+        from pdfread import text_on
+
+        from ctrlgrid.loader import loads
+        from ctrlgrid.pages import build
+        from ctrlgrid.writers.pdf import PdfWriter
+
+        text = self.GERMAN.split("words:")[0]
+        path = tmp_path / "en.pdf"
+        build(loads(text, source="test"), PdfWriter(path))
+        pages = " ".join(text_on(path, page) for page in range(4))
+        assert "Contents" in pages and "Full-year overview" in pages
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ def pages(`
`209`	`209`	`if section.divider:`
`210`	`210`	`yield layout.divider_page(`
`211`	`211`	`name, section, area, dest=_section_dest(index), q=q,`
`212`		`- placeholders=placeholders,`
	`212`	`+ placeholders=placeholders, contents_title=cfg.contents_title,`
`213`	`213`	`)`
`214`	`214`	`for number in range(1, section.pages + 1):`
`215`	`215`	`dest = (`