KeyEcho: typing sounds from a Rust core, not a browser runtime

What the app actually does

KeyEcho is described as a tiny open-source desktop app that plays pleasant keyboard sounds while you type, built with Tauri, Rust and Solid, and designed to stay local, fast and easy to audit. The homepage is keyecho.app, the builds come from the GitHub releases page, and there is a technical write-up linked alongside a guide for custom sounds. The reasons the README gives are five and they are specific. Local keyboard event handling for low-latency sound playback. Cross-platform builds for Windows, macOS and Linux. A small native desktop footprint instead of a bundled browser runtime. No account, no cloud sync and no typing-content analytics. And custom sound packs for people who want to tune the typing feel. The third of those is the architectural commitment that everything else follows from, since a Tauri app renders its interface with a system web view instead of shipping Chromium.

The permission question, answered head on

Any app that plays a sound on every keystroke has to see every keystroke, which is the same capability a keylogger uses, and the README addresses it in the install section rather than burying it. KeyEcho needs the operating system permissions required for global keyboard event listening. It maps key events to local sound playback, and it does not upload typed content. That distinction is the one that matters for anyone deciding whether to install it: the process does observe the keyboard globally, and what it does with the observation is play a sound and nothing else. There is no account to sign up for, so there is no server holding anything, and the privacy claim is structural rather than a promise, since there is no component that could receive the data. The auditability claim in the introduction follows from the same place, because a small Rust codebase with no network path is something you can read.

Tauri, Rust and Solid, and what each one is doing

The package metadata shows a two-language project with a clear split. The Rust half lives in src-tauri and holds the audio path, which is what the README means by fast. The frontend is Solid, with solid-js at 1.9.13 and vite-plugin-solid for the build, and the Tauri packages are the API at 2.11.1 and the CLI at 2.11.3. There is also a deep-link plugin and valibot for schema validation, which suggests the settings the user picks are validated rather than trusted. The build configuration is unocss for the utility styles and TypeScript 6 for the frontend, with tsconfig.json and vite.config.ts at the root. The dev dependencies are unusually complete for a small app: ESLint 10 with the antfu config, Prettier, lint-staged with a separate config file, commitlint with the conventional config, simple-git-hooks, and tsx for running the TypeScript scripts. The scripts are named the way a Tauri project usually names them, with tauri as the underlying command and dev and build wrapping it.

The script names tell you how the project is tested

The scripts in the package manifest are the clearest description of the project's engineering. There is web:dev for the Vite frontend alone and web:build, which type-checks with tsc --noEmit and then builds, so a type error fails the build. The Rust tests run through cargo test against the src-tauri manifest, and web:test runs vitest in a node environment rather than a browser one, which is faster for logic that does not need a DOM. The aggregate test script runs the Rust tests, then the web tests, then the frontend build, which means a single command covers the three things that can break. Two other scripts are worth noting. The bench:audio script runs a cargo test in release mode with the reference_timing test marked ignored and output captured, which is how the audio timing is measured, and the performance notes in the docs are the human-readable version of that number. There is also an updater script and a release-notes script, both run through tsx.

Running it from source in three commands

The prerequisites are Rust and Cargo, and pnpm. The package manager is pinned to [email protected] in the package manifest, and a preinstall script runs npx only-allow pnpm, so the install will refuse to proceed under npm or yarn. The local run is a clone, an install and a dev command.

git clone [email protected]:ZacharyL2/KeyEcho.git
cd KeyEcho
pnpm install
pnpm dev

The useful commands list gives the rest of the workflow.

pnpm web:dev       # Vite frontend only
pnpm web:build     # Type-check and build the frontend
pnpm test:rust     # Rust tests
pnpm test          # Rust tests, web tests, and frontend build
pnpm build         # Tauri production build

There is a pnpm-workspace.yaml at the root and a pnpm-lock.yaml, so the frontend and the Rust side are managed as one workspace with one lockfile.

The sound packs are where the money is, and the app is not

The commercial structure is stated in plain terms. KeyEcho itself stays free and open source. Optional Crafted Packs are one-time purchases, not a subscription, and they are not required to use the app. Each Crafted Pack is $3.99, and there is a bundle called All Sounds Forever at $9.99 once that includes every current and future official Crafted Pack. You can browse and try them at keyecho.app/packs. Free packs download straight into the app, while paid packs unlock with a license key. There is also a custom sounds guide covering recording, processing and adding your own packs, which is the more interesting half for anyone who wants the app rather than the sounds, since it means the pack format is documented rather than opaque. The licensing detail to note is that the app is AGPL-3.0, so a modified build you distribute carries copyleft obligations.

Where KeyEcho is the wrong choice

Four limits apply. It requires a global keyboard listener permission on your operating system, and depending on how your organisation manages that, you may simply not be able to grant it, which is the case where no amount of the app's privacy design helps. It is a typing accessory, so on a shared or recorded machine it adds a new sound channel rather than removing one, which matters for a call you join from the same laptop. It only builds for the platforms the releases page lists, which are Windows x64 and ARM64, macOS on Intel and Apple Silicon, and Linux x64 and ARM64, so an unusual architecture is out of scope. And the sound content is where the money is: the app is open source but the official packs are paid, so a user who wants a particular keyboard sound either buys it or records their own using the guide, which is more work than most people want for a novelty app.

Editorial conclusion

Use KeyEcho if you want typing sounds with a native footprint and you are willing to grant the operating system the global keyboard listening permission it needs, since that permission is the whole mechanism and the app answers for it directly. Do not install it on a machine where you cannot accept a process reading every key event, and note that the AGPL-3.0 licence applies if you plan to redistribute a modified build. Verify first which platform build you download, that your operating system prompt is the expected one, and that the sound pack situation matches your intent, because the app is free and open source while the optional Crafted Packs are one-time purchases at $3.99 each.

Frequently asked questions

Official sources

1. License: AGPL-3.0
2. Project website
3. README
4. Releases
5. ZacharyL2/KeyEcho on GitHub