Text injection

Text injection is the last step of every dictation — the moment your finished words land where your cursor is. This page explains how InkSpoke gets text into your app, why it types into some apps but pastes into others, and the safety nets (clipboard restore, mid-typing abort, copy-mode fallback) that keep your words from ever getting lost or clobbering something.

The good news: for almost everyone, this just works. InkSpoke's default Auto mode picks the right delivery method for whatever app you're in. You can read this whole page as "how the magic works," or jump to the settings if you have a specific app that's misbehaving.

Where injection fits

Injection is the final stage of the dictation loop: after your speech is transcribed and (optionally) refined, InkSpoke delivers the result to the app that had focus when you started.

Because your cursor never leaves the target app — the listening overlay is careful not to steal focus — the text goes exactly where you were writing.

The three injection modes

InkSpoke has two fundamentally different ways to deliver text, plus a smart mode that chooses between them per app:

Mode	How it works	Best for
Auto (default)	Picks per app: terminals and code editors are typed into with SendKeys; everything else gets clipboard-paste.	Almost everyone — leave it here.
ClipboardPaste	Always copies the text and fires the paste shortcut. The fastest way to drop in long text.	Long passages into ordinary apps (docs, email, chat).
SendKeys	Types the text one character at a time, as if you were typing it yourself.	Remote sessions, apps that reject synthetic Unicode paste, and secret/password fields (the text never touches your clipboard).

You set this with the TextInjectionMode setting. The trade-off is speed vs. compatibility: clipboard-paste is instant but some apps mangle or block pasted text, while per-character SendKeys is universally accepted but visibly slower on long text.

Why type into terminals instead of pasting?

Two reasons. Per-character typing leaves your clipboard untouched, and it types reliably into shells that drop or garble spaces from a bulk paste. Code editors get the same treatment so autocomplete and paste-interception don't rewrite your text. That's exactly what Auto does for you automatically.

How Auto decides

In Auto mode, InkSpoke looks at the app that has focus and routes accordingly:

Terminal and IDE detection is what drives the "yes" branch. InkSpoke recognizes a broad list of shells and editors — for example Windows Terminal, Command Prompt, PowerShell / pwsh, gnome-terminal, konsole, xterm, Hyper, macOS Terminal, iTerm2, Alacritty, kitty, WezTerm, and Visual Studio Code (including Insiders). When one of these is focused, Auto uses SendKeys; for anything else it uses clipboard-paste.

You can turn each detector off independently:

Setting	Default	What it does
TerminalModeEnabled	true	Lets Auto detect terminals and type into them with SendKeys.
IdeIntegrationEnabled	true	Lets Auto detect code editors / IDEs and type into them with SendKeys.

Power users

If you have one stubborn app, you rarely need to change the global mode. Prefer to keep Auto and only flip TerminalModeEnabled / IdeIntegrationEnabled if Auto is guessing wrong. Reach for a global ClipboardPaste or SendKeys only when you want the same behavior everywhere.

Remote Desktop (RDP) mode

Remote desktop sessions are a special case: the ordinary paste and synthetic-key events don't survive the RDP keyboard pipeline. InkSpoke handles this for you — when it detects that the focused app is a Microsoft Remote Desktop client, it automatically switches to injection primitives that work through the remote connection.

• On Windows, an RDP target uses clipboard-paste, because Ctrl + V is native inside the remote window.
• On macOS, InkSpoke routes through System Events — typing character by character into the remote window (or a clipboard-paste path), with configurable newline handling.

This is fully automatic; there's no toggle to switch on. RDP mode also skips the "can this field receive text?" check, because the remote window is opaque to the operating system's accessibility layer — InkSpoke can't inspect a field that lives on another machine.

RDP newline modes

Different remote apps expect different keystrokes for a line break. The RdpNewlineMode setting controls how newlines in your dictated text are delivered inside the remote session:

Newline mode	What it sends	When to use
Text	A literal newline character	Terminals and editors inside the remote session.
ReturnKey	The Return key	Apps that treat Return as a line break.
ShiftReturn (default)	Shift + Return — a near-universal soft line break	The safe default that works in most apps.
CtrlReturn	Ctrl + Return	Apps where that inserts a break.
CmdReturn	⌘ + Return (macOS only)	macOS remote sessions that expect it. On Windows this falls back to a plain Return.

If multi-line text lands wrong in a remote app

Your remote app is deciding what Return means — not InkSpoke. If line breaks come out as "send message" or vanish, switch RdpNewlineMode. Start from the default ShiftReturn; try Text for terminals, or ReturnKey for plain editors.

Atomic clipboard restore

Whenever InkSpoke pastes (Auto's clipboard path, or ClipboardPaste mode), it borrows your clipboard for a fraction of a second — and then gives it back exactly as it was. The steps:

1. Back up whatever is currently on your clipboard. On Windows this preserves every format — images, files, rich text, HTML, PNG — not just plain text.
2. Place the dictated text on the clipboard, flagged so it's excluded from Windows Clipboard History and Cloud Clipboard (your dictations don't pollute your paste history or sync to other machines).
3. Paste it into your app.
4. Restore your original clipboard — but only if the dictated text is still on the clipboard.

That last condition is the important one:

Your manual copy is never clobbered

If you happen to press copy during the brief paste window, InkSpoke notices that the clipboard no longer holds its dictated text and leaves your copy alone — it won't overwrite what you just grabbed. Concurrent dictations are serialized too, so two pastes can never trample each other's backup.

If you'd rather your dictations never touch the clipboard at all — for example, dictating into a password field — use SendKeys mode, which types directly and skips the clipboard entirely.

Stopping an injection mid-way

Per-character typing (terminals, code editors, and remote sessions) is deliberate and visible, which means you can change your mind while it's happening. Press Esc, or say your voice cancel word ("stop"), and InkSpoke halts the remaining keystrokes immediately.

• The characters already typed stay — nothing is undone.
• The dictation still completes: your transcript and recording are saved to history as usual.
• A balloon reports exactly how far it got — "Typing stopped — X of Y characters typed" — with an error cue.
• The post-dictation quick-confirm / follow-up prompt is skipped for an aborted run.

This only applies to per-character injection; a clipboard-paste is instantaneous, so there's nothing to interrupt.

Smart Space Injection

Smart Space Injection is a small convenience that's off by default. When enabled (SmartSpaceInjectionEnabled), InkSpoke prepends a single space to your text whenever your cursor sits directly after a non-space character — so a new dictation doesn't jam up against the word you'd already typed.

It's off by default because the "right" spacing depends heavily on where you dictate, and an automatic space is sometimes unwanted. Turn it on if you frequently continue a sentence you started typing.

When there's nowhere to type: copy-mode fallback

Occasionally, by the time your text is ready, the target can't accept it — you clicked onto the desktop, a button, or a window with no text field. Rather than lose your words, the listening overlay switches to copy mode: it shows the full transcript with a Copy button and the label No text field detected.

┌────────────────────────────────────────────────────────────┐
│  ⚠  No text field detected                                 │
├────────────────────────────────────────────────────────────┤
│  "Here's the transcript we couldn't inject anywhere —      │
│   it's safe, just copy it and paste it yourself."          │
│                                              [  Copy  ]    │
└────────────────────────────────────────────────────────────┘

Click Copy (you'll see a Copied! confirmation) and paste it wherever you like. Field detection uses the operating system's accessibility layer — UI Automation on Windows, Accessibility on macOS — which is why copy-mode is skipped for Remote Desktop targets: the remote field can't be introspected, so InkSpoke goes ahead and injects.

Settings

All of these live in the desktop app's settings:

Setting	Default	What it does
TextInjectionMode	Auto	How text is delivered: Auto, ClipboardPaste, or SendKeys.
TerminalModeEnabled	true	Let Auto detect terminals and type into them with SendKeys.
IdeIntegrationEnabled	true	Let Auto detect code editors / IDEs and type into them with SendKeys.
SmartSpaceInjectionEnabled	false	Prepend a space when your cursor sits right after a non-space character.
RdpNewlineMode	ShiftReturn	How newlines are sent inside a Remote Desktop session.

Platform notes

The modes above mean the same thing everywhere, but the low-level mechanics differ per OS:

	Windows	macOS	Linux
ClipboardPaste	Win32 clipboard + Ctrl + V	Clipboard + ⌘ + V	Clipboard + paste
SendKeys	Per-character typing, paced to keep word-boundary spaces intact in shells	Unicode typed in small chunks	Native key simulation, with an xdotool fallback
Remote Desktop	Uses clipboard-paste (native Ctrl + V)	Per-character via System Events, with the newline modes above	—
Clipboard restore	Full-format backup, excluded from Clipboard History	Restores shortly after paste	Handled via the system clipboard

A couple of things worth remembering:

• RDP auto-detection applies to the Microsoft Remote Desktop clients on Windows and macOS. The CmdReturn newline mode is macOS-only and falls back to a plain Return on Windows.
• On macOS, InkSpoke normalizes unusual Unicode space and line-separator characters before injecting into a remote session, so odd whitespace doesn't leak through.

Next steps

• Push-to-talk basics — the press-speak-press loop that injection completes.
• The listening overlay — the HUD, including copy-mode fallback in full.
• General settings and hotkeys — where the injection mode, RDP newline, and detection toggles live.
• History and diagnostics — every injected dictation is saved here, even aborted ones.