Human Typer

Human Typer is a lightweight desktop utility that types text character by character into the active field of another application. Its base speed, random timing variation, punctuation pauses, and optional self-corrected typing mistakes are configurable, producing a natural cadence.

It is built with Tauri 2, React 19, TypeScript, and Rust. Everything runs locally on your device: there is no server, account, telemetry, or permanent storage of your text.

Only use automation in applications and fields where you are authorized to do so. Press Esc to stop typing from any application.

Features

• Types every character individually instead of pasting the whole text.
• Imports the first worksheet of a local .xlsx or .csv file and fills the foreground spreadsheet cell by cell.
• Supports Unicode, accented characters, ñ, ¿, ¡, symbols, spaces, tabs, and line breaks.
• Includes predefined speeds and fine-grained adjustment from 15 to 350 ms.
• Adds random timing variation and subtle natural fluctuations.
• Supports optional pauses after . , ; : ? ! and line breaks.
• Can occasionally press a nearby letter, erase it, and immediately type the intended letter.
• Can lock onto the target window and pause automatically if focus moves elsewhere on macOS or Windows.
• Includes a bundled Chrome, Edge, and Firefox web companion for background typing in browser-based editors.
• Can play a completion chime and show a desktop notification when a run finishes.
• Provides a configurable countdown from 1 to 30 seconds.
• Displays status, character progress, and percentage.
• Pauses or resumes globally with F8 and cancels immediately with Esc.
• Includes equivalent controls inside the application.
• Supports light, dark, and system themes.
• Switches the desktop app and browser extension between English and Spanish.
• Saves preferences locally without persisting the text.
• Enforces safety limits of 250,000 characters and eight hours per run.

Download

Prebuilt installers are available on the GitHub Releases page:

• Windows 11, 64-bit: NSIS .exe installer.
• macOS, Apple Silicon: .dmg image.

Windows binaries are not code-signed, so SmartScreen may display a warning. The macOS release workflow always applies at least an ad-hoc signature so Gatekeeper does not misidentify the downloaded app as damaged. Without a Developer ID signature and notarization, macOS can still require the user to approve the first launch from Privacy & Security or by Control-clicking the app and selecting Open.

Screenshots

The screenshot directory is prepared at docs/screenshots. Final screenshots should be captured from signed macOS and Windows builds so they accurately show each platform's native window decoration.

Requirements

• Node.js 26 or newer. The repository pins 26.8.1 in .nvmrc.
• npm 12 or newer. The repository declares npm 12.0.2 in package.json.
• Rust 1.98 or newer. The repository pins 1.98.0 in rust-toolchain.toml.
• The Tauri 2 prerequisites for your operating system.

Linux additionally requires the WebKitGTK development libraries listed by Tauri.

Installation and development

npm install
npm run tauri dev

The first launch downloads and compiles the Rust dependencies, so it may take a few minutes.

Useful scripts

npm run dev           # Run the Vite frontend without the native typing engine
npm run typecheck     # Check strict TypeScript types
npm run lint          # Run ESLint
npm test              # Run frontend unit tests
npm run check         # Run typecheck, lint, and frontend tests
cargo test --manifest-path src-tauri/Cargo.toml

Building

npm run tauri build

Installers are generated under src-tauri/target/release/bundle/. Configure macOS signing and notarization and Windows code signing before distributing production builds.

The release workflow uses an ad-hoc macOS signature when Apple credentials are unavailable. For normal Gatekeeper approval without a manual exception, add all of these GitHub Actions secrets:

• APPLE_CERTIFICATE: base64-encoded Developer ID Application .p12 certificate.
• APPLE_CERTIFICATE_PASSWORD: password used to export the certificate.
• APPLE_ID: Apple Developer account email.
• APPLE_PASSWORD: app-specific password for that Apple ID.
• APPLE_TEAM_ID: Apple Developer team identifier.

The workflow rejects a partial configuration, imports the Developer ID certificate, notarizes the app through Tauri, and verifies the DMG, bundle signature, Gatekeeper assessment, and stapled notarization ticket. If none of the five secrets exist, it verifies the ad-hoc signature instead.

In CI or a macOS session that cannot automate Finder, run CI=true npm run tauri build. Tauri will omit the DMG's visual Finder customization while still producing a valid installer.

Usage

1. Paste or enter content in Your text.
2. Select a speed preset or adjust the delay slider in milliseconds.
3. Configure timing variation, the countdown, punctuation pauses, and optional typing mistakes.
4. Optionally enable Protect target window to prevent typing into another window if focus changes.
5. Select Start.
6. Focus the target text field during the countdown. With target protection enabled, the foreground window at the end of the countdown becomes the target.
7. Press F8 to pause or resume, or Esc to cancel. After an automatic focus-loss pause, return to the target window before pressing F8.

Editing and settings are locked while a run is active so the displayed progress always matches the text being typed.

Formatting and importing documents

The text editor supports normal paragraphs, six heading levels, bold, italic, underline, and strikethrough. Select text to apply emphasis and use the paragraph style selector for headings. Subtitle uses Heading 2. Customize Heading 1–6 in Google Docs to apply your document's own fonts, sizes, and spacing.

Enable Apply formatting in Google Docs before starting a formatted run. The native engine sends Google's formatting shortcuts at each style change while continuing to type character by character. Keep Google Docs in the foreground for desktop typing. Leave the option disabled to type plain text into other apps. The generated console script also includes formatting when enabled; browser editors may ignore synthetic formatting shortcuts, so use desktop typing if this happens. The standalone browser extension uses its own plain-text field.

Choose Attach DOCX / TXT to replace the editor content with a local file. Word .docx files preserve headings and supported emphasis; .txt files preserve paragraphs. Old binary .doc files must first be saved as .docx in Word or Google Docs. For a Google Doc, download it as Microsoft Word (.docx) before attaching. Files are processed locally, with limits of 20 MB and 250,000 characters. Tables and lists become text. Images, page layout, fonts, and other unsupported styles are omitted; check the editor before starting transcription. Import errors leave the previous editor content intact. Neither the document nor its formatting is stored permanently.

Filling a spreadsheet

1. Open a blank workbook in Excel (or a compatible spreadsheet application) and select the starting cell, normally A1.
2. In Human Typer, choose XLSX / CSV in the Spreadsheet section. The first worksheet in an XLSX file is used.
3. Select Fill sheet, then return to the workbook during the countdown. Keep it in the foreground.

The spreadsheet mode writes each value as native keyboard input, uses Tab to advance through columns, and returns to the first column before moving to the next row. Blank cells are preserved. It reads files locally and limits imports to 100,000 cells and 250,000 characters. Embedded line breaks are converted to spaces because they would otherwise move Excel's selection to a different row.

Shortcuts and safety

Action	Global shortcut	In-app alternative
Pause / resume	F8	Pause / Resume button
Cancel	Esc	Cancel button

Shortcuts are registered when the application starts. If another program has already reserved one, Human Typer displays a warning and keeps the in-app buttons available. The engine checks for cancellation every 25 ms, including during longer pauses. A run also stops on the first input error, after eight hours, or when the process closes.

Esc intentionally acts as a global shortcut while Human Typer is open. Close Human Typer when it is not in use if this conflicts with another utility.

macOS permissions

macOS requires permission to generate keyboard events:

1. Open System Settings.
2. Go to Privacy & Security → Accessibility.
3. Enable Human Typer.
4. Quit and reopen the application if it was already running.

During development, the list may show Terminal, iTerm, your IDE, or the debug binary instead of Human Typer. Enable the process that runs npm run tauri dev. The application checks this permission before typing and displays instructions when it is missing.

If Human Typer appears enabled but the app still reports that permission is missing, quit it completely and reopen the same .app that you authorized. Unsigned development builds can receive a new code identity after recompilation; in that case, remove the old Human Typer entry with the − button, add the exact current .app with +, enable it, and reopen the app. Prefer copying the latest build to /Applications and always launching that copy.

Compatibility

System	Status	Notes
macOS 12+	Primary target	Requires Accessibility permission. Distributed binaries should be signed.
Windows 11	Primary target	Elevated applications may reject events from a non-elevated process.
Linux X11	Supported	Requires a graphical session and the Tauri system dependencies.
Linux Wayland	Experimental	Input injection and global shortcuts depend on compositor policy.

Protected fields, elevated applications, games, and remote desktop software may reject simulated input.

Architecture

src/
├── components/            # Small UI components and controls
├── hooks/                 # Preferences, theme, and the Tauri bridge
├── lib/                   # Pure logic and tests
├── types/                 # TypeScript contracts
├── App.tsx
└── main.tsx
src-tauri/
├── src/
│   ├── lib.rs             # Commands, shared state, and global shortcuts
│   ├── platform.rs        # Platform-specific permission checks
│   └── typing_engine.rs   # Countdown, timing, and Unicode input
├── capabilities/          # Minimal Tauri permissions
├── Cargo.toml
└── tauri.conf.json

React invokes Tauri commands and listens for state events. A native worker owns the countdown and typing loop, while enigo emits each character separately. Synchronized worker state lets global shortcuts pause or cancel without relying on WebView focus.

Persistence and privacy

Only the speed, variation, countdown, theme, punctuation, typing-mistake, and target-window protection preferences are stored in localStorage. Text exists only in memory and is discarded when the application closes or reloads.

• Text is never sent over the network.
• There are no analytics, crash reporting services, or user accounts.
• Text is never written to logs.
• Tauri's content security policy restricts external resources.

Testing

Pure frontend logic tests cover Unicode counting, progress, persistence, duration estimates, document formatting ranges, sanitized imports, and an actual DOCX fixture. Rust tests cover delay components, the minimum delay, punctuation, and the main control-state transitions. Real keystrokes are validated manually on each platform because automating them would create fragile tests and could type into the wrong application.

npm run check
cargo test --manifest-path src-tauri/Cargo.toml

License

Copyright © 2026 AugustoOM.

Human Typer is free software licensed under the GNU General Public License version 3, identified by the SPDX expression GPL-3.0-only. You may use, study, modify, and redistribute it under the terms of that license. Distributed modified versions must preserve the same freedoms and provide the corresponding source as required by the GPL.