SpeakType: push-to-talk dictation that never leaves your computer

What the app does

SpeakType lets you type with your voice. Hold a key, say what you want to write, and let go. Your words appear wherever your cursor is, in an email, a chat, a document, a code editor, anywhere.

The model is a push-to-talk dictation app in the most literal sense. There is no microphone button, no typing mode, no special field. You hold a modifier, the app records, you release, and the text appears at the focus.

The positioning against the obvious alternative is stated in one paragraph, and it is the reason to look at this project. Most voice typing apps send your recordings to a company's servers and charge a monthly fee. SpeakType does all the work on your own computer, so it is free, it works without internet, and nothing you say ever leaves your computer.

The comparison table in the README sets that out in four rows. Cost is free with no limits against a monthly subscription. Your recordings stay on your computer against being uploaded to the company's servers. It works without internet against not working. And no account is needed against an account being required.

That last row is worth pausing on. A subscription for a dictation app is not just a cost, it is a data relationship, and the reason many people accept it is that they are not given an alternative. SpeakType's argument is that the alternative is a local model, and the local model is now small enough and fast enough to be practical.

The primary language is Swift, the licence is MIT, the default branch is main, and the homepage is tryspeaktype.com. The recent releases are v2.0.0 from 2026-09-22, v2.0.0-alpha.7 and v2.0.0-alpha.6 both from 2026-09-17, so the 2.0 line went through several alphas in a week before the stable release. The last push was on 2026-10-15 with the project not archived.

How it works, and what the model costs you

The three-step workflow is short enough to hold in your head.

Install SpeakType and open it. Download a speech model when the app asks, which is the part that turns your voice into text, and it is a one-time download of 75 MB to 1.6 GB, with SpeakType suggesting one that suits your computer. Then hold your shortcut and talk: click into any text box, hold fn on a Mac or Ctrl plus Shift plus Space on Windows and Linux, speak, and let go. The shortcut can be changed in Settings.

The 75 MB to 1.6 GB range is the whole trade in one number, and it is much narrower than it used to be. That is the size of the speech model, and it is downloaded once. A smaller model is quicker and uses less memory, a larger one makes fewer mistakes.

Two model families are offered and they are chosen for different reasons. Parakeet models are very fast and cover English plus 24 other European languages, but they are not available on Intel Macs. Whisper models cover 99 languages. You can download several and switch any time.

So the choice for most people is the platform constraint. On an Apple Silicon Mac, Parakeet is available and is the faster option with good European language coverage. On an Intel Mac, Parakeet is out and Whisper is the only route. And if you need a language outside Europe, Whisper is the answer regardless of platform.

The features list gives the performance claims in specific terms. A 35-second ramble becomes neat, punctuated text in under two seconds. The install is 15 MB and it stays out of the way when you are not talking. And it works in every app, typing into whatever you are using, and putting back anything you had copied.

That last detail is a nice touch. Dictation that overwrites your clipboard is an irritation that most implementations get wrong, and the fact that it is listed as a feature suggests the author has used the category of tool enough to notice.

The remaining features are the ones you would expect from a mature dictation app. Up to 99 languages depending on the model. A dictionary, so you can teach it names and terms it mishears, and filler words like um are removed. And a history you can copy and replay past dictations from, along with a count of how much typing you have saved.

Installing on each platform, and the Windows signing problem

The downloads are all on the GitHub releases page, and the file naming is the whole selection mechanism. For a Mac, Apple Silicon or Intel, on macOS 13 or later, it is the file ending in .dmg. For Windows 10 or 11, it is the file ending in -setup.exe. For Linux on Ubuntu, Debian, Mint or Pop!_OS, it is the file ending in .deb. For Fedora, RHEL or openSUSE, the .rpm. And for any other Linux distribution, the .AppImage.

So the packaging covers the four usual Linux formats plus the Mac disk image, which is a complete set for a desktop application.

The Mac install is the familiar one: open the .dmg and drag SpeakType into your Applications folder. Then open it and allow microphone access so it can hear you, and accessibility access so it can type for you.

Those two permissions are the crux of how a dictation app works on macOS, and the README explains what each is for. The microphone permission is obvious. The accessibility permission is the one that lets the app synthesise keystrokes into another application, which is how the text ends up in your email rather than in SpeakType's own window. Any app that types into other apps needs it, and it is a permission worth understanding rather than granting reflexively.

Linux has three routes depending on the package format. The .deb is installed by double-clicking it or by running sudo apt install ./SpeakType_*.deb. The .rpm is double-clicked or installed with sudo dnf install ./SpeakType-*.rpm. And the .AppImage needs chmod +x SpeakType_*.AppImage before it can be double-clicked.

Windows has one extra step, and the README is honest about why: if a blue Windows protected your PC box appears, click More info, then Run anyway, and you only need to do this once. The reason given is that the Windows app is not signed by Microsoft yet, and that this is coming soon.

That is a real limitation rather than a formality. Unsigned Windows executables trigger SmartScreen, and the workaround is a warning to the user to click through a security prompt. A signed build is on the roadmap, and the download badge in the README points at the releases page rather than a per-platform installer, so the version you get is the one that is current.

The questions, and the privacy argument in detail

The README has a series of collapsible questions, and they are where the actual product decisions are explained.

Is it really free? Yes, there is no trial, no word limit and no paid plan, and SpeakType is open source under the MIT licence, so anyone can read or reuse the code.

Does anything get sent over the internet? No. Your voice is turned into text on your computer. SpeakType only goes online to download speech models when you ask it to, and to check for new versions, which you can turn off in Settings. There is no account, and nothing is collected about how you use it.

That last sentence does two jobs. It answers the privacy question and it clarifies the business model, and the combination is the point. There is no account, so there is no user to sell data about, and nothing is collected, so there is no telemetry even in the anonymous sense. The two network behaviours that remain are the model download the user asked for and a version check that can be turned off.

Where are the recordings and history kept? Only on your computer, and you can delete single dictations or clear everything from the History screen.

The last question is the one with an interesting answer. If you used the old Mac app, do you lose your history? No. SpeakType 1 offers SpeakType 2 as an update, and the first time you open it your history, dictionary and settings come with you. You will need to download a speech model again, since SpeakType 2 uses a different kind. And if you would rather stay on the old app, SpeakType 1.3 remains available as a release.

So the migration is handled properly: the data carries across, the model does not, and the old version stays downloadable. That is a considerate handling of a version change, and the note that the model has to be downloaded again because the second version uses a different kind of model is the honest cost of it.

The troubleshooting entry is equally candid. SpeakType 2 is new, and Windows and Linux support is especially young, and the README asks you to open an issue describing what happened and which computer you are on.

The What's next list shows the same candour. Smarter cleanup, still private, an optional step that tidies up and formats what you said using an AI model on your computer. A SpeakType keyboard for iPhone and Android, with optional syncing. Words as you speak, instead of after you stop. And a signed Windows app. The roadmap file is said to have the rest, including what SpeakType will never do.

The codebase, and the Makefile as a picture of the project

The top-level listing shows a native macOS-first project with cross-platform packaging.

There is speaktype.xcodeproj/ and a speaktype/ directory for the app sources, plus speaktypeTests/ and speaktypeUITests/ for the unit and UI test targets, which is the standard Xcode layout. There is a desktop/ directory, which is where the cross-platform work lives, and dmg-assets/ for the disk image resources, and scripts/ for the release tooling.

The Makefile is the most revealing artefact, because a Makefile wrapping an Xcode project is a choice about workflow. The available commands are listed with help text, and the categories are development, testing, distribution, code quality and logging.

help:
	@echo "SpeakType - Available commands:"
	@echo ""
	@echo "Development:"
	@echo "  make setup         - Initial project setup"
	@echo "  make build         - Build the project (Debug)"
	@echo "  make run           - Run the application"
	@echo "  make run-dev       - Build and run SpeakType-Dev.app"
	@echo "  make clean         - Clean build artifacts"
	@echo "  make clean-dev     - 🧹 Clean ALL app data & permissions (fresh start)"
	@echo "  make xcode         - Open in Xcode"
	@echo "  make install       - Install SpeakType to /Applications"
	@echo "  make uninstall     - Fully uninstall (no rebuild)"
	@echo "  make reinstall     - Uninstall then install again"
	@echo ""

The distribution section is the one to read. There is create-release, described as bumping the version, building, signing and notarizing to dist/*.dmg, and deploy-release, which pushes the tag and uploads the DMG to the GitHub releases. There is also run-release to run the last release build locally, and package and dmg targets to create a ZIP package or a DMG installer, both unsigned.

So the Mac release path is a signed and notarised build, which is what Apple requires for distribution outside the App Store, and there is an unsigned path for local use. The notarisation step is the one that matters for other people installing the app, because an unnotarised build gets a Gatekeeper prompt that a user has to click through.

The quality section runs SwiftLint for linting and formatting, and there is a .swiftlint.yml at the root configuring it, along with an .editorconfig. The ci target reproduces the CI checks locally as a build plus unit tests plus lint, which is a good practice and saves a round trip through a pull request.

The test targets are split into unit tests and UI tests, and the clean-dev target is described as cleaning all app data and permissions for a fresh start. That target only makes sense for an app that stores a history, a dictionary and a downloaded model in the user's space, and it is a hint about how the app is architected: state lives on disk in a place the app can wipe.

The logging section has a logs target for viewing live logs, a logs-live alias for streaming them, and an errors target for filtering. A local app that runs a speech model in-process has real operational questions about what it did and why, and a logging story is part of a product rather than a debugging afterthought.

How to evaluate it, and the questions to ask first

There are four things to consider.

First, whether the model fits your machine and your languages. The Parakeet and Whisper choice, the 75 MB to 1.6 GB download, the 15 MB install, and the claim that a 35-second ramble transcribes in under two seconds, are all things to weigh against your hardware. If you are on an Intel Mac, Parakeet is out and the choice is made for you. If you dictate in a language outside Europe and the 24 Parakeet languages, Whisper at 99 languages is the route, and Whisper is the slower and larger of the two.

Second, the platform maturity. The README says it plainly: Windows and Linux support is especially young. The macOS app is the one that has a version 1 behind it, the one with the signed release path in the Makefile, and the one whose permissions are explained. On Windows you will get a SmartScreen prompt, and on Linux you will be installing an AppImage or a package that is not in your distribution's repository.

Third, what the offline guarantee means in practice. The claim is that nothing you say leaves your computer, that there is no account, and that nothing is collected. The two exceptions are the model download you trigger and a version check that can be turned off. For someone whose reason for choosing a dictation app is that they dictate confidential content, that is the property that matters, and it is worth confirming for yourself by watching the network once with the version check disabled.

Fourth, the roadmap. There is a signed Windows app coming, an iPhone and Android keyboard with optional syncing, smarter cleanup using a local AI model, and words appearing as you speak rather than after you stop. The last of those is the one that would change the character of the app, because a push-to-talk app that shows text as you speak feels like a different thing from one that waits for you to stop.

What you get is a young but unusually complete application, with a real offline story, a transparent model choice, and a licence that lets you read the code or reuse it. The cost is that the cross-platform story is behind the Mac one, and the model download is a genuine step that puts a hundred megabytes on your disk before the first word is transcribed.

Editorial conclusion

Adopt SpeakType if you dictate enough that a subscription and a server round trip are both costs you would rather not pay, and if you need a Mac, Windows or Linux build of a push-to-talk dictation tool that works with no internet connection. Do not adopt it expecting equal maturity across platforms, because the README says Windows and Linux support is especially young and the Windows build is unsigned until the signing work lands. Before you commit, check which model family fits your machine, since Parakeet is unavailable on Intel Macs and Whisper is the only route to the wider language set, plan for a one-time model download of up to 1.6 GB, and confirm the permissions model on macOS, where the app needs both microphone access and accessibility access to type into other applications.

Frequently asked questions

Official sources

1. karansinghgit/speaktype on GitHub
2. License: MIT
3. Project website
4. README
5. Releases