---
title: "Apple Writing Tools Alternative on Mac: Custom AI Text Edits, Local"
description: "An Apple Writing Tools alternative for Mac with custom prompts, chained transforms, your choice of local model, and edits that run on-device. Free download."
date: 2026-05-31
author: "Ben Racicot"
tags: ["Apple Intelligence", "Writing Tools", "Alternative", "AI", "Privacy", "macOS"]
type: "article"
canonical: "https://modelpiper.com/blog/apple-writing-tools-alternative"
---

# Apple Writing Tools Alternative on Mac: Custom AI Text Edits, Local

> An Apple Writing Tools alternative for Mac with custom prompts, chained transforms, your choice of local model, and edits that run on-device. Free download.

## TL;DR

Apple Writing Tools is free, built into macOS, and excellent for its fixed presets (Proofread, Rewrite, Friendly/Professional/Concise, Summarize, Key Points, Lists). The gap: you can't define your own prompts, you can't chain edits, you can't pick the model, and some requests route to Apple's Private Cloud Compute off-device. ToolPiper action snippets fill exactly that gap. Select text, tap right Command, and a transform you defined (;legalese, ;casual, ;bullets) rewrites it. Chain two with one tap (";fix ;formal"). Edits run on your Mac via a local model you choose, verifiable by watching network traffic. Free download (DMG), macOS 26+, Apple Silicon.

You highlight a paragraph, right-click, and Apple Writing Tools gives you a tidy menu. Proofread, Rewrite, Friendly, Professional, Concise, Summarize, Key Points. For those exact tasks it's good, and it's free, and it's already on your Mac. We're not going to pretend otherwise.

The wall you hit is the menu. You can't add an item to it. You can't tell it "rewrite this in plain legal English" or "turn this into a changelog entry" and save that as a one-tap action. You can't run two edits back to back. And you don't get to know, request by request, whether the work happened on your Mac or got sent to Apple's Private Cloud Compute. **Apple Writing Tools gives you a fixed set of edits. The moment you want your own, you're out of options inside the menu.**

That's the gap this article is about. ToolPiper action snippets are user-defined text transforms that run the same select-and-tap motion, except you write the prompts, you chain them, and the model runs on your Mac. The point isn't to beat Apple at Proofread. It's to cover the edits Apple's menu will never have.

## What is Apple Writing Tools and what are its limits?

Apple Writing Tools is a system-wide text-editing feature built into recent macOS as part of Apple Intelligence. It offers a fixed set of rewrites - Proofread, Rewrite, Friendly, Professional, Concise, Summarize, Key Points, and list/table conversions - on selected text. You cannot add custom prompts, chain transforms, or choose which model runs the edit, and some requests are processed off-device by Apple's Private Cloud Compute.

Here's the honest version. Writing Tools is zero-install (it's part of the OS), it works in nearly any text field system-wide, and for the presets it ships it's quick and the output is solid. If your editing needs are "fix my grammar" and "make this sound more professional," you may not need anything else, and we'll say so plainly at the bottom of this article.

The limits show up the moment your needs get specific. The presets are the presets. There's no field where you type your own instruction and save it. There's no way to say "first fix the grammar, then make it formal" in one motion. You can't point it at a particular model. And Apple's design routes some Writing Tools requests to Private Cloud Compute, which is off your device. Apple has built real cryptographic guarantees around that path, and it's a genuinely careful design - but it is, by definition, not local.

## What's a private alternative to Apple Writing Tools?

ToolPiper action snippets are a private, local alternative to Apple Writing Tools. You select text, tap right Command, and a transform you defined rewrites the selection in place. The edit runs on your Mac - it tries Apple's on-device model first, then falls back to a local model in ToolPiper - and the text never leaves the machine. You can confirm that by watching network traffic while it runs.

The mechanism matters, so here's how it works. You select a region of text. You press the right Command key and release it inside 250 milliseconds (a deliberate tap, not a held shortcut). ToolPiper reads only that selected region - it never reads your clipboard in this pipeline - and runs your chosen transform on it. The result replaces the selection.

Where the work happens is the part people care about. The transform tries Apple's on-device Foundation Models engine first. If that engine rejects the input or the text is too long for it, ToolPiper falls back to its own local model running over loopback on your Mac. Either way the text stays on the machine. This is the same verifiability stance we apply to [push-to-talk dictation](/blog/push-to-talk-ai-mac) and the rest of the platform. Don't take our word for it. Run a packet inspector and watch nothing leave.

## How do custom prompts beat a fixed menu?

A custom prompt lets you define a transform Apple's menu doesn't have. With ToolPiper you can create ;legalese, ;casual, ;bullets, or any trigger with any instruction you write, and invoke it the same way you'd run a built-in edit. Apple Writing Tools only offers its fixed presets.

ToolPiper ships 12 transforms out of the box so you're not starting from a blank page. The bundled set covers `;fix`, `;formal`, `;casual`, `;concise`, `;expand`, `;simplify`, `;bullets`, `;summary`, `;tldr`, `;active`, `;email`, and `;rewrite`. Those overlap with Apple's presets on purpose - the muscle memory should feel familiar.

The difference is the next one you make. Maybe you draft contracts and you want a `;plainlegal` that strips jargon while keeping the meaning intact. Maybe you write release notes and you want a `;changelog` that reformats a paragraph into a bulleted entry with a leading verb. You define the trigger, you write the prompt, and from then on it's a one-tap edit that lives in your hands, not in a menu someone else curates. The presets Apple ships are good defaults. **Your work has edits that no default menu will ever include.**

## Can you chain AI text edits together?

Yes. ToolPiper action snippets chain - ";fix ;formal" runs the grammar fix first, then the formal rewrite, in document order, on a single tap. Apple Writing Tools applies one edit at a time, so chaining means manually running one preset, then selecting the result and running another.

Chaining sounds small until you do it twenty times a day. Say you've dictated a rough reply and it needs two passes, cleaning up the grammar first, then shifting the tone to professional. In Writing Tools that's Proofread, re-select, Rewrite-to-Professional - two trips through the menu. With a chained snippet it's `;fix ;formal` and one tap.

There are guardrails so a chain can't quietly mangle your text. Stages run in document order, capped at four. If any stage returns empty output, the chain aborts and your original selection is preserved untouched. ToolPiper also refuses to run on an empty selection, refuses an empty result, and refuses any target longer than 16,384 characters - the kind of edges where an unbounded transform would do more harm than good.

## Which model runs the edit, and where?

With ToolPiper you choose the model. Action snippets try Apple's on-device Foundation Models engine first, then fall back to whichever local model you've loaded in ToolPiper for longer or rejected inputs. Apple Writing Tools uses Apple's models only, with no option to swap, and routes some requests off-device to Private Cloud Compute.

This is the lever Apple doesn't give you. Writing Tools is Apple's model, full stop, and for some requests Apple's cloud. That's a reasonable default for most people. But if you want a larger local model for a meatier rewrite, or a specific model you trust for a specific kind of text, ToolPiper lets you pick it. The on-device-first design keeps the common case fast and free, and the fallback gives you headroom when the small model isn't enough.

The privacy consequence follows directly from that choice. When the edit runs on your Mac - Apple's on-device engine or ToolPiper's local model - the text doesn't travel. There's no request to inspect because there's no request. Apple's Private Cloud Compute is a careful, audited design, but it's still a path where your text leaves the device for processing. Local-first means the question of "did this leave" has the same answer every time, which is no. For the bigger argument on why that distinction matters, see [our pillar on local-first AI on macOS](/blog/local-first-ai-macos).

## What about Grammarly and the broader category?

Grammarly is a cloud-based writing assistant that gives real-time grammar and style suggestions as you type across apps and browsers. It's strong at continuous inline checking, but the text goes to its servers and the useful tiers are a paid subscription (as of May 2026). ToolPiper action snippets are tap-to-transform edits you define that run on a local model on your Mac, so they cover custom, chainable rewrites that stay on the machine, while Grammarly covers as-you-type suggestions that ToolPiper doesn't.

Grammarly is the other tool people reach for when Writing Tools isn't enough, so it earns a row in the comparison below. It's strong at what it does - real-time grammar and style suggestions as you type, across browsers and apps - and it has years of polish behind it. The trade-off is the obvious one. Grammarly's checking runs in its cloud, your text goes to their servers, and the useful tiers are a subscription. It's a different shape of tool than a tap-to-transform snippet, but it's the same buyer deciding, so we put all three side by side.

ToolPiper's wedge against both is consistent. Edits you define, chained when you want, on a model you choose, running on your Mac. Where Apple wins is just as consistent - zero install, free, and system-wide out of the box. The table doesn't hide either fact.

## One muscle memory, three ways in

The select-and-tap motion isn't the only way to fire a transform, and that's the part that ties the whole feature together. The same snippets you define for action mode are reachable three ways. There's type-and-tap on a selection, by voice ("use the fix snippet," or speaking the trigger), and - in beta now - through chat, where a model can call an `apply_<trigger>` tool to run your snippet on a passage. One library of edits, the same names, whichever input is closest to your hands at the moment.

Voice dispatch for the explicit cases is solid and deterministic today. If you name the snippet or say its trigger, it's a single local model call with no guessing. The chat path and the smartest "match my paraphrase to the right snippet" routing are the parts still landing - we'll call those beta rather than oversell them. The type-and-tap path is the one to start with, and it's the one that goes head to head with Apple Writing Tools.

## When does it know not to fire?

ToolPiper's action-snippet capture checks the focused element's accessibility role before reading any text and refuses secure or password fields. If accessibility access is denied or the check times out at 250 milliseconds, it fails closed and does nothing.

The reason this matters is simple. A tool that reads your selection to edit it must not read a selection it has no business touching. Before capturing, ToolPiper probes the focused field's accessibility role. A secure text field - a password box, for instance - is refused outright. If the accessibility check can't complete or you haven't granted access, it doesn't guess. It fails closed and the transform simply doesn't run.

Trigger matching is careful in the other direction too. Triggers only fire when flanked by whitespace or punctuation, so `;fix` never goes off inside the word ";fixed." And the action pipeline reads only your selection - never your clipboard - so an edit can't accidentally pull in whatever you copied an hour ago. Voice, voice chat, and snippet expansion are interlocked so two of them can't fire at the same instant and collide.

## How do you set it up?

Three steps, and the first two are the only ones that touch system settings.

**1\. Download and install ToolPiper.** Grab the DMG from [modelpiper.com](https://modelpiper.com). ToolPiper isn't on the Mac App Store because it uses Accessibility and CGEvent APIs the App Store sandbox doesn't allow - the same reason TextExpander, Raycast, Alfred, and Keyboard Maestro all ship outside it.

**2\. Grant Accessibility permission.** On first launch macOS asks for Accessibility access. That's what lets ToolPiper read your selection and replace it. It's also what powers the secure-field refusal described above - without that access, capture fails closed by design.

**3\. Tap right Command on a selection.** Highlight some text, press and release right Command, and the default `;fix` transform runs. From Settings you define your own triggers and prompts, and chain them when you want a two-pass edit. The on-device model handles short edits with no further setup, and longer ones fall back to whatever local model you've loaded.

## Where Apple Writing Tools is the right call

We'll be straight about this. If you want zero setup and the built-in presets already cover what you do, Apple Writing Tools is the right tool and you should use it. It's free, it's already installed, and Proofread plus Rewrite plus Summarize is genuinely most of what casual editing needs. There's nothing to download, nothing to grant, nothing to configure.

You'd reach for ToolPiper action snippets when the menu runs out. That's when you need a transform Apple doesn't ship, when you want to run two edits in one motion, when you want a specific local model doing the work, or when the text is sensitive enough that "some requests go to Private Cloud Compute" isn't a trade-off you want to make. Those are real needs for some people and a non-issue for others. Pick honestly.

One more limitation is worth stating. Action snippets replace a selection in standard text fields, and some apps render text in non-standard ways (a few terminal emulators, certain custom editors) where in-place replacement won't take. In those, you'd copy the result manually. The on-device-first model is fast for short edits, but a long, complex rewrite that falls back to a larger local model takes longer than Apple's tuned preset - that's the cost of getting to choose the model.

## Get ToolPiper

ToolPiper is a free download from [modelpiper.com](https://modelpiper.com) (DMG). It needs macOS 26 or later and Apple Silicon (M1 or newer). Install it, select some text, tap right Command, and define the first edit Apple's menu never had.

_This is part of our cluster on text and clipboard tools - see the [text and clipboard workflows roundup](/workflow/text-clipboard) and the pillar on [local-first AI on macOS](/blog/local-first-ai-macos). If you also want shortcuts that expand as you type, read [AI text snippets on Mac](/blog/ai-text-snippets-mac) - the typed-trigger side of the same engine._

## FAQ

### Can I add custom prompts to Apple Writing Tools?

No. Apple Writing Tools offers a fixed set of presets - Proofread, Rewrite, Friendly, Professional, Concise, Summarize, Key Points, and list conversions - with no way to define your own instruction or save a custom transform. That's the core gap. ToolPiper action snippets let you create any trigger with any prompt you write, like `;legalese` or `;changelog`, and run it with the same select-and-tap motion.

### Does Apple Writing Tools work offline?

Partly. Some Apple Writing Tools requests run on your device, but others route to Apple's Private Cloud Compute, which requires a network connection and processes the text off your Mac. So it isn't fully offline or fully local. ToolPiper action snippets run on your Mac - Apple's on-device model first, then a local model in ToolPiper - so they work without a network and the text never leaves the machine.

### What's a private alternative to Apple Writing Tools?

ToolPiper action snippets are a private alternative. You select text, tap right Command, and a transform you defined rewrites the selection on your Mac. It tries Apple's on-device engine first and falls back to a local model in ToolPiper - no cloud hop either way. You can verify nothing leaves by watching network traffic while it runs, which is a check you can't run against a cloud-processed edit.

### Can ToolPiper chain two text edits in one step?

Yes. Write a chained snippet like ";fix ;formal" and one right Command tap runs the grammar fix first, then the formal rewrite, in document order. Chains are capped at four stages. If any stage returns empty output the chain aborts and your original selection is preserved. Apple Writing Tools applies one preset at a time, so the same result there takes two manual passes.

### Will action snippets fire in a password field?

No. Before reading any text, ToolPiper checks the focused field's accessibility role and refuses secure and password fields. If the accessibility check is denied or times out at 250 milliseconds, it fails closed and does nothing. The action pipeline also reads only your current selection - never your clipboard - so an edit can't pull in something you copied earlier.

### Do I have to pay for ToolPiper action snippets?

No. ToolPiper is a free download (DMG) from modelpiper.com, and action snippets are part of it. It requires macOS 26 or later and Apple Silicon (M1 or newer). It ships outside the Mac App Store because it uses Accessibility and CGEvent APIs the App Store sandbox doesn't permit - the same reason TextExpander, Raycast, and Alfred ship as direct downloads.

### Is this a replacement for Grammarly too?

It overlaps but isn't identical. Grammarly does real-time inline grammar and style suggestions as you type, across apps and browsers, with its checking in the cloud. ToolPiper action snippets are tap-to-transform edits you define, running on a local model on your Mac. If you want continuous as-you-type suggestions, Grammarly does that and ToolPiper doesn't. If you want custom, chainable edits that stay on your machine, ToolPiper covers what Grammarly's cloud model and Apple's fixed menu don't.