Private local recognition
Microphone capture, conversion, recognition, rendering, and transcript storage remain on the device after the system-managed language model is available.
SpeechTranscriberOn-device speech that behaves like a product.
A resilient, privacy-first transcription experience with bounded memory, failure-aware lifecycle handling, incremental local storage, and no application cloud service in the recognition path.
Recognition path
Local after the language model is installed
Bounded pipeline
8 capture buffers + 32 analyzer inputs
Local persistence
Final text is appended incrementally to disk
Current evidence
Architecture reviewed; device testing remains
What makes it different
More than speech-to-text. A hardened local capture system.
Four product promises map directly to implementation boundaries and concrete failure classes.
Reliable audio processing
The microphone callback stays minimal. Conversion moves to a dedicated queue, while saturation becomes visible instead of silently losing data.
AudioInputPipelineBounded resource usage
Capture and analyzer queues are bounded. Final text writes incrementally to disk, while the view retains a controlled working set.
TranscriptArchiveFailure-aware lifecycle
Interruptions, route changes, model installation, cancellation, backgrounding, resets, and final delivery converge on explicit state and cleanup paths.
TranscriptionSessionArchitecture
Four focused layers. One controlled data path.
Local Speech treats microphone audio like a production stream: capture quickly, buffer deliberately, convert away from the real-time callback, and fail visibly when integrity cannot be guaranteed.
Microphone capture
AVAudioEngine tap with minimal work
Bounded audio queue
Eight in-flight capture buffers
Format conversion
Dedicated user-initiated processing queue
Local recognition
SpeechAnalyzer + progressive SpeechTranscriber
Output to the interface
Volatile text appears progressively. Final text becomes stable transcript segments and is eligible for sharing.
Output to local storage
Finalized segments append to a file in the app’s Documents directory instead of accumulating indefinitely in RAM.
Trust boundary
Privacy is explicit—and so are the limitations.
The source defines no remote transcription endpoint, third-party analytics SDK, or application-controlled audio-upload path. That guarantee is separate from Apple’s language-asset delivery.
What stays local
- Microphone audio during transcription
- Audio format conversion
- Progressive recognition results
- Visible transcript state
- Finalized transcript archive
Material constraints
- Requires iOS 26 and supported iPhone hardware
- Supported languages vary by device and framework
- A language model may require an initial Internet download
- The source still requires Xcode 26 compilation
- Physical-device and long-duration testing remain pending
Red-team hardening
The engineering story lives in the failure paths.
Technical detail remains available on demand without interrupting the primary narrative.
Bounded queues and memory pressure
Capture and analyzer queues have explicit limits. Saturation is surfaced as an integrity failure rather than silently dropping audio or growing memory without control.
Interruption and route recovery
Calls, Siri, AirPods transitions, media-service resets, and backgrounding converge on explicit session-state and cleanup paths.
Incremental persistence and finalization
Final transcript segments append incrementally to local storage. Volatile text remains separate until the framework marks it final.
Model availability and offline behavior
The app distinguishes initial model availability from the active local recognition path. Offline validation remains a physical-device gate.
Validation boundary
Architecture reviewed. Device evidence remains.
The current status is intentionally visible without dominating the opening proposition.
| Evidence | Status | What it confirms |
|---|---|---|
| Architecture and source review | Reviewed | Confirms intended boundaries, bounded queues, lifecycle handling, and local storage strategy. |
| Control-alignment gate | Reviewed | Confirms centered labels, stable control geometry, and no clipping or overflow in tested layouts. |
| Physical iPhone transcription | Pending | Confirms device capability, locale support, audio capture, and recognition output. |
| Offline test after model installation | Pending | Confirms recognition remains functional without active connectivity. |
| One-hour memory and thermal profile | Pending | Confirms bounded behavior under sustained device load. |
| Interruption and microphone-route matrix | Pending | Confirms recovery across calls, Siri, AirPods, and audio-service resets. |
Build path
From generated source to an iPhone in four controlled steps.
XcodeGen allows a cloud macOS runner to create the project, sign the application, and publish it through TestFlight.
Commit the source bundle
Add the Swift source, project.yml, and README to a repository.
Generate with XcodeGen
Use a macOS cloud image with Xcode 26 and the iOS 26 SDK.
Sign and publish
Configure the developer team, archive the app, and upload it to App Store Connect.
Validate on the target iPhone
Exercise model installation, airplane mode, long sessions, interruptions, route changes, and finalization.
Local by architecture
Speech-to-text without making privacy a footnote.
Local Speech shows what on-device AI looks like when the implementation respects resource limits, lifecycle, failure integrity, and user trust.