Skip to content

About

Cassini for iPhone and iPad

Resources

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

Cassini for iOS

Cassini records audio and makes the transcript on your iPhone or iPad. It labels the speakers and can remember the voices of the people you name. Search, playback and export all work on the device, with no account and no server.

This is the iOS port of Cassini for Android (branch rebuild). It ports Android's behaviour and keeps Android's tests: each ported test is marked // ports: <AndroidTest>#<name>. Where the two apps disagree, Android's behaviour wins, unless the difference is an iOS-only extra or a platform constraint. Differences from Android lists what remains different and why. The app is native SwiftUI for iOS 18 or later. On iOS 26 and later it can fall back to Apple's speech model and uses continued background processing; below iOS 26 it does without both (iOS 18). On iOS 18 the full test leg has passed on the iOS 18.2 simulator, and Whistle has run on two iOS 18 devices (an iPhone 11 and an iPhone 15, in AWS Device Farm); the finite background path has been checked once by hand on the iOS 18.2 simulator, and A12 or A10 devices on iOS 18 are not yet verified.

Screenshots

These screenshots come from the iOS simulator (iPhone 17 and iPad Pro 13-inch (M5)). They were taken by scripts/screenshots.sh from seeded test notes with silent audio and fake transcription, so they are examples of the interface, not recognition results.

Notes Read and listen Transcribing Name a speaker Settings
Light Notes, light theme Read and listen, light theme Transcribing, light theme Name a speaker, light theme Settings, light theme
Dark Notes, dark theme Read and listen, dark theme Transcribing, dark theme Name a speaker, dark theme Settings, dark theme

The screens that only iOS has, or that look different on iOS:

Recording Search Recently Deleted Saved voices
Light Recording, light theme Search, light theme Recently Deleted, light theme Saved voices, light theme
Dark Recording, dark theme Search, dark theme Recently Deleted, dark theme Saved voices, dark theme

On iPad the Library stays beside the note, in landscape and in portrait:

iPad split view in landscape, light theme iPad split view in portrait, dark theme

iPad split view in landscape, dark theme iPad split view in portrait, light theme

Privacy

Speech recognition and speaker analysis run on the device. Cassini does not upload audio, transcripts or voiceprints. It has no accounts, no analytics and no advertising. The network is used only to download models, and only after you agree: Parakeet Ultra and every other model only from Cassini's model host, dist.gocassini.com, through its manifest (D4, D53.1), and, on iOS 26 or later on a device that uses Apple Speech, Apple's speech model for your language. Voiceprints stay in the app's private storage (PrivateVoices/) and are never written into a document or an export. By default, recordings, transcripts and voiceprints are included in system backups when enabled; in Settings → Moving and backup, the main backup switch controls both notes and saved voices (marking both to be left out of iCloud Backup via NSURLIsExcludedFromBackupKey when off), while the saved-voices switch additionally excludes voiceprints when backups are enabled (iOS treats backup exclusion as guidance—a direct Quick Start transfer may still copy excluded files). Downloaded models are always excluded from backups.

The build bundles pinned Whistle weights and a private Needle runtime (D75.2). Whistle transcribes immediately without a speech-model download. On supported devices, a calm, dismissible suggestion offers the more accurate Parakeet Ultra with its actual pinned download size. Once Parakeet is installed and hash-verified, new jobs use it automatically; Whistle remains selectable. Devices below Parakeet's capability/memory/disk requirements never see the suggestion. Existing queued and paused jobs keep their recognizer. See Whistle/README.md for the documented minos27 archive exception (linked for iOS 18.0), the iOS 26 and iOS 18.2 simulator parity, the A12/3GB measurements (made with the 26.0-linked framework; owed again for the 18.0-linked one), and what the iOS 18 evidence does not show (two AWS Device Farm runs on 2026-11-10, iPhone 11 on iOS 18.6.2 and iPhone 15 on iOS 18.0, ran Whistle in a Debug build; no A12 or A10 device on iOS 18 has run it). Internal TestFlight builds retain private memory diagnostics and must export with testFlightInternalTestingOnly=true.

Run

You need Xcode 26 or newer (the project is developed with Xcode 27), Swift 6.2 or newer, and XcodeGen. The Xcode project is generated and is not checked in. Generate it after checkout, and again after changing the targets or adding files:

brew install xcodegen
xcodegen generate

Open Cassini.xcodeproj, select the Cassini scheme, and run it on an iPhone or iPad simulator or device. For a device, choose your development team under Signing & Capabilities. No API keys or backend are needed. The pinned Swift packages are Zstandard (it unpacks the compressed speaker model) and swift-opus (libopus), and Package.resolved records their exact revisions.

What works

  • Record with pause and resume, a live waveform, an editable title and "Mark a moment" bookmarks. Recording continues with the screen locked or in another app. A Live Activity on the Lock Screen and in the Dynamic Island shows the time and has Pause, Resume and Stop. A call or a disconnected microphone pauses the recording until you resume it.
  • Safe capture. Audio is captured as 48 kHz PCM (CAF), which survives a crash, and compressed to M4A at Stop. If compression fails, the original stays playable. The recording stops and saves before storage runs out, with a warning about 15 minutes before. At launch, recordings that were interrupted are repaired and listed as recovered.
  • Import Opus/Ogg (.opus, .ogg), MP3, M4A, WAV and native FLAC from Files (several files at once) or with "Open in Cassini" from another app, using the pinned shared decided-format contract. Ogg inputs require Opus headers; FLAC requires a native stream and complete audio frames. A file already in the Library is not added twice. A Cassini document’s verified transcripts are imported with it. Imports show an Importing… card; failures keep a Needs attention card with retry/dismiss controls.
  • Transcribe on the device with the bundled Whistle model at once, or with Parakeet Ultra after a one-time download of about 531 MB (Ultra, its speech detector and the speaker models, from Cassini's model host) on devices with 4 GB of memory or more (those that report at least 3.25 GiB). A Parakeet run that cannot get the memory it needs or cannot load its model before it has saved any progress is run again with Whistle, for that note only; one that has saved progress or speaker names fails and keeps them. On iOS 26 or later, where neither Whistle nor a verified Parakeet can run, Cassini uses Apple's SpeechAnalyzer after a model download for the speech language you choose; iOS 18 has no Apple speech, so a device that can run neither engine cannot transcribe there (iOS 18). The queue is durable: jobs run one at a time and survive a relaunch. Progress is saved every 30 seconds of audio, so "Stop and keep progress", iOS taking the background time back, or a crash all resume from the last checkpoint. The progress card shows the stages, the percent, the time left, a battery projection and the draft so far. On iOS 26 or later transcription continues in the background with a system progress indicator; on iOS 18 it pauses when iOS ends the short background time (seen once on the iOS 18.2 simulator, not on a device). A notification says when a note is done or iOS paused it.
  • Speakers. As Android does, streaming Sortformer tells the speakers apart window by window while the words are decoded, and CAM++ makes a voiceprint for each speaker. The draft shows the speakers as they appear: you can name or merge them before the job is done, and a saved voice is suggested in the draft ("Is this Luca?"). Afterwards you can name a speaker across all their passages, play a sample of their voice, merge two speakers, or reassign a passage.
  • Saved voices. Cassini can remember a named voice, suggest it in later notes ("Is this Sam Rivera?"), and keep names over a Transcribe again. Automatic naming is optional and off by default. You can rename or forget a saved voice, forget everyone, or erase all voice data.
  • Read and listen. The playing word is highlighted, and tapping a word plays from there. You can skip 10 seconds back or forward, change the speed, and use the lock-screen and headphone controls. The playback position is kept across launches.
  • Search titles, transcripts and bookmarks, ignoring case and accents, with the matches highlighted. Search inside a note shows a "1 of 3" counter. The Library remembers All / Starred on this device. Search combines Starred, Speaker, date (including This year), and Recorded by me; closing Search resets its filters.
  • Edit and versions. You can edit a passage's text; its word timing is dropped, but its place in the audio is kept. Every transcription, merge and run of edits keeps the transcript from before it as a version you can go back to.
  • Export plain text, localized Markdown, SRT or WebVTT subtitles, structured JSON, a copy of the original audio, or a portable Cassini .opus document. The document keeps the source's verified transcripts, its private x data and its audio packets, adds the note's versions and speaker names, and records how each transcript was made. A stale or unverified source with nothing new on the device is shared as it is, without a renamed title; one transcribed again keeps only the new versions, beside the source's private data and meeting details.
  • Recently Deleted. Deleted notes stay for 30 days, with Undo right after the delete, and can be restored, deleted now, or emptied all at once. A permanent delete also removes that note's voice samples.
  • Settings for the app language (in the Settings app), the speech language (Apple Speech devices on iOS 26 or later only), automatic transcription, speaker identification and automatic naming. The on-device model rows show their status, with Download and Cancel. Your library's totals and the licences are there too.
  • Six languages: English, Italian, French, Spanish, and Brazilian and European Portuguese (D50).
    • Cassini follows the system's language. A regional variant reads as its language (fr-CA as French), and a bare pt as Brazilian Portuguese. pt-PT and the other Portuguese regions read as European Portuguese, and any other language as English.
    • Light and dark appearance, Dynamic Type up to the largest accessibility sizes, VoiceOver, and a split view on iPad and on large iPhones in landscape.

Current boundaries

This is a working iOS app, not yet an App Store release. Distribution lists what signing and TestFlight still need.

  • Recognition quality depends on the engine (Whistle, Parakeet Ultra or, on iOS 26 or later, Apple's), the device and the language. The simulator screenshots and tests use fake transcription, so they say nothing about accuracy.
  • The speaker pipeline's memory needs (Ultra and Sortformer loaded together) have been measured on the simulator only. Review automatically named speakers.
  • iOS 26 grants continued background processing only to a drain that starts while Cassini is on the screen. Otherwise, and always on iOS 18, transcription gets the short background time iOS allows. When iOS ends that time, the job pauses with its progress kept, and resumes when you continue.
  • Opus playback supports standard mono and stereo files (channel mapping 0). For other files the transcript stays readable and the original is kept, with an explanation in place of the player.
  • On a device that uses Apple Speech (iOS 26 or later), Apple manages its speech models. iOS does not report their size before the download, so the download screen and Settings use an estimate there.
  • The build carries what App Store Connect asks for: privacy manifests for the app and the Live Activity extension, ITSAppUsesNonExemptEncryption set to false, and the increased-memory-limit entitlement. The App Privacy answers are "Data Not Collected" with no tracking. The privacy policy is published at https://cassini.talk/privacy/ios/ from Privacy.txt (distribution).
  • A real device is still needed to validate recognition, model downloads, long background capture and transcription, Bluetooth routes, the Live Activity and thermal behaviour. Validation has the checklist.
  • iOS 18 support rests on the code, unit tests and runs with the iOS 18 facts on the iOS 26 and 27 simulators, and on the iOS 18.2 simulator (the iOS 18 test runtime; Apple no longer offers 18.6): there Whistle's imports and parity fixtures check out, and on 10 November 2026 the full iOS 18 leg passed (hosted 98/98, iPhone 102/102, iPad 12/12). That day two AWS Device Farm runs (iPhone 11 on iOS 18.6.2, iPhone 15 on iOS 18.0) ran hosted Whistle and platform tests on devices in a Debug build. No A12 or A10 device on iOS 18 and no Release or TestFlight build at 18.0 has run the app. iOS 18 lists what is shown and what is pending.

Differences from Android

docs/differences.md describes each difference in detail. In summary:

  • Live recording motion (iOS presentation extra). The microphone meter samples at 40 Hz; the same 56 peak buckets still cover seven seconds. A display-scheduled Canvas interpolates their heights and horizontal position at the available refresh rate (including ProMotion). Pause, Reduce Motion and inactive scenes remove the animation timeline. Capture duration, policy, stored audio and enrollment limits remain based on captured time. See the UI observation audit for observation boundaries and verification.

  • Library export on iOS 18. The format selector opens full-screen below iOS 26. A sheet can hang SwiftUI’s lazy Library layout after Star changes on iOS 18.2; full-screen presentation avoids resizing the Library behind it. The formats and share-after-confirmation flow are unchanged. iOS 26 and later keep the sheet.

  • Library and Search (D99). iOS uses a native All / Starred segmented control and a scrolling Search chip row. The filter contract matches Android: AND, local calendar dates, own recordings (including recovered captures) for Recorded by me, case-insensitive speaker names, and transient Search choices seeded from the remembered Library choice. Speaker searches match that speaker’s words and show their excerpt; with no text, they match meetings with that named speaker. Stars stay in local Library metadata.

  • Phase 2 meeting wording. Settings, Saved voices, Speakers and Recently Deleted use the shared meeting catalog in all six UI languages. iOS retains its existing Recently Deleted labels and device-specific speaker explanations; the shared phone entries retain their historical android.* IDs. See the immutable source pin.

  • Audio import (L-25 / D-1029). Picker/Open-with types and accepted extensions come from the shared decided-format contract. iOS uses AVFoundation for MP3/M4A/WAV/FLAC, including 24-bit and float WAV beyond Android's 16-bit PCM path. .opus and .ogg require actual Ogg Opus headers; the former Android-compatible MP3-under-.opus fallback is excluded by this shared contract. ZIP restoration also accepts legacy audio containers (including CAF and AAC) so audio-only notes exported unchanged can return to the Library; this iOS compatibility path does not expand Picker/Open-with admission. Native FLAC is checked with bounded metadata/CRC reads and a full decoded frame count because Apple’s reported duration alone does not detect truncation. A bounded process-local cache reuses successful validation only while the path, inode, size and modification time match; the import staging rename carries that validation to the final file. Header checks and cancellation still run on every open. Streams with an unknown sample count are decoded through EOF and must contain complete, nonempty frames. See the import differences.

  • Unknown meeting dates (D95). The Library names the group with the shared “Date unknown” heading in all six languages, including for VoiceOver. iOS omits the repeated unknown-date label from individual row metadata, the Note subtitle and the Document info Recorded row; the Note subtitle keeps the duration. Android repeats “Date unknown” on those surfaces. Neither app displays a document's sealing or import time as its recording date.

  • First-run hero and backup copy (D98). An empty Library shows the Wave 5 hero with its backup qualifier and privacy.onDevice.{iphone,ipad}.withBackup while backups are enabled (the default), or privacy.onDevice.{iphone,ipad}.backupExcluded when the library root is marked isExcludedFromBackup = true. Unlike Android's phone-only state, iOS never claims “The audio never leaves it.”, because NSURLIsExcludedFromBackupKey is backup guidance and Quick Start device migration may still copy local app storage.

  • Engines and thresholds. D78 starts with bundled Whistle and promotes Parakeet Ultra after its pinned files are verified. Parakeet needs a device that reports at least 3.25 GiB of physical RAM (every 4 GB device and no 3 GB one; Android asks for 4,000,000,000 bytes, which the 4 GB iPhone 12 and 13 do not report) and the normal runtime memory preflight, whose figures were measured on four 4 GB devices on 2026-11-11. A Parakeet run that fails that preflight or cannot load, and has no saved progress or draft speaker names, goes back to the front of the queue for Whistle (iOS only: Android's run fails with MEMORY, as a run with saved progress does here); its download suggestion also checks the pinned install's actual disk requirement. Whistle's production pipeline and default-limit A12/3GB memory gate passed. On iOS 26 or later Apple Speech remains a separately checked fallback candidate when neither bundled nor verified downloaded speech is available; unsupported devices/locales are refused before queueing or download consent. On iOS 18 there is no Apple Speech: where Whistle cannot run, a Transcribe leads to the Parakeet download consent as on Android, or is refused when the device cannot hold Parakeet either. Recording, playback and audio export remain available. Apple's distributed Mach-O runtime may be encrypted: iOS pins its clear runtime at build/export and relies on the iOS signed-code loader for the installed private framework, with full weights/VAD hashes still checked on-device. This distribution constraint differs from Android's ELF packaging; see Whistle/README.md. Speakers use Android's streaming Sortformer and CAM++ with Android's thresholds (0.72 automatic, 0.50 suggest, 0.08 margin, 4 s of speech), so the voiceprints are Android's; voices saved by earlier iOS builds are named again. iOS keeps automatic naming off by default. On Apple Speech devices (iOS 26 or later) the speech language is chosen in Settings, because Apple's models are per language. The pinned model catalog, plan, redirect policy, fetcher and installer are ported with Android's tests, behind an HTTPTransport port over a data-task URLSession that never follows a redirect itself, and one shared installer downloads Ultra, its speech detector and the speaker models with consent. Sizes follow the shared rule of the format vectors ("444 MB"), where Android still rounds to tens.

  • Storage model. A note is a note.json beside its audio. The portable Cassini document is sealed only at export, with the run's provenance under Android's keys. Each variant carries the language of the run that made its words (D53.2): und for Parakeet, as Android writes, the locale that ran for Apple Speech, never the Settings language. Words that no speaker step told apart are one speaker with an id new to the run (<run prefix>1, Android's diar_<run>_1), labelled "Speaker 1" in the app's language (D59). A passage the user set to no speaker is sealed as the speaker unassigned, labelled "Unknown speaker" in the app's language (D47); Android's words always have a speaker. The cross-app vectors are checked through the reader and the import. Android keeps the transcript in a sealed document and a Room catalogue. The queue is jobs.json, and checkpoints use iOS's own format. Search uses an in-memory index instead of FTS4. As on Android, search joins spoken turns with spaces; row excerpts flatten embedded line breaks while preserving highlights. The lazy list separates grouped and flat projections so iOS 18 does not retain ordinary row bodies in search results. Rows key their stateless SwiftUI drawing by renderKey, which includes the full row presentation except live recording duration ticks. Ticks update text in place without interrupting taps or context menus; Stop and other presentation changes replace retained Recording badges. Note UUIDs still identify navigation and actions. Android does not need this SwiftUI identity workaround. Library renames of a live note also update the iOS recorder’s title before it seals the note, keeping the mirror and capture in sync. On iPad, a newly recorded or imported note replaces the detail column so its Library selection follows the note. Date filters apply only after typing a query. Local transcription jobs expose a time-left interval, so Library pills and VoiceOver share the catalog’s no-ETA fallback rather than inventing a scalar estimate. Saved voices keep one sample per note instead of a running mean.

  • Transcript rendering (D84). The pure CassiniNotebook.TurnModel ports the gocassini viewer pipeline at 1111155cb0017b47c072a8662c54f28ad7c44223: readable grouping, display-only timing repair, continuity-based turn reconstruction, inline interjections, competing-speaker labels and continuation headers. The sealed note, live draft, reader, Library previews, search excerpts and text/Markdown export use that projection. Canonical words and timestamps stay unchanged; playback and editing keep the original word indices even when reading order differs. The six shared vectors in CassiniNotebookTests/Resources/interjections are copied unchanged from coordination and checked with swift test --filter CassiniNotebookTests (no simulator or e2e). This viewer contract supersedes the older per-app paragraph rules, including iOS's former 200/120-word paragraph limits. SRT/VTT retain their subtitle cue rules; portable .opus/JSON exports retain canonical word order.

  • Recording. iOS captures PCM CAF and compresses it to M4A, so there is no 1 GiB AAC limit, and the storage floor includes the room for that compression. After compression, the stored duration comes from the same AVAudioPlayer endpoint as playback (read off the UI thread), so AAC sample-rate conversion cannot leave the Library and player a second apart. The filename and duration are saved together; failed inspection or saving keeps the CAF. The audio session does not mix with other apps, so a call pauses the recording. Losing the input pauses it too. A Live Activity replaces Android's ongoing notification, and recovery repairs CAF files. The Recording screen has Android's controls (All meetings, Stop in the centre, Pause or Resume) on the always-dark night ground; iOS adds "Mark a moment" above them.

  • Transcription. A Parakeet run tells speakers apart as it decodes, as on Android. On the Apple Speech fallback, and for Identify speakers, the same streaming pipeline runs over the whole file after the words, so that draft has one voice. Android's foreground service becomes a BGContinuedProcessingTask on iOS 26, and the finite beginBackgroundTask time on iOS 18, which has no continued processing. When iOS takes the time back, the queue is held and "Paused by iOS" is shown. The stepper reads Words, then Speakers & matching.

  • iOS 18 (a platform constraint; iOS 18). No Apple Speech and no continued processing: a transcription or a standalone model download that is still running about 30 s after Cassini leaves the screen stops (the job pauses with its checkpoint, the download keeps its bytes), where Android keeps both running. The paused transcription resumes from its checkpoint when Cassini comes back to the screen (a proposal; Android's system pause waits for Resume); the download needs Try again. Whistle also needs Armv8.1 atomics and Armv8.3 RCpc, so the A10 iPad (7th generation) gets no Whistle; with 3 GB it gets no engine at all. The Whistle binary is built for iOS 27 and linked at 18.0 under the D75.2 exception as extended, which rests on the iOS 18.2 simulator evidence in Whistle/README.md and two AWS Device Farm runs on 2026-11-10 (iPhone 11 on iOS 18.6.2, iPhone 15 on iOS 18.0); no A12 or A10 device on iOS 18 has run it. The transcription's background pause was checked by hand on the iOS 18.2 simulator (see iOS 18); the download's stop was not.

  • iOS extras. Stars, bookmarks, playback speed, lock-screen controls, passage editing, JSON export, the Speakers list, the "Recently Deleted" name, "Forget all voice data", and Settings sections for transcription, speakers and your library.

  • Platform. The app language is set in the Settings app. iOS has no system Back, so the back button carries the title of the screen below. The iPad has a split view. Rename is a sheet. Notifications are silent results with hidden-preview text. The W1 preview reads the pinned Cassini palette (cool neutral grounds, navy light accent, and a blue/magenta/cyan/orange/violet/slate speaker cycle) with system sans fonts and Dynamic Type; contrast is checked by tests. Content width is capped at Android's 560 pt. The App Store build declares its privacy manifests, export compliance and memory entitlement.

Verify

scripts/test.sh fast     # the string catalog check (scripts/check-strings.sh), then the Swift package tests
scripts/test.sh app      # build for testing, then the hosted unit tests (CassiniTests)
scripts/test.sh ui       # build for testing, then the UI tests, sharded across simulator clones
scripts/test.sh all      # all of the above (the package tests run beside the build); prints the time of each step
scripts/test.sh changed  # only what the changes since origin/main touch (or since a base: changed <ref>)
scripts/test.sh build    # only build for testing
scripts/test.sh simulator # simulator tiers only (CI runs fast separately); never posts drmeyers/test-all
scripts/test.sh ios18    # build for testing, then only the iOS 18 leg (below)
scripts/test.sh clean    # delete this worktree's simulator clones

The script builds once into DerivedData.noindex and runs the tests from that build. It clones the simulators (ts-<worktree>-iphone-N, plus an iPad for the testIPad* tests), keeps the iPhone clones booted for the next run, and splits the UI tests across up to three clones, fewer when memory is short. The shards are balanced by each test's measured time, averaged with the time stored before. Arguments after the tier go to xcodebuild, so scripts/test.sh ui -only-testing:CassiniUITests/NoteScreenTests runs one class, still sharded. The header of scripts/test.sh lists its environment variables. scripts/test-remote.sh [tier] runs the same tier on the Mac named by CASSINI_MAC, or here when that is unset.

UI helper deadlines only bound hangs: menu taps require settled snapshots, Library navigation waits for loaded data and UIKit presentation in an active scene before one tap, and text replacement waits for a cleared field and one edit. A late destination or edit never triggers another input solely because a short deadline expired.

CASSINI_RUNTIME=18 scripts/test.sh app (or ui) runs on the newest installed iOS 18 simulator runtime instead of the newest runtime; a version such as 18.2 or a runtime identifier also works. A run fails when no runtime matches, or when the runtime cannot run the device types: below iOS 26 they default to iPhone 16 and iPad Pro 13-inch (M4). That leg keeps its own clones (ts-<worktree>-iphone18-N), logs (DerivedData/test-logs-ios18) and UI timing table, so it neither reuses nor disturbs the default leg, and it posts no commit status. clean deletes its clones too.

The iOS 18 leg

CASSINI_IOS18=smoke adds an iOS 18 leg to scripts/test.sh all. It starts once the default runtime's tiers pass. The worktree's clones are shut down first, and the same build then runs on the iOS 18 runtime: the hosted tests, which load Whistle and ONNX Runtime for real, then the UI tests in scripts/ios18-smoke-tests.txt on one iPhone 16. The list plans about five and a half minutes (332 s) by scripts/ui-test-durations.tsv. CASSINI_IOS18=full runs every UI test and the testIPad* tests on an iPad Pro 13-inch (M4) instead. Once the leg is on by default, a branch that changes views (Cassini/Features or Cassini/Design since it left origin/main) gets the full leg, and every other branch the smoke run; CASSINI_IOS18=smoke or full overrides that choice. scripts/test.sh ios18 builds and runs only the leg. The leg is CASSINI_RUNTIME=18 scripts/test.sh prebuilt, which tests the last build without building, so its clones, logs and timing table are those described above. The commit status names what the leg ran and how, for example passed in 24 min: iPhone 72/72, iPad 8/8; iOS 18.2 smoke: hosted 76/76 (6 skipped), iPhone 16/16.

The iOS 18 test runtime is iOS 18.2 (22C150): Apple no longer offers 18.6 for download, and the app's floor is 18.0. The leg is on by default (ios18_default=smoke in scripts/test.sh), so every Mac that runs all needs the iOS 18 runtime (install steps below). A Mac without it fails the run and its status before anything is built; the leg is never skipped. With ios18_default=off an all run has no leg and its status says nothing about iOS 18. CASSINI_IOS18=0 turns the leg off and posts no status, the same way CASSINI_UI_IPAD=0 does. CASSINI_IOS18_RUNTIME=26 runs the whole leg on the installed iOS 26.0 runtime, to try it without iOS 18. There every UI test is given the iOS 18 facts (below), so the iOS 18 side of each test runs, and the run posts no status. In tests, DeviceUnderTest (in CassiniUITests) reads which platform the device has, so the same test checks the iOS 18 screens on 18 and the iOS 26 screens on 26 and 27. With TEST_RUNNER_CASSINI_IOS18_FACTS=1, every launch gets --ios18-platform and those expectations follow, which runs the iOS 18 side on the current simulators.

Where a test needs a recognizer that runs and the system has no Apple speech, it launches the bundled Whistle device of a 3 GB phone (DeviceUnderTest.workingSpeech, --d78); where it needs a speech model to download, the Parakeet device (DeviceUnderTest.downloadedSpeech, --parakeet). With Apple speech both add nothing, so the iOS 26 and 27 runs launch with the same arguments as before. The statuses seed's paused job carries the recognizer of the device it is seeded on, so Resume queues it on the Whistle device too. Every UI test now follows the platform: with the iOS 18 facts, the smoke list passes on iOS 27, and the full leg (CASSINI_IOS18=full) passes on the iOS 26.0 runtime. On the real iOS 18.2 runtime (10 November 2026, at bc7bb8e) the full leg passed: hosted 98/98 (7 skipped), iPhone 102/102, iPad 12/12. Earlier runs there had found the frame-budget regression (its cause, the turn model's per-word regex rejoin, was fixed on main by #81, which measures the keystroke in main-thread CPU: 7.64 ms on 18.2 against 16 ms), a crash of every pinned-model download (on iOS 18 Task(executorPreference: nil) crashes; PinnedModelInstaller now starts a plain Task when it has no executor), and seven UI failures, fixed on this branch: Name a speaker could save a name one keystroke old (on every OS), the iPadOS 18 split view started without its sidebar, the running draft did not follow its end, and the audit reported clipped text with no element on Settings and Saved voices. The leg stays off by default for now. ScreenshotTests skip unless scripts/screenshots.sh runs them.

To install the runtime, download the iOS 18.2 simulator runtime DMG (22C150) with the owner's Apple ID and keep it on /Volumes/DrMeyers2/sim-runtimes. Do not simctl runtime add that DMG itself: simctl first stages a second 9 GB copy of it on the internal disk and then copies the inner image as well, and on this Mac that second copy was refused twice ("the disk is almost full", with 27 and 30 GB free). Mount the DMG read-only from the external volume and add the image inside it instead, which copies once:

hdiutil attach -nobrowse -readonly /Volumes/DrMeyers2/sim-runtimes/iOS_18.2_Simulator_Runtime.dmg
ls /Volumes/<mounted volume>/Restore/                  # one inner .dmg (092-09271-199.dmg for 22C150)
/usr/bin/lockf -k -t 3600 ~/.cassini-heavy.lock \
    xcrun simctl runtime add "/Volumes/<mounted volume>/Restore/<inner>.dmg"
hdiutil detach "/Volumes/<mounted volume>"
xcrun simctl list runtimes | grep 'iOS 18'           # iOS 18.2 (22C150) is listed
df -h /System/Volumes/Data                           # check what stays free on the internal disk

simctl copies the inner image, about 8.7 GB, into the system's store on the internal disk, and the first boot of the runtime builds its dyld cache, about 3.5 GB more under /Library/Developer/CoreSimulator/Caches. The DMG stays external as the backup. The leg then runs: ios18_default=smoke in scripts/test.sh is the one line that turns it on.

On GitHub, .github/workflows/ci.yml runs harness regressions, scripts/test.sh fast and scripts/test.sh build with Xcode 27.0 on the configured trusted runner pool (hosted fallback for forks/unset configuration). The observational simulator workflow runs scripts/test.sh simulator on rented self-hosted iOS runners for same-repository PRs, nightly schedules and manual main dispatches. Every run keeps the full default runtime coverage. Ordinary PRs run the iOS 18 smoke list plus all AccessibilityAuditTests and WideScreenTests, including their iPad tests, serially. Nightly, manual and full-ci PR runs retain the full iOS 18 leg. CI still runs on every main push; the simulator workflow does not repeat after each merge. Its job guard skips fork PRs; a server-side runner policy must also exclude PR-edited workflows, as described in that design. During the comparison period, the drmeyers/test-all status from CASSINI_POST_STATUS=1 scripts/test.sh all remains the coordinator's merge gate.

scripts/screenshots.sh takes the screenshots above. It runs CassiniUITests/ScreenshotTests on its own iPhone 17 and iPad Pro 13-inch (M5) clones, in light and dark, with the status bar pinned to 9:41. It then exports the named attachments from the result bundle and saves them, scaled down, under docs/screenshots/. --locale it (or fr, es, pt-BR, pt-PT) takes the same set in that language under docs/screenshots/<locale>/, which is not committed. --device and --appearance take a subset. For a headless English gallery run, use scripts/screenshots.sh --locale en --appearance light --output /path/to/gallery/ios. The folder receives stable light/01-library.png through light/09-saved-voices.png names and ipad/light/01-split-landscape.png, ipad/light/02-split-portrait.png. Custom output runs retain other files in the chosen folder. Capture runs through simctl and XCTest; no Simulator window is needed. For local before/after PR renders, fetch main and run (outside any enclosing heavy lock):

python3.12 -m venv /path/to/pr-shots-venv
/path/to/pr-shots-venv/bin/pip install --isolated Pillow==11.3.0
PATH="/path/to/pr-shots-venv/bin:$PATH" scripts/pr-shots.sh --base origin/main --pr 125 --out /path/to/new/pr-render

The base is the merge base of that ref and the head worktree (--head PATH defaults to this checkout). Use a new output folder outside the worktree; commit changes and remove untracked files first. It renders each source's English screenshot set (currently 26 images, including Note and Library export menus) in light and dark, using each source's capture tests, renderer and one private simulator pair. Legacy bases without manifest tooling receive only the head renderer/helper, preserving their capture tests. New reading shots start paused, so no pressed skip-button tint leaks into a capture. Each render takes ~/.cassini-heavy.lock itself (or CASSINI_HEAVY_LOCK); the wrapper removes only its temporary worktree and uniquely named clones. Output has before/, after/, per-side shots.json, capture/test logs (retained even on failure) and render.json with source SHAs and elapsed time. SIGHUP, SIGTERM and SIGINT stop the renderer; further signals are ignored until scoped cleanup finishes. --output disables lossy pngquant by default and records actual runtime/device, locale, seed, test and pixel size; the 1200-pixel downscale remains. Existing normal README renders keep their previous compression behavior.

The canonical cassini-ux pr-shots.py is vendored from commit 5e0c34e0f1bb390298dabdf4eedc494e933fd329. It adds pr-shots/ using only its diff command; use your PR number with --pr N. --render-only skips that step and needs only Python's standard library. The wrapper uses python3 from PATH. Before diffing it checks each screen has both appearances and probes the canvas against the scheme label (recording intentionally uses a dark canvas in both). CI runs those regressions and the canonical self-test. This wrapper never accesses GitHub or publishes; the coordinator alone uploads images and replaces PR blocks.

scripts/render-icon.swift draws the app icon (swift scripts/render-icon.swift from the repository root).

UI absence assertions wait for a completed screen or app decision, then inspect the same accessibility state immediately. Debug UI-test launches expose suggestion-completion, Settings-loaded and completed-scroll markers for this purpose.

UI-test launches (--ui-testing, Debug builds only) use a library and preferences of their own, a clock fixed at Thursday 8 October 2026 09:41 UTC, en_US formatting, and fake transcription and speaker analysis. Named seeds fill the library: --seed library|search|reading|speakers|voices|trash|processing|recording|statuses|long. --parakeet makes the fake transcriber stand for Parakeet Ultra, so the model download screen and Settings show its sizes. --ios18-platform builds the app over the iOS 18 platform facts (no Apple speech, no continued processing) on the current runtime, so those flows are tested on the usual simulators. A normal launch starts empty, and Release builds link no fakes.

UI-test word-tap checks read the last clamped seek target applied by the real audio adapter. Playback keeps advancing, while the test-visible target stays fixed until another seek; the assertion has no playback-position time window.

The iOS UI-test harness also supports --draft-growing: its fake waits for cassini://ui-test/append-draft?count=K before emitting K more synthetic sentences. Each permit advances the injected transcription clock past the result-publication interval; tests wait for those actual new words. Frozen fake reports advance virtual time too, so pace estimates do not depend on host scheduling. These Debug-only controls are iOS harness extras; ordinary launches and production timing are unchanged.

Native speech runtime

Every iOS build links sherpa-onnx from the same fork and commit as Android, codemyriad/sherpa-onnx 0c2ee3f (D16 §1: the NeMo frontend, Ultra's TDT selection by its plain URL, Nemotron-3 diarization), against ONNX Runtime 1.27.1, with the C API and without TTS. Like Android it has speaker diarization on and applies Android's scripts/streaming-diarization.patch, so the streaming Sortformer diarizer and the CAM++ speaker-embedding extractor are in the build; scripts/streaming-diarization-c-api.patch (iOS only) puts the streaming calls into the C API, because Android's patch adds them only to JNI. The build is published as the release v1.13.7-cassini-mobile.1 (sherpa-onnx-1.13.7-0c2ee3f-ios.2-no-tts.xcframework.zip, and a mirror of csukuangfj's ONNX Runtime 1.27.1 static xcframework), which Package.swift links as two binary targets by URL and checksum. Android's pure decode rules (windows, quiet cuts, seam merge, word gate, speech feed, incremental 28 s windows) are ported with their tests to CassiniNotebook/Transcription, and ParakeetTranscriber (CassiniInference) drives them over CassiniSherpa's ParakeetDecoder and SileroDetector. The app uses Ultra when the device passes SpeechCapability, installed or not: a job, or the model download screen's Download, fetches Ultra and its speech detector with consent through the installer the speaker models share (PinnedModels). Apple's recognizer stays as the fallback, on iOS 26 or later, where neither Whistle nor a verified Ultra can run (AppleSpeechWindows); iOS 18 has no Apple recognizer. Speakers run on the same runtime: CassiniSherpa wraps Android's streaming Sortformer diarizer (SortformerStream, with save and restore of its state) and CAM++ extractor (VoiceprintExtractor); the streaming rules (TurnHistory, SpeakerBudget, Diarization, the voice-clip cache, DraftNames and draft stats) are in CassiniNotebook, and the job (WindowSpeakers, LiveMatching, DraftNamesStore) in CassiniEngine. Without the native runtime there is no speaker step. The speech detector hears the recording through WebRTC's 100 Hz high-pass (SpeechInputFilter, decision D26.1), so a microphone's DC offset does not change what it finds; the recognizer and the speakers get the samples raw (differences).

scripts/build-sherpa-xcframework.sh   # pinned sources -> .tools/sherpa/SherpaOnnxC.xcframework and a reproducible zip
scripts/verify-native-runtime.sh      # the lock (scripts/native-dependencies.json) against Package.swift and the build
scripts/fetch-ci-models.py --dest .tools/models   # the pinned models from dist.gocassini.com, verified, in the app's
                                                  # layout (models/<id>/<source_sha256>/ with NOTICE.txt)
scripts/fetch-ci-models.py --check-live           # the live manifest still lists every pin (two small GETs)
scripts/sherpa-bench.sh               # simulator: Ultra decode vs Android's golden, memory and speed, and a real job
                                      # vs iOS's golden (CASSINI_PARAKEET_RECORD=1 records it)
scripts/speaker-smoke.sh              # simulator smoke: Sortformer streaming + save/restore and CAM++ on two FLEURS voices

Models from the model host (D4, D53.1). Every model Cassini installs itself comes from dist.gocassini.com and from nowhere else: ModelCatalog compiles in the four pins (Parakeet Ultra INT8, Silero VAD, Nemotron 3 Diarization INT8 with ONNX interface v2, CAM++), each as (id, source_sha256) with both SHA-256 values of every file. Before a download, NetworkModelFetcher reads the live manifest.json and requires the pinned row and every artifact entry (key, URL, sizes, both hashes, encoding) to agree with the pins (DistManifest); a missing or contradicted pin fails with its own banner, "Model not available" (DOWNLOAD_PIN_UNAVAILABLE, no Retry; the Settings row keeps the generic failed status, and the next install reads the manifest again). Each file is its own seekable Zstandard object, resumed with Range and If-Range (the entity tag is the quoted compressed SHA-256; a 200 restarts from zero whatever its tag, and a 206 without that tag or a 416 deletes the part) and checked before and after decompression; the files and the host's NOTICE.txt are collected in CassiniModels/models/<id>/.<source_sha256>.staging/ and renamed into CassiniModels/models/<id>/<source_sha256>/. On iOS, the model root, staging directories and resumed staging files use completeUntilFirstUserAuthentication so verification can finish after auto-lock. A response with a validated length finishes at its pinned whole-file or range boundary without waiting for connection teardown; size and SHA-256 checks still precede publication. As an iOS URLSession recovery measure, a timeout or lost connection while reading the manifest or NOTICE gets one retry with a separate session. It checks both metadata objects again and uses that session for the remaining model requests. Artifact transfers keep their existing resume rules; cancellation, pin, HTTP and local storage failures do not trigger this metadata retry. Separately, an artifact request chain may retry once through an independent session if a GET times out or loses its connection before response headers arrive. That retry preserves the current redirect target, hop budget and Range/If-Range headers. Errors after headers do not trigger this retry; existing resume and partial-deletion rules still apply. Neither scope retries cancellation, HTTP/status, pin/digest or local storage failures, and neither adds a delay or retries indefinitely. About › Model notices shows that NOTICE.txt from an installed revision. Every request to the host, each redirect hop included, sends User-Agent: CassiniTalk/<CFBundleShortVersionString> (iOS <version>; build <CFBundleVersion>) (D54, ModelUserAgent), built once by the app and set by URLSessionTransport. Before the first load in each session every installed file is hashed again (ModelVerifier, D16 §4); a file that differs retires the revision, the job fails with "Model verification failed", and the next job downloads it again. Provenance names Ultra parakeet-ultra-0.6b-int8-v2@<source_sha256> (D16 §5, D86). The default is the improved #4179 INT8 encoder (50c15b94…): 465,446,146 compressed bytes and 671,608,018 installed bytes. The previous ID remains readable in provenance and stays on disk until v2 is installed and verified; only then is its install removed. The model cache key is derived from all pins and artifact hashes in scripts/ci-models.json, so v2 gets a distinct cache. These pins need the codemyriad sherpa-onnx fork at 0c2ee3f (D16 §1): an older runtime cannot load the v2 diarizer or the dist Ultra export.

Package.swift links the release's two xcframeworks into CassiniSherpa, the only module that imports SherpaOnnxC; CASSINI_SHERPA_LOCAL=1 links the ones scripts/build-sherpa-xcframework.sh writes to the gitignored .tools/sherpa instead (the same bytes; scripts/verify-native-runtime.sh checks both against the lock). The binaries are iOS-only (.when(platforms: [.iOS])), so swift test on macOS links no native code, but SwiftPM still downloads the two release zips once when it resolves the package (about 41 MB, then cached in .build and SwiftPM's cache), and so does Xcode for scripts/test.sh and scripts/test-remote.sh: the first run needs the network. Unlike Android's two ABIs, iOS builds only the device (ios-arm64) and the Apple-silicon simulator (ios-arm64-simulator) slices, so every build is arm64-only. CassiniTests/SherpaBenchTests, CassiniTests/ParakeetJobTests, CassiniTests/SpeakerJobTests, CassiniTests/SpeakerSmokeTests and CassiniTests/DCVectorTests skip themselves unless the environment names their models, as scripts/sherpa-bench.sh and scripts/speaker-smoke.sh do. ParakeetJobTests compares a real job's words with CassiniTests/Goldens/fleurs-it-short.ios.json, recorded on the arm64 simulator with the dist export: iOS keeps goldens of its own because ONNX Runtime's int8 kernels differ from those of Android's x86_64 emulator. scripts/fetch-speaker-fixture.py mixes the speaker smoke test's two-speaker clip from public FLEURS audio (Android has no public meeting recording) into the gitignored .tools/fixtures.

A new runtime is a new release asset: rebuild with scripts/build-sherpa-xcframework.sh, publish the zip, then put its URL, version and SwiftPM checksum in scripts/native-dependencies.json and the same URL and checksum in Package.swift, and run scripts/verify-native-runtime.sh.

Validation lists what each tier covers, the test counts and the device checklist. Architecture describes the modules, state ownership, startup, storage and the transcription lifecycle.

License

Copyright © 2026 Codemyriad and contributors.

Maintainer: Codemyriad cassini@codemyriad.io.

Cassini for iOS is free software under the GPLv3. Cassini/Resources/Licenses/ThirdPartyNotices.txt lists the licences of the dependencies and the models, including every library of the native runtime's lock (scripts/native-dependencies.json, checked by LicenseAssetsTests); ONNXRuntime-ThirdPartyNotices.txt next to it is ONNX Runtime 1.27.1's own notices for the libraries inside it. Both show under Settings → Source code and notices. The portable format is specified in cassini-format.

ZIP transfers (D96)

The Library import picker accepts multiple audio/Cassini files and ZIP archives. Edit selects notes for Export Selected as ZIP; Export All as ZIP includes the whole live Library. Transfers show progress, support cancellation and retain already imported notes. The archive rules and iOS differences cover limits, original-audio fallback, safe paths and cleanup. iOS uses its native picker/share sheet and AVFoundation audio support; Android-only container support is not added.

Shared status badges

The pinned badge contract, full catalog and vectors drive the pure selector and compiled six-language lookup. RowBadge adapts iOS lifecycle states while preserving phone-only statuses and actions. Rendered pills retain Dynamic Type and translated text. State, catalog, generation and corruption tests verify the full outputs; UI geometry tests cover accessibility text. Runtime rendering never parses JSON.

Phase 1 alignment QA

The D-989 QA report records the six audited phone surfaces, existing implementation PRs and iOS platform differences. Meeting header names use the same assigned speaker colours as transcript labels; unnamed speakers remain stone in both appearances. Library Search and Find match spoken words rather than labels inserted by the viewer. Search previews join paragraphs with spaces so blank lines cannot hide the matching word. Both search surfaces preserve the viewer’s spacing around standalone punctuation, including punctuation inside inline replies.

Wave 6 voices and phone backups (D-979, D98): iOS includes meetings and saved voices in OS backups by default. Settings → Backup controls Library directory exclusion and the independent PrivateVoices exclusion; Saved voices includes a one-question opt-in for automatic naming, transcript enrollment (unchanged), guided four-second test-phrase enrollment, sample playback, rename and forget. Guided audio stays under PrivateVoices/Enrollment, never in the Library or ZIP export, and is removed when its voice is forgotten. Unlike Android's “phone only” mode, iOS only marks directories to be left out of iCloud Backup: Quick Start may still copy them. The floating Library notice appears only after a saved meeting exists; the Backup page explains this guidance. Turning exclusion on does not delete existing cloud backups. Directory resource flags cover all descendants, including new directories, atomic replacements, recordings and imports; startup reapplies both committed preferences, including the old always-excluded voice store. Manual ZIP export contains portable meetings (or their original audio) and never private voiceprints or guided samples, regardless of the saved-voice backup switch. Speech model folders retain their separate backup exclusions.

Single-meeting export follows D99 / PARITY §2: Cassini file and Markdown are primary choices, with Plain text, SRT and WebVTT under More formats. Meetings without a finished transcript hide text choices; raw imports then share the original audio. Finished transcripts, edits and saved versions remain exportable during a queued, running or failed re-transcription. A completed no-speech result also offers text formats. Job checkpoints never enter the stored transcript or its exports. Confirming opens the iOS share sheet. Multi-meeting export remains ZIP. JSON is retained as an internal writer, but is absent from the sheet. The Phase 2 TXT/SRT/VTT derivatives use speaker-turn blocks, seven-second subtitle segments and monotonic non-overlapping cues; the older Android writer fixtures remain as historical coverage. The shared Markdown golden matches byte for byte. At cassini-ux b26190b, vectors/export/ has no TXT/SRT/VTT vectors, so those formats have local regression coverage pending shared goldens. This is the current difference from Android's older subtitle rules (six-second cues and cross-speaker overlap).

Imported provenance (L-10): Library and Search show the shared outline Imported badge before speaker counts on finished imported meetings; progress and problem states take its place. Headers identify imported meetings and files that arrived with a transcript from another device. This matches the Phase 2 phone contract; recovered local captures remain own recordings. Existing stored import records are read without migration, and import-flow copy is unchanged.

D103 phone Settings uses the shared topic map. iOS keeps its speech-language picker on Apple Speech devices, its “Transcribe right away” and “Name strong matches automatically” switches, and opens app language in iOS Settings. The Backup page retains iOS backup guidance; it cannot report whether iCloud Backup has run. Turning off “Recognise saved voices” clears unconfirmed matches from active and paused drafts, while keeping confirmed names and Remember choices. Re-analysis still carries over names given within the same meeting.

D103 Backup uses the answer-first phone page, independent meeting and saved-voice switches, inclusion rows and separate explanations of iCloud, computer backups and ZIP copies. Both switches still default on. Settings remain eligible independently of the Library directory, saved voices follow both switches, and downloaded models are always excluded. “Included” is conditional on iCloud Backup being enabled; Cassini cannot inspect its state or completion. The once-only notice floats above Record after a saved recording or import, never over an empty first launch or a first live/interrupted recording. The notice temporarily yields to the Undo snackbar. Close and Keep backup on preserve choices; exclusion dismisses only after its storage transaction succeeds. Backup’s ZIP action uses the Library exporter and excludes live and interrupted captures.

Phase 2 onboarding and voices (D103)

The one-time voices question opens over a visible meeting with more than one actual speaker, including speakers shown only in reply chips and live drafts. It waits while saved voices are read-only and for restored sheets and other overlays. Yes and Not now set the independent Remember people I name default; dismissal preserves it. A Settings change also answers the question. The default starts on and does not change automatic naming or recognition. Existing voice links and explicit draft Remember choices take precedence. Legacy answered flags remain answered; legacy auto-name values do not infer a Remember preference. The answer/default share one UserDefaults record, written through its asynchronous persistence mechanism without a main-actor disk flush.

The shared copy is pinned to cassini-ux dd06a62dc881034fed417b000f47004e577a3fb0 (all six languages). The iOS Saved voices page keeps guided Add voice enrollment as an existing platform extra; row playback, sample counts and Ready labels are removed. Download consent is a full-screen modal with a source-only detail page. Its displayed speaker models are separate rows while installation and consent retain their existing bundle grouping. Apple does not publish speech-asset download sizes, so that path retains the approved size-free body and estimated installation space. Standalone downloads retain Download, and speakers-only jobs retain Download and identify speakers: neither starts a transcription. These are platform constraints/existing iOS extras to the phone board.

Phase 2 first run (D105)

The empty Library places its grey conversation wave and hero above Import audio and Record, on the search bar’s 16-point edge. The 28-point hero and the two privacy lines wrap and scroll at larger text sizes. Like Android, first run has the same copy with backups on or off. iOS names this iPhone or iPad and says backups follow your iCloud settings; Settings still uses the full D98 backup or exclusion wording. The process is called “transcribe”, while “Every word written down.” remains the hero. Shared strings are pinned to cassini-ux #55, 277c65423909ec6f696836eeefede6d4ac5e4c84. Pending L-68 permission prompts are not adopted.

About

Cassini for iPhone and iPad

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Used by

Contributors

Languages