Private local recognition
Microphone capture, format conversion, speech recognition, transcript rendering, and transcript storage remain on the device after the system-managed language model is available.
SpeechTranscriberPrivate by architecture iOS 26
On-device speech that behaves like a product.
Local Speech turns Apple’s iOS 26 speech stack into a resilient, privacy-first transcription experience—with bounded memory, failure-aware lifecycle handling, incremental local storage, and no application cloud service in the active 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.
The showcase centers on four product promises. Each maps directly to an implementation boundary and a concrete class of failure the code is designed to guard.
Reliable audio processing
The microphone callback stays minimal. Conversion moves to a dedicated processing queue, while queue saturation becomes a visible integrity failure instead of silent data loss.
AudioInputPipelineBounded resource usage
Capture and analyzer queues are explicitly bounded. Final text writes incrementally to a local file, and the SwiftUI view retains only a controlled working set.
TranscriptArchiveFailure-aware lifecycle
Interruptions, microphone route changes, model installation, cancellation, backgrounding, media resets, and final result delivery all 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 are appended to a file under the application’s Documents directory instead of accumulating indefinitely in RAM.
Trust boundary
Privacy is explicit—and so are the limitations.
The current source does not define a remote transcription endpoint, third-party analytics SDK, or application-controlled audio upload path. That guarantee is separate from Apple’s one-time 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 the device and framework
- A language model may require an initial Internet download
- The reference 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 is available on demand. These disclosures use native HTML, remain usable without JavaScript, and keep the primary narrative focused.
Bounded audio and analyzer backpressure
The capture pipeline retains at most eight microphone buffers
waiting for conversion. Analyzer input uses a bounded
AsyncStream policy with 32 slots. If either boundary
is exceeded, the app stops and marks the transcript as potentially
incomplete rather than silently discarding speech.
Real-time callback safety
The AVAudioEngine tap only enqueues captured buffers. Allocation, conversion, and analyzer delivery run on a dedicated processing queue, reducing work inside the latency-sensitive capture callback.
Finalization and result draining
Stop first ends microphone capture, drains queued conversion work, flushes converter output, closes analyzer input, finalizes SpeechAnalyzer, and waits for the result stream within a bounded timeout. The UI warns when the final words may be incomplete.
Interruptions, routes, and background state
Phone calls, Siri, microphone changes, media-service resets, application backgrounding, and view dismissal trigger explicit shutdown. A new recording rebuilds the audio pipeline instead of reusing potentially invalid format assumptions.
Language assets and cancellation
The session checks SpeechTranscriber hardware availability, resolves an equivalent supported locale, exposes installation progress, allows preparation cancellation, verifies installation, and manages older app-specific locale reservations when limits are reached.
Memory and ownership cleanup
Session resources are isolated from the SwiftUI model. Shutdown releases audio pipeline references, analyzer continuations, SpeechAnalyzer, SpeechTranscriber, result tasks, installation progress, and the transcript archive. Visible text is also capped while the finalized archive remains on disk.
Evidence status
Implemented is not the same as device-validated.
The page deliberately separates source-level implementation from tests that require Apple’s SDK, signing infrastructure, and a supported physical iPhone.
| Validation gate | Status | What it establishes |
|---|---|---|
| Architecture and lifecycle red-team | Reviewed | Ownership, bounded queues, cleanup, and failure paths are represented in source. |
| Source bundle and XcodeGen structure | Prepared | The project is packaged for an Xcode 26 cloud macOS builder. |
| Xcode 26 SDK compilation | Pending | Confirms exact API signatures and Swift 6 concurrency behavior. |
| 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 user-facing recovery across calls, Siri, AirPods, and audio service resets. |
Build path
From generated source to an iPhone in four controlled steps.
The included project uses XcodeGen so a cloud macOS runner can create the Xcode project, sign the application, and publish it through TestFlight without requiring the author to own a Mac.
Commit the source bundle
Add the Swift source, project.yml, and README to a GitHub repository.
Generate with XcodeGen
Use a macOS cloud image with Xcode 26 and the iOS 26 SDK.
Sign and publish
Configure the Apple Developer team, archive the app, and upload the signed build to App Store Connect.
Validate on the target iPhone
Exercise model installation, airplane mode, long sessions, interruption handling, route changes, and transcript finalization.
Local by architecture
Speech-to-text without making privacy a footnote.
Local Speech is a showcase of what on-device AI looks like when the implementation respects resource limits, system lifecycle, failure integrity, and user trust—not just the happy-path demo.