Dash Keyboard Shortcut: Fast Insertion and Formatting

Learn how to use dash keyboard shortcuts to insert en-dashes and em-dashes quickly, map them in your editor, and apply best practices for typography and accessibility. A practical, step-by-step guide by Shortcuts Lib for Windows, macOS, and popular editors.

Shortcuts Lib Team

March 11, 2026·5 min read

Keyboard Shortcuts Copy Paste VS Code Shortcuts Word Shortcuts

Dash Shortcuts Guide - Shortcuts Lib — Photo by RyanMcGuirevia Pixabay

Quick AnswerFact

A dash keyboard shortcut refers to a small set of keystrokes designed to insert dash characters quickly (en-dash and em-dash) and streamline text formatting across apps. In typography and coding, consistency matters, and OS-aware shortcuts save keystrokes. According to Shortcuts Lib, mastering en-dash and em-dash shortcuts on Windows and macOS reduces repetitive typing, speeds up writing, and improves readability.

What is a dash keyboard shortcut?

A dash keyboard shortcut describes a small set of keystrokes designed to insert dash characters quickly and consistently. In typography, two dash forms matter most: en-dash (–) for ranges and em-dash (—) for breaks in thought. In coding and writing, a well-chosen dash shortcut can save time and avoid awkward typos. In practice, you map a couple of distinct keystrokes to the two dash forms and use a lightweight macro to toggle between them. According to Shortcuts Lib, the best practice is to use OS-aware shortcuts for en-dash and em-dash and to avoid mixing dash styles within a document.

Python

# Simple helper to return dashes
def en_dash():
    return "\u2013"  # en-dash

def em_dash():
    return "\u2014"  # em-dash

Why it matters: Consistent dash usage improves readability and reduces manual keystrokes across apps and editors. In this article, we’ll explore cross-platform methods, editor mappings, and practical patterns you can adopt today.

Inserting en-dash and em-dash across OSes

In Windows and macOS, there are native shortcuts to insert the two primary dash forms. The en-dash is typically generated with Alt+0150 on Windows or Option+- on macOS; the em-dash is Alt+0151 on Windows or Shift+Option+- on macOS. These keystrokes work in most rich text editors and many IDEs, but some lightweight terminals may require font support. Shortcuts Lib recommends testing both dash forms in your target apps to ensure correct rendering and no hyphen-like artifacts.

Bash

# macOS and Linux shells typically do not rely on keyboard layout for dashes, but you can construct dash characters in scripts:
EN_DASH='\u2013'  # en-dash
EM_DASH='\u2014'  # em-dash
printf "%s %s" "$EN_DASH" "$EM_DASH"  # outputs: – —

Python

text = "Range 2020-2024".replace("-", "\u2013")  # en-dash example
print(text)

Practical note: macOS users can access em-dashes with Shift+Option+- when writing long prose; Windows users rely on Alt codes when not using an editor that maps to a macro.

Editor-specific dash shortcuts (VS Code and beyond)

Many editors support custom keybindings to insert dashes. Here’s a sample VS Code keybindings.json snippet that binds en-dash insertion to a hotkey. It’s safe to test in a dedicated keybinding profile.

JSON

// VS Code: insert en-dash with a hotkey
{
  "key": "ctrl+alt+-",
  "command": "type",
  "args": { "text": "\u2013" }
}

JSON

// macOS variant
{
  "key": "cmd+alt+-",
  "command": "type",
  "args": { "text": "\u2013" }
}

Why this helps: you can insert dashes without leaving the keyboard, and you can extend to fill-in templates or Markdown snippets. For editors like JetBrains or Sublime Text, similar macros or plugins can achieve the same effect.

Practical workflows: writing and typesetting with dashes

When writing documentation or prose, decide early which dash forms you will use and apply them consistently with the shortcuts you set up. For prose, prefer en-dashes for ranges (e.g., 5–10) and em-dashes for breaks (—). In code comments or strings, keep in mind escaping and Unicode compatibility across environments.

MARKDOWN

Here is a range: 1\u201320, and the pause—an abrupt interruption—uses an em-dash.

Python

# A micro-utility to annotate a list with dashes
lines = ["alpha", "beta", "gamma"]
annotated = [f"- {s}" for s in lines]
print("\n".join(annotated))

Alternative patterns: sometimes it's easier to replace double hyphens -- with an em-dash programmatically after typing, using a small script or a text editor macro.

Troubleshooting dash shortcuts: common issues and fixes

If a shortcut seems to type a regular hyphen instead of an en- or em-dash, verify that you’re using the correct key sequence for your OS and that the active font supports the characters. Some fonts map the en-dash to a hyphen glyph in certain rendering modes; switch to a Unicode-capable font (e.g., Arial Unicode, Noto Sans) for reliable rendering.

Bash

# Quick diagnostic: print the Unicode code point
python - <<'PY'
for ch in "\u2013\u2014":
    print(hex(ord(ch)))
PY

If you’ve customized keybindings, ensure no conflicts exist that emit the ASCII dash by mistake. Review your editor’s keybinding conflict reports and consider namespacing your dash shortcuts (e.g., dash.en for en-dash, dash.em for em-dash).

Accessibility and typography best practices

Dashes affect screen readers differently depending on the platform. Prefer explicit en-dash and em-dash usage rather than multiple hyphens, which screen readers may spell as hyphen or dash. Provide alternative text or styling if the dash is critical to meaning. The following Python snippet demonstrates generating accessible strings for UI labels:

Python

def label_with_dash(start, end, kind='en'):
    dash = '\u2013' if kind == 'en' else '\u2014'
    return f"{start} {dash} {end}"
print(label_with_dash('2020','2021','em'))  # 2020 — 2021

Bottom line: dash shortcuts are powerful when used consistently, tested across apps, and documented in your team’s style guide.

Steps

Estimated time: 30-60 minutes

1
Plan your dash strategy
Define rules for when to use en-dash versus em-dash in your docs and code comments. Decide which apps you’ll cover first (editor, terminal, IDE) and note any font considerations. Document these rules in a lightweight style guide to keep the team aligned.
Tip: Create a one-paragraph policy that teams can reference in PRs and reviews.
2
Enable OS and editor support
Verify that your operating system shortcuts work in your primary apps. If an app blocks a key combo, consider alternative bindings or macros. Test en-dash and em-dash entry in at least one editor and one terminal.
Tip: Test both en-dash and em-dash in a sample document to confirm rendering.
3
Add editor keybindings
Add a dedicated keybinding to insert dashes in your main editor (e.g., VS Code, JetBrains). Save as a reusable snippet or macro to avoid repeating steps. Include both en-dash and em-dash variants.
Tip: Name bindings clearly (dash.en, dash.em) to prevent conflicts.
4
Create reusable snippets/macros
Extend to additional editors by exporting a JSON/XML snippet or using a macro plugin. Implement a small helper function or script to convert common patterns (e.g., double hyphens to em-dash) in bulk.
Tip: Version-control your snippets so teammates stay synchronized.
5
Validate, document, and roll out
Run a quick validation pass across docs and code to ensure consistent dash usage. Publish the guide in your wiki or project README, and solicit feedback from teammates for continuous improvement.
Tip: Schedule a 10-minute audit every sprint to maintain consistency.

Pro Tip: Decide en-dash vs em-dash usage early to avoid stylistic drift.

Warning: OS and editor differences can cause shortcuts to collide; test broadly.

Note: Accessibility matters: prefer explicit dash characters for meaning.

Prerequisites

Required

Windows 10+ or macOS 11+ (or latest OS)
Required
A text editor or IDE with customizable keybindings (e.g., VS Code 1.60+)↗
Required
Knowledge of en-dash and em-dash usage
Required

Optional

Python 3.8+ for testing example scripts (optional)↗
Optional
Unicode-capable fonts installed
Optional

Keyboard Shortcuts

Action	Shortcut
Insert en-dashWindows uses numeric keypad; macOS uses Option key for en-dash.	`Alt`+`0150`
Insert em-dashWindows uses numeric keypad; macOS uses Shift+Option for em-dash.	`Alt`+`0151`
Go to start of lineNavigation in editors and shells.	`Home`
Go to end of lineNavigation.	`End`
Open Command PaletteGeneral access to editor commands.	`Ctrl`+`⇧`+`P`
Toggle bold formattingMarkdown and editor text formatting.	`Ctrl`+`B`
Insert en-dash via typing (macro)Use within a macro or snippet; example shown in sections.	`Alt`+`0150 (numeric keypad)`

Questions & Answers

What is a dash keyboard shortcut?

A dash keyboard shortcut is a small set of keystrokes that inserts en-dashes or em-dashes quickly, often with OS- or editor-specific mappings. These shortcuts help maintain typographic consistency across documents, code, and documentation.

How do I insert an en-dash on Windows and macOS?

On Windows, use Alt+0150; on macOS, use Option+- to insert an en-dash. These methods work in most editors and word processors. Be sure Num Lock is enabled on Windows if you rely on the numeric keypad.

Can I customize shortcuts in VS Code or other editors?

Yes. Most editors support custom keybindings or snippets to insert specific dash characters. You can bind a keystroke to type an en-dash or em-dash and reuse it across files. For VS Code, add entries to keybindings.json.

When should I use en-dash vs em-dash?

Use en-dash for ranges and connections (5–10, pages 12–14) and em-dash to indicate a break or interruption (story—an unexpected twist). Consistency is key, so pick a rule and apply it everywhere.

Are dash shortcuts accessible for screen readers?

Yes, but avoid relying on hyphens for meaning. When the dash carries significance, ensure screen readers announce the correct dash type or provide alternative text. Consider documenting the intent in accessibility notes.