Text Expansion and Clipboard on Mac: Snippets, History, and AI Transforms

What is text-expansion and clipboard tooling on Mac?

Text-expansion and clipboard tooling on Mac is a category of background apps that put text into fields faster. A clipboard manager recalls what you copied, a text expander turns a short trigger into a longer phrase, and dictation turns speech into typed text. Newer tools add AI transforms that rewrite text you've selected.

You already do all three of these things by hand. You copy a URL, lose it behind ten more copies, and go hunting for it again. You retype your email signature for the four-hundredth time. You draft a message, decide the tone is wrong, and rewrite it word by word. Each of those is a tiny tax you pay all day, and each has a tool that removes it.

Here's what the tools actually do. A clipboard manager keeps a history of everything you copy so you can paste something from an hour ago, not just the last thing. A text expander watches what you type and swaps a trigger like ;addr for your full mailing address the instant you type it. Dictation converts your voice to text in whatever field has focus. On Apple Silicon, the interesting part is that all of this can run on-device. The clipboard manager indexes locally, the expander injects locally, and modern dictation runs a speech model on the Neural Engine instead of shipping your audio to a server. The new layer on top is AI-on-selection. You highlight a paragraph, trigger a transform, and a language model rewrites it in place.

The reason these four live in one category is that they all hook the same two macOS subsystems. Expansion and clipboard managers read what's in a text field and write back to it through the Accessibility APIs, and they watch your keystrokes and hotkeys through CGEvent taps. That's the same plumbing whether the payload is a fixed string, a recalled clipboard item, a dictated sentence, or a model's rewrite. A tool that already holds the Accessibility permission to expand ;addr is one step away from being able to read your selection and hand it to a model. The historical accident is that these grew up as separate apps from separate developers, so you ended up running three of them. The technical reality is that they're one capability wearing three hats.

The state of the art (May 2026)

Here's the shift worth understanding. Standalone text utilities are being replaced by integrated systems. A clipboard manager that can't transform what it holds is just a list. A snippet tool that doesn't know your AI models is just a string-replacer. The value is no longer the snippet itself. It's that text expansion, clipboard history, dictation, and AI transforms live in one local system that shares your models, your preferences, and your selection, and that knows when not to fire.

That last part is the part most tools get wrong. A text tool that fires when it shouldn't is worse than no tool. It expands ;fix inside the word ;fixed, or it dumps your 1Password autofill into a clipboard history you later screen-share. The frontier isn't just adding AI. It's adding AI that refuses to run in a password field, won't match a trigger mid-word, and can't collide with your dictation hotkey. Capability without restraint is a liability in a tool that touches every text field you use.

Here's the landscape, named honestly.

Apple Writing Tools shipped as part of Apple Intelligence and is the biggest move in the category. It's built into recent macOS, free, zero-install, and system-wide. Select text in almost any app and you get a fixed set of rewrites like Proofread, Rewrite, Friendly, Professional, Concise, and Summarize. For its presets it's frictionless, and that bar is high. The catch is the fixed set. You can't define your own prompts or triggers, you can't chain transforms, you can't pick the model, and some requests route to Apple's Private Cloud Compute, which means they leave the device.

Raycast is a full launcher with snippets, clipboard history, and window management. Its free tier covers a lot. Raycast Pro (around $8/month as of May 2026) adds AI features that run in Raycast's cloud. If you want a launcher, Raycast is excellent and ToolPiper is not competing for that job. The wedge is narrow and specific. Raycast's AI is a cloud subscription, where the local-text-AI approach is a free download that runs on your machine. Alfred (around $40 Powerpack, one-time) and LaunchBar (around $29, one-time) are launchers in the same family with snippet and clipboard features, but without AI transforms on selection.

TextExpander is the long-standing name in expansion. As of May 2026 it's a subscription at roughly $3.33/month billed annually (about $40/year). Its real strengths are cloud sync, shared team libraries, and genuine cross-platform reach across Mac, Windows, iOS, and web. If a team needs one snippet library on every platform, that's a real reason to pay. The trade-off is that the expansion is static. There's no AI transform, and you're paying a recurring fee for text replacement.

Maccy is a well-built, single-purpose clipboard manager that a lot of people love. It's open source, and the convenient prebuilt version is a paid Mac App Store app (around $10), though you can compile the source for free. It is clipboard history only. No expansion, no AI, no OCR, no categorization. That focus is a feature for some people. It also means an open-source tool can still cost money, and it doesn't touch the expansion or transform side of the workflow at all.

Espanso is free, open source, and cross-platform across macOS, Windows, and Linux. You configure it in YAML files, and it's scriptable in ways a GUI tool isn't. For people who like config-as-code, that's the appeal. The cost is the YAML itself instead of a GUI, no AI transforms, and no bundled clipboard or dictation.

Keyboard Maestro (around $36, one-time) sits at the powerful end. It can drive almost anything on macOS through a visual macro editor, including clipboard manipulation and text insertion. It's the deepest automation tool in this list. The cost is the learning curve and the hand-building. There's no AI interpretation of intent and no natural-language layer.

So where's the actual frontier? AI-on-selection is the current edge of this category, and three serious approaches exist, namely Apple Writing Tools, Raycast AI, and ToolPiper action snippets. Apple's is built-in and fixed. Raycast's is a cloud subscription. ToolPiper's is user-defined, chainable, and runs on your chosen local model. They're solving the same problem from different ends, and naming all three is the honest way to describe May 2026.

The integration thesis shows up most clearly when you watch a single task cross the seams. You dictate a rough note by voice, the words land in your editor, you select the messy paragraph and tap a transform to clean it up, then you copy the result and your clipboard history files it as text with the source app attached. In a three-app setup, each of those steps lives in a different process with its own permissions, its own hotkeys, and its own idea of what your current selection is. The dictation app doesn't know the expander exists. The clipboard manager has no concept of the transform you just ran. When they're one system, the selection is shared, the model is shared, and the hotkeys are coordinated so two of them can't grab the same keypress. The seams are where standalone tools leak, and removing the seams is the actual product, not any single feature.

There's a second reason integration matters, and it's about the model. A snippet tool bolted onto a cloud API has to ship your text somewhere to transform it, and it has no say in which model runs or what it costs per call. A system that owns its inference can try Apple's on-device model first for a quick correction, fall back to a heavier local model for a long rewrite, and never touch the network. The snippet stops being a string and becomes a thin trigger over whatever local capability you've got loaded. That's the difference between a feature and a layer.

What's coming

The category is moving fast, so it's worth separating what we're building from what the industry might do.

Our roadmap

Agentic-chat snippet firing (in beta now). Today an action snippet runs as a deterministic single-LLM-call transform on selected text. The next step lets a chat agent fire a snippet as a tool call, so you can ask in conversation to apply a transform and the model picks the right one. This rides the agentic-chat work currently in beta. It is not a settled capability yet, and we won't describe it as one.

Semantic snippet dispatch (planned). Right now you trigger a snippet by typing its exact delimiter and abbreviation. Semantic dispatch would match a paraphrase to the right snippet through embeddings, so a near-miss phrasing still resolves. This is planned, not shipped.

App-aware snippet suppression (announced). Clipboard capture already skips password managers like 1Password and Keychain. We're extending that idea to snippet triggers, so expansion can be suppressed per-app. To be precise about today, this exists for clipboard capture, not yet for snippet triggers.

Custom hotkey mapping (in development). Push-to-talk dictation is on the Right Option key and action snippets fire on the Right Command tap. Configurable bindings are in development so you can reassign them.

Industry horizon

Apple Intelligence expansion (rumored). Apple is widely expected to extend Writing Tools and on-device language features at its next developer conference. If Apple opens custom prompts or third-party model selection in Writing Tools, the AI-on-selection landscape shifts. As of May 2026 this is rumored, not confirmed, and we're tracking it.

How does ToolPiper handle text and clipboard today?

ToolPiper is a free macOS menu bar app that runs clipboard history, typed text snippets, AI action snippets, and push-to-talk dictation as one local system. The clipboard manager, expander, and transforms share the same models and preferences, and the action pipeline refuses secure text fields and won't match a trigger mid-word.

Each piece works on its own, and they share the same machinery underneath. Here's what ships right now.

Clipboard manager

ToolPiper keeps a browsable clipboard history, 200 items by default and configurable from 50 to 2,000. Fuzzy search runs across the text, any OCR-extracted text, the source URL, and the source app. Items auto-categorize into eight types, namely text, URL, email, code, JSON, file path, color, and number. Copy a screenshot and Apple Vision OCRs it so the text inside becomes searchable. Source tracking records which app you copied from, including the browser-tab URL for Safari, Chrome, Firefox, Arc, Brave, Edge, and Vivaldi. You can pin items, and the history persists across launches. Concealed, password, one-time-password, and transient pasteboard items are skipped, and 1Password, Keychain, LastPass, and Dashlane are on the capture ignore list by default, so your autofills don't land in history.

Ready to try it? Set up the clipboard manager - the all-in-one overview, working the moment you install.

Text snippets

Type a delimiter plus an abbreviation and ToolPiper expands it, with longest-trigger-first matching so overlapping triggers resolve to the most specific one. Eleven dynamic-value utilities resolve at expand time, including ;today for the long date, ;date for the short date, ;now, ;iso, ;timestamp, ;name, ;myemail, ;host, and ;app for the frontmost app. Drop a %| marker to place the cursor after expansion. Case-sensitivity has three modes (sensitive, ignore, adapt), and expand-when context rules control where a trigger is allowed to fire. If you're switching from another tool, import from TextExpander (.textexpander), Raycast (JSON), or CSV.

Ready to try it? Set up local text expansion - static and dynamic snippets, no subscription.

Action snippets (AI-on-selection)

Select text, tap the Right Command key (press and release under 250ms), and the selected region is replaced by an LLM transform. ToolPiper tries Apple's on-device model first through the Foundation Models framework, then falls back to a local LLM over loopback for longer or rejected inputs. Twelve transforms ship built in. They are ;fix, ;formal, ;casual, ;concise, ;expand, ;simplify, ;bullets, ;summary, ;tldr, ;active, ;email, and ;rewrite. You can chain them, so ;fix ;formal runs in document order, up to four stages, and aborts on empty output while preserving your selection. The pipeline refuses an empty target, an empty result, or any target over 16,384 characters. It never reads the clipboard - your selection is the only input.

The part that matters for trust is restraint. Selection capture probes the focused element's accessibility role and refuses secure and password text fields, failing closed if accessibility is denied or times out at 250ms. Trigger matching is whitespace and punctuation flanked, so ;fix never fires inside ;fixed. Push-to-talk, voice chat, and snippet expansion are interlocked so they can't collide. Voice dispatch tiers 1 and 2 (saying "use the fix snippet" or a literal trigger phrase) are deterministic single-LLM-call paths and are solid today.

Ready to try it? Set up AI action snippets - twelve transforms out of the box, chainable, on your local model.

What people actually do with this

The clearest way to understand the integrated approach is to watch where each piece earns its keep in a real day. Here are a few that come up constantly.

Fix a client email without it leaving your Mac. You drafted a reply and the tone is wrong. Select it, tap Right Command after ;formal, and a local model rewrites it professionally. No copy-paste into a chat window, no client correspondence sitting in a cloud provider's logs. If the first pass is too stiff, chain ;formal ;concise and it runs both stages in order on the same selection.

If you want the deeper walkthrough of the AI transforms, the spoke on AI text snippets covers the twelve built-ins and how to define your own.

Recall the thing you copied two hours ago. You grabbed a URL, an error message, and a code block from three different browser tabs this morning. Open the clipboard history, search any fragment, and ToolPiper shows you what you copied, when, from which app, and which tab. Source tracking captures the browser-tab URL for the seven major browsers, so "that thing from that article" becomes a search instead of a hunt.

Talk instead of type when your hands are busy. Hold Right Option, speak, release, and the transcribed text appears in whatever field has focus, at about 140ms end-to-end. It's the same on-device Parakeet engine described in the local voice transcription spoke, and because it runs on the Neural Engine, your audio never leaves the Mac. Useful for notes during a call, for RSI, or anywhere typing is disruptive.

Stop retyping the boilerplate. Static and dynamic snippets handle the text you type the same way every week. ;sig for your signature, ;today for a formatted date in a filename, ;myemail for your license email in a form. The local text expansion spoke goes through case-sensitivity modes and expand-when rules in detail.

Which models and hardware does this use?

ToolPiper's text and clipboard features use three local models. Apple's on-device model handles the first hop of short action-snippet transforms, a local LLM via llama.cpp handles longer transforms and fallback, and Parakeet TDT V3 (FluidAudio) handles push-to-talk dictation and voice dispatch.

The models table below has the details. The short version is that action snippets try Apple's on-device model first because it's fast and free for short rewrites, and they hand off to a local LLM through ToolPiper's loopback when the input is longer or Apple's model declines it. Dictation and voice-triggered snippets run on Parakeet, FluidAudio's speech-to-text model, which clocks roughly 210x realtime on the Neural Engine and about 140ms end-to-end from key release to inserted text. Everything here runs on Apple Silicon. None of it requires a cloud account for the text features to work.

The two-hop design for action snippets is deliberate. Apple's on-device model is fast and already resident, so for a short correction it returns before you'd notice. But it has limits on input length and will decline some requests, and a long rewrite or a chained multi-stage transform benefits from a heavier model. Rather than force one model to do both jobs badly, the pipeline routes short work to Apple's model and hands the rest to a local LLM you choose, loaded through ToolPiper's loopback. A 3B model handles most transforms at roughly 40 tokens per second on Apple Silicon. An 8B model is slower at around 25 tokens per second but sharper on ambiguous or longer text. You pick the trade-off.

For the dictation and voice-trigger path, there's only one model and it stays warm. Parakeet runs as a keep-warm backend so there's no cold-start penalty on the first utterance of the day, which is the difference between dictation that feels instant and dictation you have to wait for. That keep-warm behavior is why the 140ms figure holds in practice and not just on a fresh benchmark.

How does this compare to standalone tools?

Standalone tools each win one job: TextExpander leads on cross-platform sync and team libraries, Maccy is a clean single-purpose clipboard manager, Raycast is a full launcher, Espanso offers config-as-code across three operating systems, and Apple Writing Tools is free and built in for fixed presets. ToolPiper's wedge is integration: one local system covers expansion, clipboard history, dictation, and user-defined AI transforms on selection together, with image OCR and seven-browser source tracking that the single-purpose tools don't attempt.

The honest landscape table below puts ToolPiper next to TextExpander, Maccy, Raycast, Espanso, and Apple Writing Tools across the dimensions that actually differ. A few notes so the table reads fairly. Raycast has clipboard history and snippets, so those cells say yes. Apple Writing Tools has no text expansion, so that cell says no. Maccy has no AI transform, so that cell says no. ToolPiper's chat tool-call path is in beta, so it's marked that way rather than as a flat yes. The point of the table isn't to win every row. It's to show where each tool is strong and where the integrated-local approach has its wedge.

Reading down the columns, the honest summary goes like this. If you need one snippet library synced across Mac, Windows, iOS, and web, or shared across a team, TextExpander is built for exactly that and ToolPiper isn't, because the text features are local-only. If all you want is a fast, single-purpose clipboard manager and nothing else, Maccy is a clean, well-liked choice, and the fact that it's open source means you can read every line. If you live in a launcher, Raycast does jobs ToolPiper doesn't attempt, and its free tier covers snippets and clipboard. If you want config-as-code across three operating systems, Espanso's YAML is a genuine strength. And if your transforms only ever need Apple's presets, Writing Tools is free, built in, and already on your Mac.

The integrated-local approach earns its place in the cells where those tools stop. AI transforms on selection that you define, chain, and run on your own model. Image OCR that makes copied screenshots searchable. Source-tab tracking across seven browsers. On-device dictation at about 140ms. And all of it on a free download with no recurring fee for the text features. The wedge isn't "better at everything." It's that one local system covers expansion, history, dictation, and transforms together, which is the thing three separate tools structurally can't do.

Start here

The spoke directory below is the instructional hub. Each link goes deep on one piece. Some set up expansion, some walk through switching off a tool you're already paying for, and one wires up the clipboard manager. If you're coming from a subscription expander or a single-purpose clipboard tool, the switching guides walk through importing your existing library so you don't start from zero.

How private is this, really?

ToolPiper's text and clipboard features process everything on your Mac. The action-snippet transform runs on your machine via Apple's on-device model or ToolPiper's local LLM, your clipboard indexes locally, and dictation audio is transcribed on the Neural Engine. None of it travels over the network, and you can confirm that by watching network traffic while ToolPiper runs.

Don't take that on faith. The mechanism is what makes it true. The action pipeline reads your selection, sends it to a model running on your hardware, and writes the result back, with no clipboard read and no server hop in between. A cloud rewrite tool, by contrast, has to send your selected text to a remote server to transform it. That's not a policy difference, it's a structural one. A privacy policy governs what a company says it does with data after the data arrives. It can't change the fact that the data left your device. With local transforms, the data doesn't leave, and a packet inspector will show you the same thing we're telling you. This is the same architectural stance that runs through everything ToolPiper does on-device, laid out in the pillar on local-first AI on macOS.