argmaxinc/argmax-oss-swift: WhisperKit, SpeakerKit and TTSKit in One Swift Package

What the Argmax Open-Source SDK actually contains

Three inference frameworks live in a single Swift package, each shipped as its own library product. WhisperKit wraps OpenAI Whisper for speech-to-text. SpeakerKit wraps Pyannote for speaker diarization. TTSKit wraps Qwen-TTS for text-to-speech. An umbrella product called ArgmaxOSS imports all three at once, and the README describes the package as a collection of "turn-key on-device inference frameworks."

The audience is narrow and specific: Swift developers building for Apple platforms who want audio processing to happen on the device rather than in a cloud call. The prerequisites listed are macOS 14.0 or later and Xcode 16.0 or later. There is no server component in the open-source package, no API key, and no account. That is the whole pitch, and it is a coherent one for apps where audio cannot leave the phone or laptop.

The README is explicit that a separate commercial product exists. Argmax Pro SDK is listed as supporting additional models and features including real-time transcription with speakers, custom vocabulary, an "Argmax Local Server" for non-native apps, and Android support through a Kotlin SDK. Anyone evaluating the open-source package should read that block first, because it defines the boundary of what the free package will ever do.

How WhisperKit loads and transcribes audio

The default path is simple: initialize a WhisperKit instance, hand it a file path, and read text off the results. The README's quick example passes a path ending in .wav, .mp3, .m4a or .flac and joins the segment texts with spaces.

The design detail worth noticing is memory behavior. The README states that by default WhisperKit loads the whole audio file into memory before transcribing, and that for long recordings an incremental mode streams from disk in bounded-memory chunks instead. That mode is selected through AudioInputOptions with an audioLoadingMode of .incremental. For a short voice memo the default is fine. For an hour-long meeting recording on a phone with limited headroom, the incremental path is the difference between working and being killed by the OS.

SpeakerKit is designed to be combined with transcription, and the README documents RTTM output for diarization results, which is the format the diarization research community already uses. TTSKit exposes generation options, saving audio to disk, progress callbacks, and style instructions that the README marks as available on the 1.7B model only. Custom voices and real-time streaming playback are both documented for TTSKit.

Installing via Swift Package Manager and running a first transcription

Add the package once and select the products you need. In Xcode, the README's steps are File > Add Package Dependencies, then the repository URL https://github.com/argmaxinc/argmax-oss-swift, then choose ArgmaxOSS or the individual kits. In a Package.swift manifest the dependency looks like this.

dependencies: [
    .package(url: "https://github.com/argmaxinc/argmax-oss-swift.git", from: "0.9.0"),
],

Then declare the product you want as a target dependency. The README shows the umbrella product first and the individual kits commented out beneath it.

.target(
    name: "YourApp",
    dependencies: [
        .product(name: "ArgmaxOSS", package: "argmax-oss-swift"),
    ]
),

With the package resolved, the smallest useful program initializes the pipeline and transcribes one file. Expect the first run to spend time fetching and compiling the model before any text appears.

import WhisperKit

Task {
    let pipe = try? await WhisperKit()
    let results = try? await pipe?.transcribe(audioPath: "path/to/your/audio.wav")
    let transcription = results?.map(\.text).joined(separator: " ")
    print(transcription ?? "")
}

For a command-line workflow rather than an app, the README documents a Homebrew install of the CLI, and the repository Makefile drives model downloads from the argmaxinc/whisperkit-coreml, argmaxinc/ttskit-coreml and argmaxinc/speakerkit-coreml model repositories into a local Models directory.

brew install whisperkit-cli

The README also documents a local server with API endpoints, a generated API specification, and client generation, plus client examples under Examples/ServeCLIClient. The README notes there are API limitations, so treat the server as a convenience for local development rather than a full production surface.

Where the open-source package stops

The most important limitation is stated by the project itself, not inferred. Real-time transcription with speakers, frontier accuracy with custom vocabulary, the Argmax Local Server for non-native apps, and Android support are all listed under the Pro SDK. If your product requires any of those four, the open-source package is the wrong tool and no amount of integration work will change that.

Platform scope is the second constraint. The prerequisites name macOS 14.0 or later and Xcode 16.0 or later, and the package is Swift. There is no documented path to Windows, Linux or the browser. A team with a web frontend and a Python backend is not the audience here.

Model weights are a separate distribution problem. The Makefile downloads from Hugging Face repositories into ./Models, and the README documents model selection and even generating models. That means your app either bundles weights or fetches them, and the documentation does not present a rollback story for a model that regresses on your audio. The README is silent on rollback, so plan for it yourself.

The server surface is explicitly bounded. The README has a section titled API Limitations, and while the details are not reproduced here, the existence of that heading next to a list of "Fully Supported Features" tells you the HTTP layer is not a drop-in replacement for a general-purpose transcription service.

WhisperKit versus whisper.cpp and the hosted-API alternative

The nearest open-source comparison is whisper.cpp, which also runs Whisper locally and is the subject of one of the related searches. The difference is packaging and platform. whisper.cpp is a C and C++ implementation with bindings for many languages and a broad platform reach; WhisperKit is a Swift package built around Apple's frameworks, with the model conversion and Core ML packaging handled by the project. If you are writing a SwiftUI app, WhisperKit removes the bridging work. If you need the same code path on Android, Linux and iOS, whisper.cpp is the more portable choice and the Argmax package cannot help you at all.

The other alternative is a hosted transcription API. Those give you managed scaling, no model download, and no device compute budget, at the cost of sending audio to a third party and paying per minute. The README's framing makes the trade-off clear: on-device means the audio stays where it is, and the compute bill lands on the user's battery and thermal budget instead of an invoice.

Within the Argmax family there is also a real fork in the road. The README links to a page comparing the open-source and Pro SDKs. Read it before committing, because the feature list in this repository is a subset by design, and the gap is where most production speech products end up wanting to live.

Maintenance cadence, licensing and upgrade cost

The last push to the default branch was on 2026-08-13, and the most recent release in the list is v1.1.0 from 2026-08-06. Before that, v1.0.0 landed on 2026-05-01 and v0.18.0 on 2026-04-01. The repository is not archived. The release spacing suggests a steady cadence rather than a burst, but the version history also shows a pre-1.0 line that ran well past version 0.18, which tells you the API took a long time to settle. Any code written against a 0.x version should be reviewed against the 1.x surface.

The licence is MIT, which is permissive and imposes no copyleft obligation on your application. The repository also carries a NOTICES file, and third-party model weights come from separate Hugging Face repositories with their own terms. MIT covers the Swift code, not the model checkpoints, and the README does not spell out the model licences. Check each model repository before shipping.

Upgrade cost is mostly model churn. Because the Makefile pins model repositories rather than individual revisions, a re-download can bring different weights. If you ship an app whose output quality matters, pin the model artifacts you validated instead of pulling whatever the repository holds at build time.

Editorial conclusion

Adopt argmax-oss-swift if you are building a native iOS or macOS app that must transcribe, diarize or synthesize speech without sending audio off the device. Skip it if you need Android, a hosted API, or the real-time speaker-attributed transcription that the README places in the Pro SDK. Before writing code, confirm your deployment target is macOS 14.0 or later with Xcode 16.0 or later, and decide whether the open-source feature set covers your accuracy requirements or whether the Pro comparison page is the more honest starting point.

Frequently asked questions

Official sources

1. argmaxinc/argmax-oss-swift on GitHub
2. Issues
3. License: MIT
4. README
5. Releases