Shell Escape — Quote a String for Bash, sh, zsh and PowerShell

Pick a style — single-quote (the safe default for anything with spaces or shell metacharacters), double-quote (when the shell still needs to expand something else nearby), backslash (no quotes, character-by-character), or PowerShell — paste the value, and press Escape. Copy the result straight into your command line; it already includes its own quoting.

Because POSIX shells give single quotes exactly one meaning — pure literal text — with zero exceptions, while backslash-escaping has to correctly enumerate every character that's special across every context a word might appear in (globbing, word splitting, history expansion in interactive shells, and more). Get one character out of that list and the escaped-but-unquoted version breaks in a way that's easy to miss in testing and dangerous in production; a wrongly-quoted value is one of the most common sources of shell-injection bugs in scripts that build commands from variables. Single-quote wrapping needs exactly one special case — an embedded single quote — which is why it's this tool's default style.

You can't put one inside the quotes — nothing can escape inside a single-quoted string, single quotes included — so the standard trick closes the string, contributes the quote a different way, and reopens the string: 'Ada'\''s report' means "the literal text Ada", then \' outside any quoting (a backslash-escaped single quote, valid in an unquoted shell word), then 's report' as another literal string — and the shell concatenates all three adjacent words into a single argument Ada's report. This tool builds that sequence automatically: every ' in your input becomes '\'' and the whole value is wrapped in an outer pair of quotes. The alternative some scripts use is bash's $'...' ANSI-C quoting, where \' does mean an escaped quote directly, but that syntax is a bash/zsh/ksh extension, not POSIX sh — the '\'' idiom this tool produces works absolutely everywhere.

Whenever the shell should still DO something with part of the value even though most of it is literal text — expand $HOME inside a path, run `date` and splice in its output, or preserve a variable's word-splitting behavior differently from single quotes. Double-quote style here backslash-escapes only the four characters that remain special inside double quotes — " \ $ and the backtick — so $HOME stays as the literal text $HOME in the output rather than the two characters $ and H-O-M-E becoming something a live shell would later expand; that's correct if you intend to paste the result somewhere it should stay inert, and it is exactly the escaping printf '%q' and most "quote for double quotes" library functions perform.

The single-quote, double-quote and backslash styles follow POSIX.1-2024's Shell Command Language, which bash, sh, dash and zsh (in its default, non-csh-emulation mode) all implement identically for quoting purposes — so those three styles are safe for any of them. fish is the outlier among Unix-like shells: it accepts single-quote wrapping for the same literal effect, but its OWN escape for an embedded quote inside single quotes is a bare backslash before the quote (\') rather than the '\'' idiom, so fish-specific scripts should use fish's own string escape rather than this tool's single-quote output. The PowerShell style here handles PowerShell's single-quoted strings (doubling an embedded ' is PowerShell's equivalent trick). cmd.exe is intentionally out of scope: its quoting rules depend on which built-in or program is parsing the arguments and have no single consistent standard, so there is no one correct escaping to generate.

Because in a plain POSIX sh double-quoted string, ! is not special — it is bash and zsh's interactive-mode history expansion (the feature that turns !! into your last command) that gives it meaning, and that expansion is normally disabled in scripts and non-interactive shells, and it happens on the raw command line before quoting is even parsed, not inside every double-quoted string. Escaping it here would produce a backslash that isn't part of POSIX double-quote grammar at all — bash would print a literal backslash followed by an unescaped !, doing more harm than leaving it alone. If you specifically need to defeat interactive history expansion, run set +H first or use single-quote style, which truly is unconditional.