The iOS and Android apps run VoiceStudio on your phone: speech, voice cloning, dictation and dubbing work offline once their models are downloaded, with no computer, account or cloud service. If you also run VoiceStudio on a computer (desktop app, Docker or a server), you can pair the phone with it and choose, per task, to run on This phone or My computer.
Preview. The apps aren't in the App Store or Google Play yet. Download them from Releases (Install) or build them from source (below).
| iOS | Android | |
|---|---|---|
| Minimum OS | iOS 17 (iPhone, iPad) | Android 10 (API 29) |
| Source | mobile/ios/ |
mobile/android/ |
Each release attaches the phone apps next to the desktop installers on the Releases page.
- Android: download
VoiceStudio-<version>-android.apkon the phone, open it and allow installs from that source when Android asks. For release updates, addhttps://github.com/debpalash/VoiceStudioin Obtainium, or add the publisher-operated F-Droid repository. It carries the same release-signed APK; it is separate from F-Droid.org's main catalogue. - iPhone: download
VoiceStudio-<version>-ios-unsigned.ipaand install it with a sideloading tool that signs it with your own Apple ID (for example Sideloadly). With a free Apple ID the install expires after 7 days; turn on Developer Mode (Settings → Privacy & Security) when iOS asks.
Check downloads against the release's SHA256SUMS.txt.
Home keeps its title and feature summary beside a compact contributor column, with a stacked layout at accessibility text sizes. “Brought to you by” introduces 14 contributors, with the smaller portraits in a two-row horizontal scroller. It puts Palash (@debpalash) and Shimul (@velixio) above the smaller contributor portraits. Tap either core maintainer to open a native profile sheet with their role, website, GitHub and X links. Portraits, brand icons and profile metadata are bundled for offline use; external pages open only when tapped. Contributor portraits use the public GitHub profile images refreshed on 2026-10-26. The contributor export also keeps iOS portraits identical to Electron and Android.
Settings → Support contains native Donate, VoiceStudio Pro and Other Apps pages on both phones. All copy and project logos are bundled for offline use. Donate offers the same GitHub Sponsors, Ko-fi and PayPal destinations as desktop, opened only by a tap; gifts do not unlock features. Pro explains the computer production tools while the phone's creative tools stay free. It does not sell or activate mobile features. Other Apps introduces OpenGTM, Opal, Supermetry and Spicrawl with explicit sponsor credits and individual links.
- Speech: type text, pick a voice and language, generate, play, share. Switching between the phone and computer keeps your script.
- Voices: clone a voice from a recording or an audio file. Voices you clone on the phone stay on the phone. Stereo recordings use audio from both channels. Whisper transcribes the sample; OmniVoice generates the cloned preview. Both models must be installed. Saving publishes a voice only after that preview succeeds; playback plays the clone, while the original recording stays separate for reference conditioning. Withdrawing voice consent cancels cloning on the phone or computer; the form stays open so you can review it before trying again.
- Dub: pick a video or audio file and target languages; the phone transcribes, translates and re-voices it in the original speaker's voice. Play completed dubs directly in the app, including after using Dictate; switching between video results keeps both picture and sound.
- Dictate: tap the mic and watch the transcript appear live. Completed sessions are saved in Transcriptions, including sessions run on a paired computer.
- Transcriptions: search saved text, edit while retaining the original, copy, delete, and export TXT/JSON or timed SRT/VTT. Import audio/video up to four hours and 1 GiB for on-phone transcription; compress or split larger source files. Completed 20-second sections survive interruption; Resume uses the same installed model and verified source. Subtitle export uses the original timed transcript; restore it after text edits to export subtitles.
- Models: download, update or delete the on-device models.
- Voice design: choose voice traits and a seed, generate a sample with OmniVoice, then save it as a phone voice for Speak, Stories and dubbing.
- Stories and Audiobooks: import UTF-8 text, unencrypted EPUB or text PDFs
(up to 64 MB), cast characters, and render on the phone. Scanned PDFs need
text recognition first. Share WAV, MP3, AAC/M4A or chaptered M4B; M4B supports up to
255 chapters. Use
# Chapter title, line-leading[voice:Name]and[speed:1.25], and[pause:0.5]for silence. Pronunciation replacements and unchanged-line caches avoid regenerating unaffected narration. MP3 is encoded locally with the bundled LAME encoder; exports can be canceled. Phone Speak also shares WAV/M4A/MP3, with sample-rate conversion handled automatically. - Batch dubbing: pick several audio/video files, choose languages and a voice once, and queue them on the phone. Successfully added files leave the selection; remaining files stay available if a later import fails.
- Edit a completed phone dub: change source/translated text, timing and individual voices and 0–200% segment volume (including mute); split/merge segments; undo/redo; import/export SRT or VTT; preview original/generated waveforms. Label speakers and assign a saved voice to a cast member while keeping individual line overrides. Export styled or dual ASS subtitles, verified per-line clips, or packages containing dubbed audio and the original audio (which is not an isolated background stem). Video exports can contain multiple language tracks with a chosen default. Generate Dub reuses unchanged segments and keeps the previous completed output until replacement succeeds. Volume changes remix existing speech without running the model again. Sources stay on the phone until you delete the job. Older Android jobs whose sources were already removed must be imported again. Clip/stem package exports check available space on the output volume and stop before writing package media when space is insufficient or cannot be determined.
- Advanced computer dubbing: use installed speaker-analysis models, review the cast, regenerate a language with the chosen voices and timing mode, and export selected tracks, background-preserving mixes, burned subtitles, dual captions or karaoke. Speaker analysis, background separation and subtitle burn run on the paired computer. Detect reruns the installed speaker model on an already-transcribed project without replacing its text, timing, translations or explicit voice choices. Regeneration keeps saved line volumes, speech rates, delivery instructions and audio effects. Model downloads remain explicit.
- Project transfer: export/import editable
.vsprojectarchives on either phone or Electron's Projects page. Manuscripts, chapter headings, casts, pronunciation settings, dub timelines, translations, references and assets travel together, including translations that have not been rendered. Imports create new copies and require permission for bundled voice recordings. Engine settings and foreign caches remain in the archive; rendering uses compatible installed models. Pairing also provides a received-project inbox. The computer retains outgoing download archives for up to 24 hours, keeping at most the newest 20 within a 2 GiB budget; export again after expiry. Imported projects and their assets are retained. - Tools: convert an audio clip of up to 30 seconds into a saved voice, with optional duration matching, or compare two preset/saved voices reading the same text. Record conversion input directly with microphone permission and voice consent; recording stops by 29 seconds. Conversion transcribes and re-synthesizes; it does not transfer the source's pitch or expression.
- Audio editor: trim, fade in/out, adjust gain, normalize actual peaks and apply a noise gate without any model download. Processing streams from disk (up to four hours), preserves the original, and shares WAV/M4A/MP3. Existing synthetic provenance stays marked; a natural recording remains unmarked.
- Gallery: browse installed phone presets offline. My computer browses, previews and imports community voices on the paired host. Copy to phone explicitly transfers a reference recording and transcript after voice permission; the phone keeps author and licence details. References are limited to 30 seconds. This does not download a model or generate a preview. Opening the host gallery may refresh its community manifest; preview, host import and phone copy are separate actions.
- Workflows: connect transcription, translation, speech, voice conversion and normalization steps. Yes/no conditions can rejoin; retries and saved runs retain completed work. Import/export desktop workflow JSON, then choose phone voices and reattach audio. Conversion uses transcription and re-synthesis, up to 30 seconds. Desktop agent/call nodes and multiple-source batches are explicitly rejected; supported graphs run offline with installed models.
- Calls: control the paired computer's configured Twilio agent: confirm a call, follow its transcript, take over, type speech or hang up. Pair with an API key, then enable Allow paired call control in the computer's Calls settings. Sharing PINs cannot authorize calls; desktop-mode call settings stay on the computer. Only designed or verified-own voices may place calls. Twilio charges apply.
- Phone speech API: choose preset or saved-voice speech, and optionally
enable transcription and translation using installed models. Speech returns
marked WAV or MP3;
/mcpoffers only the enabledspeak,transcribeandtranslatetools using MCP 2025-11-25. Copy its temporary bearer token to authenticate every request. Loopback is the default; Allow local network enables other devices. One model operation runs at a time. The server stops when you leave its screen or background the app. - System integration: share text/audio/video into a review screen, then explicitly run a task. Home widgets and shortcuts open Speak or Dictate without starting recording or inference. Saved voice-design recipes reopen for editing.
Production workspaces are available from Home on both iOS and Android. Install models in Models first. Voice Design uses OmniVoice. Saved-voice speech uses OmniVoice, Pocket TTS or ZipVoice, with each model’s licence gate; translation uses the phone translation model. Voice designs save their generated sample, traits and seed. References are limited to 30 seconds; longer design results remain playable/shareable.
Stories, books, workflows and queued dubs keep completed work on disk. Android keeps long Stories and Audiobook manuscripts in a scrolling editor and retains the complete local draft and its settings across activity recreation. Checkpoints are read and written off the UI thread. Rotation keeps pending edits and retries failed writes. After process death, a small local reference restores that project's last complete checkpoint. If a new project's first checkpoint has not succeeded, Retry cannot restore the preceding project through the new reference; older files are preserved and explicit New remains available. New drafts save only that reference. An older app's existing inline recovery snapshot is retained temporarily while its checkpoint migration is pending, then replaced by the durable reference; explicitly starting or selecting a different project does not carry that old snapshot forward. A failed load offers Retry or an explicit new draft without deleting the unreadable checkpoint. Retired unsaved drafts are removed only after their known recovery references are released; unrecognized files are preserved. Autosave and project switching use separate temporary files, preventing save failures when their metadata writes overlap. Deleting a saved project also removes its draft checkpoint. Android runs these through foreground workers with progress and Cancel. iOS owns running jobs independently of screens. On supported iOS 26+ devices, GPU work requests continued processing with the signed background GPU entitlement; the UI only claims it after the OS grants it. An explicit CPU fallback option can cancel, checkpoint and continue on CPU when GPU background execution is unavailable. Foreground work retains GPU acceleration. Older systems use limited background grants. The OS may still pause work; Resume continues an unchanged saved draft. After editing a book or workflow, Generate uses the current settings and reuses matching cached work. Low battery or critical thermal conditions pause processing. This sustained job support covers dubs, stories/books, workflows and file transcription; short interactive tools and the phone API remain foreground tasks. Delete a project/job to remove its media.
Open Home → Phone speech API, choose enabled capabilities and a preset or saved voice, then start it. For another device, enable local network access and use a displayed address. Copy the bearer token; it changes whenever you start a new server.
curl http://PHONE_IP:PORT/v1/audio/speech \
-H 'Authorization: Bearer YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"input":"Hello from my phone","voice":"default","response_format":"wav"}' \
--output speech.wavdefault uses the preset or saved voice selected on the phone. Set
response_format to mp3 for local MP3 encoding. GET /v1/models lists the
selected model ID for clients that require model. Speech accepts up to 2,000
UTF-16 units and a speed from 0.5 to 2. Authenticate
GET /health too. MCP clients connect to /mcp with the same bearer token;
speak takes text, optional speed and format (wav or mp3).
When enabled, POST /v1/audio/transcriptions accepts JSON {"audio":"BASE64_WAV"}
containing PCM16 mono WAV (8–24 kHz, up to 30 seconds). This is a bounded JSON
upload, not a multipart upload. POST /v1/text/translations accepts
{"input":"Hello","language":"fr"}; language codes must be supported by the
selected model. Both return {"text":"…"}. MCP transcribe takes audio;
translate takes text and language. Requests never download models, select
an unapproved voice or open a file/URL. Keep VoiceStudio active on this screen.
Open Models and download what you need. Nothing downloads until you tap it; model files come from pinned Hugging Face revisions or an explicitly listed GitHub release component and are checked before use. Wi-Fi only unless you allow mobile data. Downloads follow VoiceStudio’s default network route and use an active VPN when its configuration includes VoiceStudio. A per-app VPN that excludes VoiceStudio does not carry its downloads; the app does not change network bindings to bypass a tunnel. Android's Wi-Fi-only policy requires an unmetered Wi-Fi or Ethernet route, including the VPN's own underlying route. A metered tunnel or one whose underlying route is unknown remains waiting unless you allow mobile data. Network changes and restored queues retain saved partial downloads.
Concurrent downloads reserve their combined remaining disk space. If they will not fit together, finish or cancel one before starting another; completed ranges remain available for resume. Saved speech keeps the text submitted for that take, even if you edit the next script while synthesis is running.
| Model | For | Size | Recommended phone memory |
|---|---|---|---|
| Kitten (English) / Kokoro (multi-language) | Speech | ~170 MB each | 2–3 GB |
| Piper Lessac (English) | Speech, one preset voice | 64 MB | 2 GB |
| Supertonic 3 (31 languages) | Speech, ten preset voices | 145 MB | 3 GB |
| Pocket TTS (English) | Speech with a saved voice | 198 MB | 3 GB |
| ZipVoice (English / Chinese) | Speech with a saved voice and transcript | 187 MB | 3 GB |
| Whisper tiny / base | Transcription, dubbing | 100–160 MB | 2–3 GB |
| Zipformer | Live dictation (English) | 44 MB | 2 GB |
| OmniVoice (Q8 / F32 codec) | Speech with a saved voice, voice design, dubbing | 1.4 GB | 8 GB |
| Qwen3 1.7B | Dub translation | 1.1 GB | 6 GB |
Some models ask you to accept their licence first (for example OmniVoice is for non-commercial use), the same as on the desktop. RAM values are recommendations: larger models stay selectable, show a warning that they may run slowly or close the app, and offer Try anyway in their download prompt. You can download and run them below the recommendation. Licence acceptance, available storage and file verification are still required.
Speech's model picker shows all seven speech engines before installation. OmniVoice, Pocket TTS and ZipVoice need a saved voice; import one from Gallery or create one in Voices. Their Generate action stays unavailable until a reference is selected. Create a designed voice in Voice Design, save it, then select it in Speech. Choosing a preset-only engine clears an incompatible saved voice. Selecting a model starts no download. Pocket's conversion has conflicting licence statements and is treated as non-commercial; Piper's training-data rights remain unresolved. Review the exact terms shown before accepting any new pack.
- On the computer, open VoiceStudio, click the Local pill in the footer and choose Network (how sharing works). On a different network, use Tailscale or an HTTPS address instead.
- In the app, tap Scan QR code and scan the code the panel shows. Or tap Enter address and type the address and the 6-digit PIN.
- For a server protected by an API key, enter the key once. The app swaps it for a session and never stores the key; Disconnect ends the session.
Plain http:// works only for addresses on your own network (home Wi-Fi,
.local, Tailscale); everything else must be https://.
Every generated result (a Speech take, a cloned voice, a finished dub) has a Report action. Pick what's wrong, optionally add a note or the text you typed, and tap Send report. It sends only the reason, your note, that text if you ticked it, the app version and the model that made the result to the VoiceStudio team; no audio, account or device ID. Nothing is sent until you tap Send, and reports are deleted after 180 days.
- "Accept the licence on your computer": some models need their licence accepted first. Open VoiceStudio on the computer → Model Catalogue and accept it there for the My computer route. For This phone, review and accept the licence in the phone’s Models screen.
- Computer engine shown as unavailable: install it on the paired computer. For phone tasks, install the model from the phone’s Models screen.
- Dictate isn't ready: install the speech-to-text model the app names, on the phone for This phone, or the computer for My computer. Remote dictation also needs an API-key session or a trusted network set up on the computer; the share PIN alone isn't enough.
- Can't connect: make sure the phone and computer are on the same network (or both on Tailscale), sharing is on, and you used the IP address the panel shows. See troubleshooting.
Both apps follow one contract, mobile/contract/SPEC.md:
a feature ships on both or neither. Colors, the API description and the text
are generated from the desktop app and backend, never copied by hand:
bun scripts/export-mobile-tokens.ts # theme tokens from the Electron theme
bun scripts/export-mobile-design.ts # native design traits from Electron
bun scripts/export-mobile-contributors.ts # maintainer identities and profile links
uv run python scripts/export_openapi.py # mobile/contract/openapi.json from the backendtests/test_mobile_contract.py fails when either is stale.
Reports in test builds. Every build, debug included, sends reports to
production. To test against the development API, copy mobile/.env.example to
mobile/.env (git-ignored) and set
VOICESTUDIO_CONTENT_REPORTS_URL=https://dev-appapi.voicestudio.sh, or export
that variable; the environment wins over the file. Rebuild after changing it.
Try the iPhone app without Xcode. Each mobile workflow run uploads an
unsigned build, VoiceStudio-ios-unsigned (kept 7 days). Download it from the
run's Artifacts, then install it with a sideloading tool that signs it with your
own Apple ID (for example Sideloadly). With a free Apple ID the install expires
after 7 days; turn on Developer Mode on the iPhone (Settings → Privacy &
Security) when iOS asks. App text uses the
Electron locale catalogs (mobile.* keys). The mobile workflow builds and
tests both apps.
The iOS TestFlight workflow signs the iPhone app and uploads it to TestFlight
for the team's internal testers by default. Its manual audience choice also
supports external for a public TestFlight beta. It prepares the pinned native
inference runtimes before generating and archiving the Xcode project, including on a clean runner.
It is dispatched by hand from main and never
submits the app for App Store review. One-time setup in the Apple Developer team:
- Register the App ID
sh.voicestudio.mobile(Certificates, Identifiers & Profiles → Identifiers) and create the app in App Store Connect with it. The same team must own the Share IDsh.voicestudio.mobile.shareextensionand widget IDsh.voicestudio.mobile.workspacewidget. Assign the existinggroup.sh.voicestudio.mobile.developmentApp Group to both the app and Share extension, then refresh their profiles. Each extension ID must be the main app ID plus one dot and a single suffix, with no additional periods; a development archive can succeed with an ID that App Store export rejects. The main app keeps its existing App Store record’s bundle ID. For another team, change the bundle IDs andVS_APP_GROUP_IDENTIFIERinproject.yml; that one group setting supplies both entitlements and runtime bundle metadata. Automatic signing cannot claim an unavailable identifier or use a profile missing the shared App Group entitlement. See Apple's App Groups setup. - Register at least one iPhone under Devices (its UDID is in Finder when it is connected). Automatic signing archives with a development profile first, and Apple issues none for a team without devices.
- Create an App Store Connect API key with the Admin role (Users and Access → Integrations). Admin lets CI create the cloud-managed Apple Distribution certificate and App Store profile during export.
- Create the
app-store-connectenvironment (Settings → Environments), limit it to themainbranch, and addAPP_STORE_CONNECT_KEY_ID,APP_STORE_CONNECT_ISSUER_IDandAPP_STORE_CONNECT_API_KEY(the full.p8text).APPLE_TEAM_IDis shared with macOS notarization. - Export one existing Apple Development identity for that same paid team
from Keychain Access as a password-protected
.p12. Include its private key; a downloaded.ceralone cannot sign. Add the base64 file asIOS_ARCHIVE_CERTIFICATEand its password asIOS_ARCHIVE_CERTIFICATE_PASSWORDin bothapp-store-connectandmobile-release. Never commit either value or revoke an active certificate to free a slot for a CI rerun. Each runner imports this existing identity into a temporary keychain, verifies its team and private key, then removes the keychain and decoded certificate. Xcode may create provisioning profiles for the app, Share extension and widget. Export still uses Apple's cloud-managed Apple Distribution identity; the.p12is only for the development-signed archive. Rotate these secrets when the identity expires. Validate an export with both OpenSSL andsecurity importinto a temporary keychain before setting the secrets: parsing a PKCS#12 certificate alone does not prove Apple's Security framework can import its encrypted private key.
For a public beta, dispatch from the latest main with
gh workflow run ios-testflight.yml --ref main -f audience=external. This creates
an external-eligible build; uploads marked Internal Only cannot be reassigned to
external groups. In App Store Connect, create an external group, complete Test
Information, add the build and submit it for Beta App Review. Once approved,
create its public link and set Tester Limit to the desired capacity (for
example, 100). The limit applies to testers joining through that link.
Regular dispatches retain the internal default. Neither audience submits an
App Store version for public sale. See Apple's
external testing and public-link instructions.
The workflow builds on the macos-26 runner because App Store Connect accepts
only the current iOS SDK; the mobile and mobile-release iOS jobs use the same runner.
The app icon is Resources/Assets.xcassets/AppIcon.appiconset/AppIcon.png, a
1024×1024 opaque PNG rendered from mobile/ios/VoiceStudio/AppIcon.svg.
Generated Brand.xcassets supplies launch and Home artwork; it removes the former
generated app icon so incremental builds also bundle exactly one icon catalog.
Privacy manifests ship in the app, both extensions and the embedded OmniVoice
and llama frameworks. The app declares private preferences (CA92.1), model and
render storage checks (E174.1), private file metadata (C617.1) and files the
user explicitly selects (3B52.1). The Share extension declares selected-file
metadata; the native frameworks declare private model-file metadata. The widget
uses none of these APIs. These manifests declare no tracking; they do not enable
telemetry. Apple's required-reason API policy
applies to each executable bundle, so the unsigned CI build, TestFlight archive
and signed release export all validate the packaged declarations before upload.
Info.plist declares ITSAppUsesNonExemptEncryption as NO: the app uses
only the system's HTTPS and hashing, which are exempt, so builds skip the
export compliance question. Revisit it if the app ever adds its own encryption.
The version is the root package.json version without any -beta.N suffix
(App Store Connect accepts only X.Y.Z); the build number is the workflow run
number and attempt, so every upload is new.
The Android Play internal testing workflow is the Android counterpart: it
signs a release bundle with the Play upload key and uploads it to the Play
Console internal testing track. It is dispatched by hand from main and
never sends a release to production. The store listing, graphics and Play Console
answers are in store/google-play.md. One-time setup:
- Create the app in the Play Console with the package name
sh.voicestudio.mobileand keep Play App Signing on (Google holds the app signing key; CI only holds the upload key). - Reuse the upload key from the
mobile-releaseenvironment so builds keep their signing identity. Keep a backup in the team password manager. Only if no key exists yet, create it once:keytool -genkeypair -v -keystore upload.jks -alias upload -keyalg RSA -keysize 4096 -validity 10000. - Create a Google Cloud service account with a JSON key, then invite its email in the Play Console (Users and permissions) with release access to this app.
- Create the
google-playenvironment (Settings → Environments), limit it to themainbranch, and addANDROID_UPLOAD_KEYSTORE(the.jksas base64),ANDROID_UPLOAD_KEYSTORE_PASSWORD,ANDROID_UPLOAD_KEY_ALIAS,ANDROID_UPLOAD_KEY_PASSWORDandGOOGLE_PLAY_SERVICE_ACCOUNT_JSON. - Google Play takes the first bundle only through the Play Console. Prepare
it without attempting an upload: run mobile-release from
main, leaverelease_refempty, enableandroid, and disableiosandsigned_ios. Itsmobile-releaseenvironment needs the same four Android upload-key secrets (use the existing key, including for later Play builds). DownloadVoiceStudio-android-release, then upload itsVoiceStudio.aabto internal testing by hand. This manual build produces artifacts only; it creates no release or tag and contacts no store. Until the app's first release is rolled out, dispatch Android Play internal testing with statusdraft.
The Play workflow installs the pinned NDK/CMake and reuses the native runtime cache. Before uploading, it strictly verifies the bundle against that upload key, accepting its self-signed certificate while rejecting unsigned content, other signers (including extra trusted co-signers) and Android debug certificates.
Camera, autofocus and microphone hardware are optional: text-to-speech, imported media and manual pairing work without them. The Android manifest explicitly opts out of the rear-camera and autofocus requirements implied by the camera permission, so Play does not exclude devices that lack them. QR scanning still asks for camera permission when used.
The version name is the root package.json version. Both signed Android
workflows get their version code from scripts/android_version_code.py: UTC
minutes since 2020-01-01 (seconds jumped too far for Play). They share a concurrency
group, so signed builds run one at a time, each taking minutes, and subsequent
builds, including reruns, receive increasing codes
across Play and GitHub releases. Local and mobile workflow APKs are debug-signed;
local release builds without upload-key environment variables are unsigned.
Every desktop release calls mobile-release at the same tag and includes the
signed Android APK/AAB and unsigned iOS sideload IPA in the same GitHub Release.
Both phone builds must pass before publication. Store uploads are separate: use
TestFlight and
Play internal testing. Nothing is published
to production automatically.
- Run it: the desktop release runs both phone builds automatically. For recovery,
Actions →
mobile-release→ Run workflow, setrelease_refto the release tag andsigned_ios=falsefor sideload artifacts without Apple signing. Manual runs produce artifacts. Rename them toVoiceStudio-X.Y.Z-android.apk,VoiceStudio-X.Y.Z-android.aabandVoiceStudio-X.Y.Z-ios-unsigned.ipabefore attaching missing files to the existing release. Preserve existing published binaries. Add the new files' SHA-256 digests to the sharedSHA256SUMS.txt, preserving existing entries, and update the release download links and signing status. Verify the uploaded asset digests against the checksum manifest. Legacymobile-v*tags still draft a separate prerelease. - Downloads for everyone: the shared release holds the signed APK and AAB,
an unsigned IPA for sideloading, and
SHA256SUMS.txt. Manual builds withsigned_ios=trueadditionally produce an App Store IPA. The App Store IPA only installs through TestFlight; iPhone users outside TestFlight sideload the unsigned IPA with their own Apple ID. - Version: the root
package.jsonversion. Android shares its increasing build code with Play; iOS uses the workflow run number and attempt. - Secrets (repository environment
mobile-release, with required reviewers, not limited tomainso tags can use it): the same values as the store workflows,ANDROID_UPLOAD_KEYSTORE,ANDROID_UPLOAD_KEYSTORE_PASSWORD,ANDROID_UPLOAD_KEY_ALIAS,ANDROID_UPLOAD_KEY_PASSWORD,APP_STORE_CONNECT_KEY_ID,APP_STORE_CONNECT_ISSUER_ID,APP_STORE_CONNECT_API_KEY,APPLE_TEAM_ID,IOS_ARCHIVE_CERTIFICATEandIOS_ARCHIVE_CERTIFICATE_PASSWORD(the last two are required for signed iOS archives).
Android updates also require the installed app's signing certificate. Google Play App Signing may use a different certificate from the APK upload key; version codes do not make builds with different signing keys interchangeable.
Android keeps a failed computer dubbing job visible while you stay on the Dub screen. Worker updates do not dismiss the error, and reopening the screen does not repeat an error already shown.
OmniVoice's phone pack uses a Q8_0 language model and full-precision F32 audio codec. Earlier Q4 files are kept in the model folder, but the updated pack needs its new files downloaded from Models. Existing voice recordings, generated clips and licence acceptance are preserved. Speech requires a saved reference; it no longer invokes reference-free voice design, which could return noise for short text such as “Hi hello”.