No description
  • Swift 93.2%
  • Python 6.4%
  • Shell 0.4%
Find a file
Dušan Bratuša b91914018b The toolbar in the Mac's own controls: Page | Table segmented, Import and Recognize round buttons
On macOS 26 the toolbar draws its glass around each item, and the app's
own controls did not sit in it in proportion:

- Page | Table was the app's TabPicker, its lens of a fixed 20 points in
  glass about 38 points high: wide margins above and below it, hardly
  any at the right. It is the Mac's segmented control now, which the
  glass is drawn to fit. ⌥⌘T as before; TabPicker stays for the panes.
- Import (+) and Recognize were split buttons (icon, a line, a chevron),
  wider and heavier than the round buttons beside them. They are round
  buttons now: a click imports or recognizes the page, click and hold
  shows their menu, as their help said already. Everything in those
  menus is also in the menu bar (File › Add from Matricula…, the
  Recognize menu).

Style.swift's notes say so: on the toolbar the Mac's own controls, the
app's for the panes and a panel of glass. The manual's toolbar line
names the click and hold.

Checked by type-checking the app and a close look at the toolbar in the
UI gallery's pictures before the change (they leave the glass out). Not
seen in the app.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 20:53:39 +01:00
docs The toolbar in the Mac's own controls: Page | Table segmented, Import and Recognize round buttons 2026-11-13 20:53:39 +01:00
engine Trained models measured on proofread pages, reading aids kept to sure gains, training seeded with a manifest 2026-11-12 16:37:30 +01:00
Resources Initial comit 2026-10-10 09:09:10 +02:00
scripts Quiet capsule controls, not glass on glass; Search Options beside the field; install_app.sh 2026-11-12 18:08:10 +01:00
Sources The toolbar in the Mac's own controls: Page | Table segmented, Import and Recognize round buttons 2026-11-13 20:53:39 +01:00
Tests A book's pages as a map of squares in the sidebar, not a row per page; a finished book shows a check 2026-11-12 22:19:54 +01:00
.gitignore Initial comit 2026-10-10 09:09:10 +02:00
CITATION.cff Provenance foundations: versions on records, scores with decisions, stable ids 2026-10-15 19:49:37 +02:00
Package.swift Initial comit 2026-10-10 09:09:10 +02:00
README.md Ask AI What It Reads: the AI's best guess at what the part says, translated into a language chosen in Settings 2026-11-13 13:10:49 +01:00

Kraken Native

A fast, native macOS application for transcribing historical handwritten documents — especially 18th- and 19th-century parish registers in German Kurrent, Latin and Slovenian — with the open-source Kraken OCR/HTR engine. Everything runs locally on your Mac.

Kraken Native with a 1770 baptism register

How to use it, chapter by chapter, with common tasks step by step and an FAQ: the user manual, also in the app (Help › Kraken Native Manual, offline).

Features

  • Import PNG, JPEG, TIFF (multi-page) and PDF files or whole folders by drag and drop or ⌘O. Originals are preserved unchanged; PDF pages are rendered at the native resolution of the embedded scans.
  • Recognize with Kraken 7.1.1: automatic layout analysis (regions, baselines, line polygons, reading order) and line recognition with per-character confidences — one page, a whole book, selected lines, a drawn region, or a line you draw by hand. Progress, device and timing are shown; everything can be cancelled. While long work goes on (recognition, training, fixing a book, Matricula) the Mac is kept from sleeping, the Dock icon shows how far it is, and a notification says what it came to when you are in another app.
  • View pages in a smooth, native viewer: zoom with the mouse wheel or a pinch, drag to pan, rotation, line and region overlays, reading-order numbers. A page whose writing slopes can be turned a little by hand (the level button beside the rotate buttons, or View › Turn Page a Little…): a slider, steps of 0.05°, or Level from Lines, with a reference line across the page to drag onto a line of writing or a ruled line and turn it level by. The turn is kept with the page: its entries are read levelled by it (the Columns editor shows it so), and the page is read turned when it is recognized again. Pointing at a line shows its recognized text above it (View › Show Text on Hover).
  • Correct line text side by side with the image. Clicking a line in the image selects its text and vice versa; uncertain characters are highlighted; corrections are saved automatically and kept separate from Kraken's output (revert any time). A word being typed is finished from the library's words (Complete Word, ⌥⎋ or F5): those you wrote yourself first — lines you corrected, pages you proofread — then those read often. Edit line shapes (drag vertices, move, add/delete vertices), delete or add lines, and change the reading order by dragging a line by its number or with By Rows (table entries) / By Columns / Automatic. A name or place the layout analysis cut into two boxes on one row is put back together with Join Lines (⌘J; Join as One Word, ⌥⌘J, without a space; a hyphen at the break goes), and a line running two things together is divided with Split Line… (click the gap between the words) or ⌥↩ while editing it. The shapes follow; nothing is read again, and a machine reading stays a machine reading. Everything is undoable.
  • Books: every imported file or folder becomes a book of pages. Join books by dragging one onto another (or Join Into in its menu), drag pages between books or to a new place in their book (a page dropped on a shelf, or on the Books heading, becomes a book of its own), and rename pages; pages keep their transcriptions. File › Join Scans into Books by File Name… gathers scans imported one by one, such as svetinje_03820_pg5.jpg, into the book “svetinje_03820” in page order. A page's menu shows its image in the Finder or copies its path (Copy Path; the paths of all pages selected, one per line).
  • Automatic fixes: Fix Book Automatically… fixes uncertain words using words you wrote (and words read clearly elsewhere in the book), but only where the recognition model's own reading of the image supports the fix; numbers are never changed. Fixes show in purple, can be reverted everywhere in the book, undone all at once, or accepted (a purple check, kept as such when the line is read again and in PAGE and ALTO exports), and count as checked only when you accept them or proofread the page. A line is read, fixed automatically, accepted or corrected by you; checked lines are never read again or fixed. Optionally, for books whose AI permissions allow it, a cloud model proposes fixes from the recognized text — never images — which pass the same image check: Claude with an Anthropic key, or any model of OpenCode Zen or OpenCode Go with an OpenCode key (Settings › AI); the run says what that cost. Improve Book… lists its four steps with your numbers, then fixes, trains on your checked lines, recognizes the rest again and fixes that. A page's menu does both for that page, or for the pages selected with ⌘-click; pages are corrected three at a time. A running correction can be hidden and keeps going (the sidebar shows it); starting another meanwhile queues it. Measurements: docs/ACCURACY.md.
  • Matricula Online: File › Add from Matricula… (⇧⌘M) takes the link of a register on data.matricula-online.eu, downloads all pages or a range (a ?pg= link selects that page) and adds them to a new book or to the book you already have for that register, labelled pg<N> in page order; pages already there are skipped. Links of parishes (one per line, several at once) list their registers: the chosen ones become books with all their pages, arranged as Parish › Krsti / Poroke / Smrti / Drugo › “1. Krstni index 1788-1825”, numbered by their years (adding again continues where it stopped, and moves an earlier flat import into place).
  • Page map: a book's pages are under it in the sidebar as one square per page, ten to a row. A square's fill says how far the work on its page has come (not read, waiting, being read, read, fixed automatically, corrected, proofread, failed) and the open page is ringed. The square under the pointer shows its page's number beside it; rest the pointer there for the page's scan, number, name and counts; click to open it, ⌘- or ⇧-click to select several, drag it to move the page, right-click for its menu.
  • Shelves: group books on shelves of your own, and shelves inside shelves to any depth (+ in the sidebar, ⌃⌘N, a shelf's New Shelf Inside, a book's Move to Shelf; or drag books and shelves onto a shelf, or onto the Books heading to take them off their shelf). Deleting a shelf moves its books and shelves up a level. A shelf's menu recognizes, re-recognizes unchecked lines of, or fixes all its books (also only the pages not recognized yet).
  • Tags on lines (an entry, a person, “to check”): select lines and Tag Lines… (⌃⌘T, or right-click). The tag button beside Search's options (⌃⌘3) lists every tag by group, where they are made, edited and grouped; click one and Search keeps to its lines (with no words, all of them, with their entries).
  • Research: documents of your own, listed in the sidebar's Research view (⌃⌘4), each opening in its own window to keep beside the book. With the Region tool's Clip to Research (⌘4) draw around part of a page: it goes to the selected research as an image, with a link back to the page (click it) and the transcribed lines inside it, all editable rich text; write your notes in between. It is written on white A4 or Letter pages, as in a word processor (zoom with ⌘+ / ⌘− / ⌘0 or the toolbar), and Export as PDF (in the window or the sidebar) gives the same pages, numbered. Kept in the library's Research folder.
  • The Region tool: one tool draws a rectangle for its action, chosen under what each does with what is drawn — Cite in Family Tree and Clip to Research (make evidence), Mark People (says who is there), Ask AI What It Reads (leaves this Mac), Recognize Here and Print (stay on it); ⌘3–⌘7. A strip above the viewer bar says what it does, to what, and Esc stops it.
  • People, two halves: Yours (your family trees above your people) and From the Registers (the people the entries name, and their houses). One click on a person shows their entry on the page and their card in the right panel (Lines | Entries | Person), headed From the registers (automatic) or Yours, with the way to the other kind.
  • Ask the AI what it reads: with the Region tool's Ask AI What It Reads (⌘6) draw around part of a page; the AI chosen in Settings › AI writes out what it reads there, letter by letter as written, then its best guess at what it says translated into Slovene (or the language chosen there), with short notes on doubtful readings and abbreviations, in a card over the page. Copy from it and correct what you like yourself: nothing is changed by it. The model's name in the card asks again with another (Claude Fable 5.1 is among them). Only that part of the page is sent, and only for a book whose AI permissions allow parts of its images. The card shows what it cost.
  • Search all books in the sidebar's Search tab (⇧⌘F): every page of every book at once, matches listed under their book (fold them one by one or all at once); clicking one opens the page at that line. Type the words and press Return, or Search beside the field: nothing is searched while you type, so typing stays quick in a large library. The tab keeps its search while you work in the Books tree, and shows it again as it was left. Search in:, above the search rows, says where: every book, an area, or the shelves and books you tick; it starts at the area you work in and is shared with People and Houses. The field stays above the results as they scroll. Several words find the places where all of them occur within a few lines of each other (an entry's name, year and place, also across columns); a phrase in quotes stays together. A word of five letters or more is also found where it was written or read in two parts — Bratuscha in “Bratu scha”, “Bratu-scha”, “Bratu-” at the end of a line and “scha” below it, or two boxes side by side on one row. Areas hold shelves and books researched together (a shelf's or book's menu › Area, or ticked in Search in: › Save as Area…); @name in the field chooses one to search in (@Svetinje Bratuša 1788; typing @ offers them). Search groups of earlier versions became areas. The Years filter above the results searches only the books of those years (from–to, either may be left open). A book's years are taken from its title or the register's data on Matricula when it is added (books from before were given theirs from their titles); see or change them in its menu › Years…. Or filter the open page's lines (⌘F) to show only those containing a word, with matches highlighted.
  • Train on your corrections: after you correct or proofread a few pages of a register, Train Recognition Model… adapts the model to that hand on your Mac (a few minutes on the GPU) and keeps it only if it makes fewer errors on lines held back from training — in our tests 17–29% fewer errors with 100–220 lines. Mark a page whose text is entirely right as proofread (✓ above the transcription, ⌃⌘P) so its lines count too: the lines held back come only from proofread pages, so at least one is needed. A book on a shelf also trains on the corrected or proofread lines of the shelf's other books (a switch in the training and Improve dialogs), but is measured on its own lines. To start sooner, Accept Automatic Fixes… (Recognize menu, book menu) makes a book's purple fixes accepted lines; training learns from them only if you ask, and never measures on them (their unfixed words are the model's own reading). A model is kept only if it is surely better: the 95% interval of the change, over the held-out lines, lies below zero. The training is seeded, and training.json beside a kept model says what it was made of.
  • Entries as a table: Page | Table at the top of the window (⌥⌘T) shows the open page's entries — or the whole book's — as a table in place of the scan, rows wrapping like the entries on the page; columns sort, resize and hide (Show Columns), and a double click edits an entry. The Edit Columns… window (as large as the screen, following the open page) sets a book's columns and a header line above which nothing is read — for an opened book, one for each page (drag each on its own: the two pages seldom lie level). All Pages | This Page chooses whose columns you edit: the book's, read on every page, or the open page's own, read instead of the book's (a title page set to Not Read, a page of another form); Use the Book's Columns lets them go. It also shows where the page's entries begin, as red lines: drag one to move it, double-click to add one, select one and press Delete to remove it. Lines are tinted entry by entry (orange where a row runs through one), and the check against the running numbers follows. Rows are kept for each page (only those you touched), survive the page being recognized again, and Use Found Rows lets the rules cut it again. Entries you fixed by hand keep their lines unless you choose Cut Entries Fixed by Hand Too; pages the cloud model read keep its entries.
  • Entries read wrongly, put right: an entry's menu (⋯ or right-click, in the Entries panel and the table) has Combine with Entry Above / Below for one entry read as two, and Divide Entry Here for two read as one: click the line where the second entry begins (its date, say), and the entry is divided at the ruled line above it. New Entry from Selected Lines and Use Selected Lines read the entry's fields from those lines. What you typed in an entry stays; the entries are kept as they are when the page is read again; ⌘Z undoes. Also in the Entries menu, for the entry the lines selected on the page are in (and ⌘K).
  • Name indexes: a book titled indeks, index or Kazalo is read as names, each with its date and folio, one list or several side by side. Each name is looked for in the register on the same shelf (the same day, the same names) and shown with what the register reads there, else placed on the page its folio falls on; Show opens the register at it.
  • Your names and places: in Names and Places…, say which spellings are one name where the spelling rules cannot (Kovacsics and Kovačič; Jera and Gertraud — Same Name as…, J) and which only look alike (Kos and Kosi — Keep Apart, K); Your Names lists them. Under Places, make the places the entries name your own, by all their names — Friedau, Ormož, Ormosch — with their language and years, the parishes they belonged to and when (two Dobravas are told apart by the parish of the entry's book), and their GOV or GeoNames ids. The People search, house search, linking, the Filter's similar spellings and the family-tree checks go by them; what the registers wrote is never changed. After each change the window says how many persons were joined or split, with Undo. The AI's answers about names are only suggestions until you accept them.
  • Family trees of your own conclusions: a drag-and-drop canvas per tree (listed in People › Yours above your people, the one people are added to marked; File › New Family Tree). People come in from an entry (Add to “…”, naming the tree, on an entry card, in the table, on a person card, or dragged from the People list) with what that entry says of them, citing it; from a part of a page drawn with the Region tool's Cite in Family Tree; or typed in by hand. Every assertion (name, birth, baptism, marriage, death, residence…) and every link cites its evidence, shown with what it said when cited and what it says now; uncited boxes and links are drawn grey and dashed. One person per library, shared by every tree. Who is who is decided among your people: Link as One Person…, Same Person… and Not This Person on a person card make, extend or narrow one of them (an entry said not theirs is kept so), and the automatic People index follows that. Drag from a box's handles to link parent, child or spouse; Arrange as ancestors or descendants; ⌘Z undoes a change, and only it (what another window changed since is left), and every change is logged (People › Changes to Your People). Export Tree (GEDCOM)… (or Export Your People) writes them for Gramps: each event citing its register, page and entry with what it said, QUAY the lower of how surely it was read and how direct the evidence is. Print… puts the chart on one page or full size over several (or saves it as a PDF), with the sources numbered after it — people who may be living (born after the privacy year, no death found) without details, here and in every export. Review… (experimental) has the AI walk the tree: the app's rules check the dates first, then the model reads each person's and link's evidence and searches the registers for what was missed (a namesake, a dead sibling, a contradicting entry) and comments on each — agrees with the cited evidence, weak, contradicted, no evidence — worst first, never changing the tree. A comment citing what the run never read, or quoting words not there, is kept as unverified. What is sent is said before it starts; people who may be living and entries after the privacy year stay on the Mac (for the research agent too). Each review is kept with the model, its instructions and the whole conversation; answer a comment (“seen — I disagree because…”) and the next review gets the answer.
  • Gold pages: a page you proofread and whose entries you made right by hand can be held out as gold (★ above the transcription). It is never trained on or learned from; --genealogy-eval measures the recognition, the reading rules and the AI against the gold pages, with intervals (see docs/ACCURACY.md).
  • Models: one-click download of the recommended multilingual PP-OCRv6 models (the most accurate we measured on Kurrent and Latin-script registers), the full public Kraken model repository, or import of .mlmodel / .safetensors files. Every model is validated by Kraken before use; layout and recognition models are chosen separately, and each book keeps its own recognition model (Kurrent and Latin-script registers side by side). An optional Latin script only filter keeps multilingual models from mixing in look-alike Cyrillic or Greek letters. What helps accuracy and what does not: docs/ACCURACY.md.
  • Export plain text (UTF-8), ALTO XML 4.4 or PAGE XML 2019 for a page or a whole book, with polygons, baselines, regions and reading order — validated against the official schemas.
  • Fast on Apple Silicon: parallel engine processes, a single Metal (GPU) slot where it helps, measured per-model device choice, performance profiles (Automatic, Maximum Performance, Energy Efficient). About 40 pages per minute on an M5 Max. See docs/PERFORMANCE.md.
  • Private: no telemetry; recognition runs on your Mac. The network is used only for model and Matricula downloads you start, and for what a book's AI permissions allow (Recognize › AI Permissions for This Book…: its recognized text, its text with the lines' places, parts of its page images) to the service you chose (Anthropic or OpenCode), when you start something that uses it. A book that runs past the living-people year, or whose years are unknown, sends nothing until you confirm it may. Crops of handwriting go only from books allowing it: the part you draw around with Ask AI What It Reads, and the names' lines in Read Names with AI (with its images switch on).

Requirements

  • Mac with Apple Silicon, macOS 15 or later.
  • About 1.1 GB of disk space for the app (it contains the complete Kraken runtime), plus your library. Each parallel engine process uses up to ~3.5 GB of memory while it works; the app limits parallelism to your Mac's memory.

Getting started

  1. Open Kraken Native.app (build it as described below; the build puts it in /Applications).
  2. On first launch the Models window opens. Click Download next to PP-OCRv6 medium. The default layout model is built in. Run Settings › Performance › Run Benchmark once on an open page: PP-OCRv6 medium then recognizes on the GPU, 2.5× faster with identical text.
  3. Drag a scanned register (images, a PDF or a folder) into the window.
  4. Click Recognize (⇧⌘R) for the page, or use the menu next to it to recognize all pages.
  5. Read and correct the text in the panel on the right. Press Return to move to the next line. Changes are saved automatically. When every line of a page is right, mark it as proofread (✓).
  6. After about two corrected or proofread pages, choose Recognize › Train Recognition Model…, then Recognize Unchecked Lines Again to apply the new model to the rest of the book. Where the writing slopes (lines begun high and run down across the page) or the paper is stained or grainy, Measure on Proofread Pages in the book's reading settings (the toolbar's model button) reads some proofread pages as scanned, straightened (each page of a spread turned level by its own tilt), with the paper made white, smoothed, and with all three, and recommends one only when it reads surely better than as scanned (its interval below zero, as for a trained model); Use for This Book then reads the book so whenever its pages are recognized again (a book follows the standard settings, Settings › General, until it has its own). The scans are not changed. Restore Page from Backup… brings back a page recognized again over your work. To read faded ink yourself, Ink Only (⌃⌘I, or the half-filled circle below the page) shows the page with its paper made white and the writing kept; the sliders beside it set how dark the writing is made, how much grain is smoothed away and how much faint show-through from the other side is made paper (shown only: the scan and the recognition stay as they are).
  7. Export (⌘E) as text, ALTO or PAGE XML.

The library lives in ~/Library/Application Support/Kraken Native/; quit and reopen at any time — recognition results and corrections are kept.

Keyboard shortcuts

Action Keys
Import / Add pages to book ⌘O / ⇧⌘O
Add book from Matricula ⇧⌘M
Save now / Export ⌘S / ⌘E
Recognize page / all pages / selected lines ⇧⌘R / ⌥⇧⌘R / ⌃⌘R
Cancel processing ⌘.
Select / Add Line ⌘1 / ⌘2
Region tool: Recognize Here / Clip to Research / Print / Ask AI What It Reads / Mark People ⌘3 / ⌘4 / ⌘5 / ⌘6 / ⌘7
Print the page / a region of it (with a preview first) ⌘P / ⌥⌘P
Show books / search / search's tags / research / people in the sidebar ⌃⌘1 / ⌃⌘2 / ⌃⌘3 / ⌃⌘4 / ⌃⌘5
Zoom in / out / actual size / fit / fit width ⌘+ / ⌘− / ⌘0 / ⌘9 / ⌘8
Zoom around the pointer Mouse wheel (Shift or ⌥ + wheel scrolls); pinch or ⌘-scroll on a trackpad
Rotate left / right ⌘L / ⌥⌘R
Turn the page a little View › Turn Page a Little…
Previous / next page ⌘[ / ⌘]
Back / forward to where you were before jumping to a page (a search match, an entry, a citation) ⌃⌘← / ⌃⌘→
Go to a page by its number or name ⌃⌘G, or click the page counter
Quick Actions: every command available now, found by typing (↑ ↓, Return, Esc) ⌘K
Select the open page in the sidebar's tree (the target button above it); the link button beside it makes the tree always follow the open page ⇧⌘J
In a book's page map in the sidebar, after a click: the page before / after, a row of ten up / down ← / →, ↑ / ↓
Move selected line up / down in reading order ⌥⌘↑ / ⌥⌘↓
Join the selected lines of one row / as one word ⌘J / ⌥⌘J
Split the line being edited at the cursor ⌥↩
Complete the word being typed, from the library's words (yours first) ⌥⎋ or F5
Mark page as proofread ⌃⌘P
Filter the page's lines by text ⌘F (Esc clears)
Delete the selected shelf, book or page in the sidebar (Return confirms) / without asking ⌫ / ⌘⌫
Rename the selected shelf, book, page, research or family tree in the sidebar ⌘R
Hide all markings (the bare page) ⌃⌘M, or the eye below the page
Mark tagged lines on the page (also on the bare page) the tag button below the page
Show lines / regions / reading order / uncertain text ⌥⌘L / ⌥⌘G / ⌥⌘N / ⌥⌘U
In the viewer: select previous/next line, edit, delete ↑ / ↓, Return, ⌫
While editing: next line / previous line / done Return or Tab / ⇧Tab / Esc
Shape editing: delete vertex / add vertex ⌥-click vertex / double-click outline

Building from source

Prerequisites (build machine only — users need nothing but the app):

  • Xcode with a Swift 6 toolchain on Apple Silicon (built and tested with Xcode 27 on macOS 27)
  • uv (brew install uv) to fetch the standalone Python and the locked dependencies
scripts/build_app.sh

This builds the engine runtime once (build/runtime, ~1 minute; force a rebuild with --rebuild-runtime), compiles the app in release mode and assembles build/Kraken Native.app, signed ad hoc for local use, then copies it to /Applications, replacing the one there. While that one is running it is left alone (its engine reads its files as it works): the script says so. Once the app is quit, copy the build without building again:

scripts/install_app.sh

Run all tests (engine protocol tests and Swift unit/integration tests):

scripts/test.sh

The dependency lock (engine/requirements.lock, with hashes) is regenerated with scripts/lock_engine.sh.

End-to-end self-test

The app can run the complete user workflow on its own, through the same code the interface uses (import → model → recognize → correct → reorder → save → reload from disk → export), and write a report:

"build/Kraken Native.app/Contents/MacOS/KrakenNative" --library /tmp/kn-lib \
    --self-test path/to/scan-or-folder --self-test-download 10.5281/zenodo.21788410 \
    --self-test-output /tmp/kn-out

--self-test-model <file> imports a local model instead; --self-test-benchmark adds the CPU/GPU benchmark; --self-test-train (with a folder of page images and PAGE XML ground truth of the same names) loads the ground truth as proofread pages, trains a model, checks that it is more accurate and recognizes the last page again with it; --self-test-correct (same folder) corrects the last page automatically, undoes it and improves the book, reporting its error rate at each step; --self-test-matricula <link> adds pages of a register on Matricula Online twice (new book, then overlapping pages) and checks the result.

To measure responsiveness on a real library, run it on a copy: KrakenNative --library <copy> --performance <dir> opens it (without the engine), times the search index, searches with the library's own words and turning pages, records the longest the main thread was busy during each (performance.json), and quits.

Architecture

SwiftUI/AppKit app + the unmodified Kraken engine in bundled worker processes (relocatable CPython 3.13), talking JSON lines. Details and the reasoning behind the design: docs/ARCHITECTURE.md.

Sources/KrakenNativeCore   model, storage, import, export, engine client, editing session
Sources/KrakenNative       SwiftUI app and AppKit page viewer
engine/kraken_worker       Python engine worker (Kraken calls, protocol, network guard)
scripts/                   runtime/app build, tests, lock file
Tests/                     Swift tests, fixtures, ALTO/PAGE schemas

Distribution notes

The build is signed ad hoc, which is sufficient for running it on the Mac it was built on (and on Macs where it is copied without a quarantine flag). To distribute it to other users, sign every Mach-O file in the bundle and the bundle itself with a Developer ID certificate using the hardened runtime and notarize it; this has not been done or tested here.

Credits and licenses

  • Kraken by Benjamin Kiessling et al., Apache-2.0; bundled with PyTorch (BSD-3-Clause) and its other dependencies under their respective licenses.
  • Models downloaded from the HTRMoPo/Zenodo repository are licensed by their authors; the license is shown for each model in the Models window.
  • Test fixtures: see Tests/KrakenNativeCoreTests/Fixtures/README.md.