Scribe AI
Scribe AI explores how speech intelligence and carefully designed application systems can support live church production. Its original Python prototype processes microphone audio locally, identifies spoken Bible references, retrieves verses from a local database, and presents candidates for human approval.
The project has since expanded into a dedicated desktop application built with Tauri and React. The desktop application establishes a command-driven architecture for production workflows, output management, permissions, and operator interaction. It remains a separate development track: the Python speech engine has not yet been integrated into the desktop application.
- AI Systems & Offline-First Applications
- Tauri 2 · React 18 · TypeScript · Rust · Zustand · Tailwind CSS 4 · Python · Faster-Whisper · SQLite
- Microphone, five-second chunks
- Faster-Whisper, local CPU
- Pattern rules, validated against chapter counts
- SQLite, spoken formats normalised
- Operator approves, dismisses, or enters manually
- Fullscreen, only after approval
The question
Church production often depends on an operator listening for spoken scripture references, finding the corresponding passage, and putting it on screen at the right moment. This work can happen on modest hardware and in environments where a stable internet connection cannot be assumed.
The engineering challenge is broader than transcription. It involves building an offline-capable application in which speech processing, production controls, output windows, and operator decisions work together reliably, while keeping automated detection separate from final human approval.
Technical approach
Scribe has two distinct implementation tracks. The Python prototype captures microphone audio in five-second chunks and runs Faster-Whisper locally on the CPU. A rule-based detector identifies references across the 66 books of the Bible, validates chapter numbers, normalises spoken reference formats, and retrieves passages from a local SQLite database containing the KJV text. An operator can approve, dismiss, or manually enter a reference before it is displayed.
The desktop application is a separate Tauri 2 and React foundation. Its architecture uses a typed command bus to mediate application actions, with validation, permission checks, undo support, and audit logging. The Rust layer manages application-level state, while the frontend provides the studio shell, operator interface, and separate Audience and Stage output windows.
The desktop command architecture also establishes keyboard shortcuts, a command palette, and an AI permission gate. These are application foundations rather than evidence that every production workflow is complete. The Python engine is not yet connected to this command system, and several desktop screens and persistence capabilities remain unfinished.
Lyric matching and service-state detection also exist in the Python codebase, but they are separate from the working microphone-to-scripture workflow. Their integration and evaluation against real service recordings remain outstanding.
Components and their status
Desktop application foundation
Tauri 2 and React studio shell, built with TypeScript and Rust.
Typed command architecture
Command bus with validation, permissions, undo, audit logging, and keyboard interaction.
Audience and Stage outputs
Separate output windows and Rust-managed application output state.
Local speech recognition
Python microphone pipeline using Faster-Whisper on CPU with five-second audio chunks and voice-activity filtering.
Scripture detection and lookup
Rule-based detection across 66 Bible books, reference validation, spoken-form normalisation, and local SQLite lookup.
Operator approval
Human approval, dismissal, or manual entry before a detected scripture reference is displayed.
Desktop and AI-engine integration
Connecting the Python speech-processing pipeline to the Tauri command architecture and desktop production workflows.
Lyric and service-state intelligence
Separate Python modules for lyric matching and service-state detection; not yet integrated into the live microphone path.
Desktop persistence and complete workflows
Persistent application data and the remaining production screens and workflows.
My contribution
I designed and developed the Python speech-processing prototype, including the local transcription loop, scripture-reference detection and validation, spoken-reference normalisation, SQLite lookup, and operator approval workflow.
I also developed the desktop application's architectural foundation using Tauri, React, TypeScript, and Rust. This includes the typed command-bus approach, command validation and permissions, undo and audit mechanisms, keyboard interaction, and the separation of operator controls from Audience and Stage outputs.
A significant part of the work has been defining boundaries between automated intelligence and production control. The speech engine, desktop application, and unfinished detection modules are documented as distinct implementation states rather than presented as one integrated system.
Engineering decisions
Offline operation as a system constraint
The Python scripture workflow runs locally against local models and data. A network connection is not required for its microphone-to-lookup path, which is important in the environments the application is intended to support.
Automation does not own the final decision
Speech recognition and reference detection can make mistakes. A human approval step separates an automated candidate from the content that reaches a production display.
Commands mediate desktop actions
The desktop application uses a typed command architecture rather than allowing interface components to perform arbitrary application mutations. This provides a central place for validation, permissions, undo, and audit behaviour.
Separate operator and audience surfaces
Production controls and audience-facing output have different responsibilities. The desktop architecture gives them separate windows rather than treating the operator interface as the presentation surface.
Keep implementation status explicit
A working Python prototype, a desktop foundation, and planned integration are different engineering milestones. The project does not describe them as a completed unified product.
Current state
Scribe AI has a working offline Python prototype for microphone transcription, scripture detection, local Bible lookup, and operator approval. Separately, its Tauri desktop application has a substantial architectural foundation, including a typed command system and independent output windows. The two tracks are not yet integrated.
- The desktop application still has unfinished screens and workflows; persistent application data is not yet implemented.
- The Python lyric detector and service-state machine are not connected to the live microphone path.
- The speech engine has not yet been integrated into the Tauri desktop application.
- The scripture workflow has not undergone systematic evaluation on recordings of real church services.
Next questions
- How should the Python speech engine communicate with the desktop command system without weakening the application's permission and state boundaries?
- What persistence model best supports production data, application recovery, and reliable output state?
- How do transcription and scripture detection perform on real recordings with different accents, background music, and overlapping speech?
- How should lyric detection and service-state tracking be integrated into the live audio workflow and evaluated independently?