nano — Friendly Terminal Text Editor

What it is

GNU nano is a small, free-software terminal text editor that descends from pico (the editor bundled with the Pine email client) and has been the FSF-maintained replacement since 1999. Every command is a single Ctrl- or Alt-keystroke listed live at the bottom of the screen — there is no mode to enter, no muscle memory to build, and no :wq to forget. Reach for nano when you want to edit a config file over SSH on a box where you don't control the editor preference (it's the default EDITOR on Debian/Ubuntu, Raspberry Pi OS, and many container base images); reach for micro, helix, vim, or neovim instead when you want a faster keyboard model, modal editing, or LSP integration.

The latest stable release is GNU nano 9.0 (April 8, 2026). Versions 8.x added the optional --modernbindings flag that remaps to a Ctrl-S-save / Ctrl-Z-undo layout for users coming from GUI editors.

Install

nano is in every major distro's base repos; macOS ships an ancient 2.x in /usr/bin/nano that you'll almost always want to override with a Homebrew build.

# Debian / Ubuntu / Raspberry Pi OS
sudo apt install nano

# Fedora / RHEL / Rocky / Alma
sudo dnf install nano

# Arch / Manjaro
sudo pacman -S nano

# macOS (Homebrew — the system /usr/bin/nano is stuck on 2.x)
brew install nano

# Verify
nano --version | head -1

Output:

 GNU nano, version 9.0

Syntax

The invocation form is nano [OPTIONS] [+LINE[,COLUMN]] [FILE...]. With no file, nano opens an empty buffer; with multiple files it opens a buffer per file and you switch with M-, / M-.. The +LINE,COL prefix (or file:LINE:COL if the --colonparsing flag is set — required since 8.1) jumps straight to that position.

nano /etc/hosts                       # open one file
nano +120 /var/log/syslog             # open at line 120
nano +120,8 src/main.c                # line 120, column 8
nano --colonparsing src/main.c:42:5   # same, colon notation (8.1+)
nano -Y python script.py              # force python syntax highlighting
nano -                                # read stdin into a new buffer

Output: (none — launches the editor)

Essential options

Long flags map 1:1 to set <flag> lines in nanorc (so you can promote any of these to a permanent setting; see the Configuration section below).

Essential keybindings

These are the legends nano prints at the bottom of every screen — ^ means Ctrl, M- means Meta (the Alt key on Linux/Windows, or the Esc-then-key two-stroke prefix on macOS terminals that don't pass Alt through). Bindings are case-insensitive: ^G and ^g are the same.

Configuration

nano reads ~/.nanorc for per-user settings and /etc/nanorc for the system default, in that order — every option you set per-user overrides whatever the system file said. The file format is flat: one directive per line, # starts a comment, blank lines ignored. There is no project-local discovery (no walking-up-the-tree for a nanorc), but every persistent flag has a --flag counterpart you can pass on the command line for one-shot overrides. Reach for ~/.nanorc to set defaults you always want (line numbers, mouse, tab size); reach for flags when shelling out to a system you only edit once.

File locations — paths searched at startup, by OS.

Loading precedence (highest to lowest):

1. Command-line flags (nano --linenumbers …)
2. ~/.nanorc
3. /etc/nanorc
4. Built-in defaults (e.g. tabsize 8, fill -8)

There is no --config FILE flag — to use a non-default rc file, set NANORC=/path/to/file in the environment before invoking nano.

Options reference — boolean toggles (no argument), value options (one argument), and color options ([bold,][italic,]fg,bg). Every entry can be inverted with unset (e.g. unset autoindent).

Boolean toggles

Value options

Color options

[bold,][italic,]fgcolor,bgcolor — colors are black, red, green, yellow, blue, magenta, cyan, white, their light* variants, grey/gray, plus #000–#fff greyscale and 256-color names on capable terminals.

Syntax & key directives

syntax NAME "FILEREGEX" ...                  # define a language
header "REGEX" ...                           # also match files whose first line matches
magic "REGEX" ...                            # also match files whose libmagic output matches
color FG,BG "REGEX"                          # paint matches
icolor FG,BG "REGEX"                         # case-insensitive variant
color FG,BG start="RX" end="RX"              # multi-line range
include "PATH"                               # pull in another rc file (often /usr/share/nano/*.nanorc)
extendsyntax NAME color FG,BG "REGEX"        # add rules to an existing syntax
formatter PROGRAM [ARGS]                     # buffer-wide formatter for ^T
linter    PROGRAM [ARGS]                     # external linter for ^T (`file:line:col: msg` output)
comment "STR"                                # comment string for the comment-toggle binding (use | for /*|*/)
tabgives "STR"                               # what <Tab> produces (e.g. four spaces inside python syntax)
bind KEY FUNCTION MENU                       # rebind a key to a built-in function
bind KEY "STRING" MENU                       # rebind a key to a literal string or {function} macro
unbind KEY MENU                              # remove the binding

Menu names: main, help, search, replace, replacewith, yesno, gotoline, writeout, insert, browser, whereisfile, gotodir, execute, spell, linter, all.

Example config

A working ~/.nanorc that turns on the modern conveniences without rebinding any keys (so the on-screen hints still match what you press):

# ~/.nanorc — sensible defaults for daily editing

# Display
set linenumbers
set constantshow
set softwrap
set atblanks
set indicator
set stateflags
set guidestripe 80

# Editing behaviour
set autoindent
set smarthome
set tabsize 4
set tabstospaces
set trimblanks
set zap
set matchbrackets "(<[{)>]}"

# Persistence
set historylog
set positionlog
set backup
set backupdir "~/.cache/nano/backups"

# Input
set mouse

# Search defaults
set casesensitive

# Colors (256-color terminal assumed)
set titlecolor    bold,white,#222
set statuscolor   bold,white,#225
set numbercolor   #777
set stripecolor   ,#222
set spotlightcolor black,yellow

# Syntax — load every bundled highlighter
include "/usr/share/nano/*.nanorc"

# Comment-toggle on M-3 already; bind M-/ as another shortcut
bind M-/ comment main

# Trim trailing whitespace before save (8.5+ formatter chain)
extendsyntax python formatter "sed -i 's/[[:space:]]*$//'"

Output: (none — file contents)

Modern bindings — Ctrl-S save, Ctrl-Z undo (8.0+)

--modernbindings / -/ remaps nano to the keymap most people learned from GUI editors: ^S saves, ^Z undoes, ^C copies, ^V pastes. The trade-off is that the on-screen hints at the bottom still print the classic labels (^O WriteOut etc.) — they don't redraw to match — so it's a power-user mode, not a beginner crutch. nano also auto-activates the modern map when its executable name starts with e (e.g. invoked as edit), which is the workaround Debian uses to provide a modern-feeling default editor without renaming nano.

# One-off
nano --modernbindings README.md
nano -/ README.md

# Always-on via shell alias
alias nano='nano -/'

# Or via symlink (8.0+ detects "edit" prefix)
sudo ln -s /usr/bin/nano /usr/local/bin/edit
edit README.md

Output: (none — launches the editor with the remapped keys)

The full remap:

Multiple buffers

Pass multiple file arguments and nano opens one buffer per file — M-, and M-. rotate through them, ^X closes the current buffer (or the whole editor when only one is open), and ^R followed by M-F inserts a file into a new buffer instead of inline. Set multibuffer in ~/.nanorc to make new-buffer mode the default for ^R.

nano src/main.c src/util.c src/util.h
# inside nano:
#   M-.    →  next buffer
#   M-,    →  previous buffer
#   ^R, M-F, src/extra.c, Enter   →  open extra.c in a new buffer
#   ^X     →  close current buffer (keeps editor open if others exist)

Output: (none — interactive editor session)

Search, replace, and regex

^W (Where Is) opens an incremental forward search; the prompt's own menu shows toggles for case (M-C), backwards (M-B), and regex (M-R). ^\ (or M-R from inside a search) opens the search-and-replace flow: enter the pattern, press Enter, enter the replacement, then for each hit choose y (replace), n (skip), a (replace all from here), or ^C (stop).

nano +1 /etc/ssh/sshd_config
# ^W "PasswordAuthentication"          → finds the option
# ^\ "^#?(PasswordAuthentication).*" Enter
#    "\1 no" Enter
#    a                                  → replaces every match with the uncommented form
# ^O Enter                              → save in place
# ^X                                    → exit

Output:

[ Replaced 1 occurrence ]

To search by default in regex mode, add set regexp to ~/.nanorc. Backreferences (\1, \2, …) are supported in the replacement. The casesensitive setting controls the initial state of the M-C toggle.

Syntax highlighting

Highlighting is rule-based and rc-driven — each syntax NAME "FILEREGEX" block opens a scope, then color FG,BG "REGEX" lines paint matches within it. Distributions ship /usr/share/nano/*.nanorc covering ~70 common languages; pull them all in with a single include glob. Force a specific syntax with -Y NAME or list available ones with nano -z (8.1+).

# List every syntax nano can apply right now
nano -z | head

# Force python highlighting on a file that has no .py extension
nano -Y python script.txt

# Author your own — drop this into ~/.nano/csv.nanorc and include it
cat <<'NANO' > ~/.nano/csv.nanorc
syntax "csv" "\.csv$"
color brightcyan ","
color yellow "\"[^\"]*\""
color cyan "^[^,]+"
NANO

# Then in ~/.nanorc:
echo 'include "~/.nano/csv.nanorc"' >> ~/.nanorc

Output:

asm
awk
c
cmake
css
default
elisp
fortran
go
html

For one-off additions to an existing syntax (e.g. flagging TODO: in red across every language), use extendsyntax:

# ~/.nanorc
extendsyntax default icolor brightred "(TODO|FIXME|XXX):"

Output: (none — rc-file content)

Undo, redo, and macros

Modern nano enables undo by default — every keystroke beyond cursor movement is undoable with M-U and redoable with M-E (^Z and ^Y if you're running with --modernbindings). For repetitive surgical edits, record a macro: M-: starts recording, perform the keystrokes once, M-: stops, then M-; replays it as many times as needed. Macros capture every key including motion, so they're equivalent to vim's q register without the register namespace.

nano list.txt
# Original:
#   alice
#   bob
#   carol
#
# Goal: surround every line with quotes and a trailing comma
#
# Position cursor at start of first line, then:
#   M-:                       → start recording
#   "                         → type opening quote
#   ^E                        → end of line
#   ",                        → type closing quote + comma
#   Down, Home                → next line, start
#   M-:                       → stop recording
#   M-;                       → replay once
#   M-;                       → replay again
# ^O Enter, ^X

Output:

"alice",
"bob",
"carol",

For programmatic edits across a marked region or whole buffer, prefer ^T → Execute → pipe the selection through sed/awk/sort. The Execute prompt also accepts ||command (8.7+) to send the buffer to an OSC 52-aware terminal's clipboard.

Restricted mode and view-only

-R / --restricted (a.k.a. "rnano" if your distro installs that wrapper) disables shell-out, file-browsing, writing to anywhere other than the files passed on the command line, and reading the rc file. Pair it with --view (-v) for read-only viewing — typing produces a beep. Together they make nano safe to expose as a forced-command editor in a restricted SSH shell or a ForceCommand handler.

# Read-only viewer with no shell-out and no save
nano -Rv /var/log/syslog

# As an SSH forced command — user can only edit one specific file
# in ~/.ssh/authorized_keys:
#   command="nano -R /etc/myapp/config.yml",no-pty,no-port-forwarding ssh-ed25519 AAAA…

Output: (none — interactive read-only session)

Common pitfalls

1. Ctrl-S freezes the terminal — on terminals where stty -ixon hasn't been run, ^S is XON/XOFF flow control; nano locks until you press ^Q. Fix: add stty -ixon to your shell rc, or run nano --modernbindings which assumes flow control is already disabled.
2. macOS ships nano 2.x — /usr/bin/nano on macOS is years out of date and is missing --modernbindings, soft-wrap-at-blanks, --positionlog, and most of the post-5.0 features. brew install nano and ensure /opt/homebrew/bin (Apple Silicon) or /usr/local/bin (Intel) precedes /usr/bin in $PATH.
3. tabstospaces doesn't fix existing tabs — it only converts new Tab keystrokes. Run expand -t 4 file > file.tmp && mv file.tmp file outside nano, or pipe the buffer through expand via ^T expand -t 4.
4. unset nowrap and the breaklonglines confusion — nowrap was deprecated; the option is now breaklonglines (off by default). Setting set nowrap in 8.x+ logs a warning to the bottom bar and is silently ignored.
5. file:line notation suddenly broke (8.1+) — colon-parsing is no longer automatic. Either pass --colonparsing or set colonparsing in ~/.nanorc. Files with literal colons in their names (rare on Unix, common on Windows shares) work as expected when the flag is off.
6. Mac terminals eat M- keys — Terminal.app and iTerm2 default to sending Alt as a high-bit byte, which nano can't decode. Enable "Use Option as Meta key" in the terminal preferences, or learn the Esc-then-key fallback (Esc U for undo instead of M-U).
7. The Mark stays set across cuts — after M-A you must press M-A again (or ^C from the cancel menu) to clear the mark, otherwise every subsequent ^K cuts the marked region instead of the line. The status bar shows [ Mark Set ] while it's active.
8. include glob silently drops syntaxes with errors — a typo inside /usr/share/nano/python.nanorc doesn't fail nano; the bad syntax is just disabled and you'll wonder why python files lost their colors. Run nano -z to see which syntaxes actually loaded.
9. ~/.nanorc line-endings matter on Windows — a CRLF-terminated rc file confuses the parser; convert with dos2unix ~/.nanorc after editing in a Windows tool.

Real-world recipes

Sane defaults in one command

Drop a known-good rc file into place for a new dev box.

cat > ~/.nanorc <<'RC'
set linenumbers
set autoindent
set tabsize 4
set tabstospaces
set softwrap
set smarthome
set mouse
set indicator
set constantshow
set historylog
set positionlog
include "/usr/share/nano/*.nanorc"
RC

Output: (none — file written)

Strip trailing whitespace on every save (8.5+)

Wire sed as a per-language formatter so ^T F cleans up before write.

cat >> ~/.nanorc <<'RC'
extendsyntax python  formatter "sed -i 's/[[:space:]]*$//'"
extendsyntax c       formatter "sed -i 's/[[:space:]]*$//'"
extendsyntax sh      formatter "sed -i 's/[[:space:]]*$//'"
RC

Output: (none — rc-file appended)

Format a buffer through an external linter

^T then L invokes the configured linter; the output gets parsed for file:line:col: message and turns into per-line annotations you can jump between with M-] and M-[.

cat >> ~/.nanorc <<'RC'
extendsyntax python linter "ruff check --output-format=concise --stdin-filename %"
RC

Output: (none — rc-file appended)

Editing as a non-root user but saving as root

Use ^T to pipe the buffer through sudo tee. This works without leaving nano and without restarting under sudo.

# Inside nano, with the buffer modified:
#   ^T            → opens command prompt
#   sudo tee /etc/hosts > /dev/null
#   Enter

Output:

[ Wrote 12 lines ]

Diffing two files side-by-side

nano itself has no split-screen, but two buffers + M-,/M-. is enough for short files. For longer diffs, shell out via ^T.

nano file-a.txt file-b.txt
# inside:
#   ^T diff file-a.txt file-b.txt
#   Enter

Output:

3c3
< the quick brown fox
---
> the lazy brown fox

Resume editing where you left off

positionlog makes nano restore the cursor (and anchors, on 8.5+) to where you saved-and-exited. Combined with historylog, search/replace strings also survive a restart.

cat >> ~/.nanorc <<'RC'
set positionlog
set historylog
RC

nano ~/notes.md      # edit, ^O, ^X
nano ~/notes.md      # reopens at the prior cursor position

Output: (none — interactive session)

Use nano as Git's editor for commit messages

Most distros default to nano already, but make it explicit.

git config --global core.editor "nano -r 72 --constantshow"
# -r 72  → hard-wrap commit body at 72 columns (Git convention)
# --constantshow → see line/column while writing

Output: (none — git config updated)

Sources

References consulted while writing this article. Links open in a new tab.

• nano — News (official changelog) — Per-version release notes 7.0 through 9.0, including the 9.0 horizontal-scrolling change, 8.7 OSC-52 clipboard via ||command, 8.6 relative-line GotoLine prefixes, and 8.5 anchor persistence.
• nanorc(5) — Configuration reference — Authoritative set option list, value-option defaults (tabsize 8, fill -8, matchbrackets), color directive grammar, and the syntax/color/extendsyntax/bind/unbind/include directive syntax used in the Configuration section.
• nano(1) — Command-line reference — Flag list used to build the Essential options table, plus the --restricted, --view, --colonparsing, and --listsyntaxes semantics described under Restricted mode and the syntax sections.
• Overview of nano's shortcuts — Canonical key-to-function map used to assemble the Essential keybindings table and verify the 8.0 modernbindings remap.
• Phoronix — Nano 8.0 released with modernbindings — Confirmation that --modernbindings debuted in 8.0 and details on the executable-name-prefix auto-activation behaviour referenced in the Modern bindings section.
• LWN — GNU nano 8.0 — Background on the 8.0 binding overhaul (default ^F/^B search) and the rationale for keeping the classic hints visible under the modern remap.
• OSnews — GNU nano gains optional modern keybindings — Coverage of the Debian edit-prefix auto-activation and the trade-off that on-screen hints don't redraw under the remap.