Linux command: nano

Something is broken on a server, you are connected over SSH, and one line in a configuration file needs to change. This is the moment where a lot of people freeze, because the editor that opens is either an editor they cannot leave or an editor they have never seen. nano is the answer to both problems: it is already installed on nearly every Linux system, it prints its own instructions along the bottom of the screen, and you can walk away from it without searching the internet for how to quit.

2. Where the Name Comes From

Ask nano what its name means and it tells you, in the first line of its own manual page:

$ man nano
NAME
       nano - Nano's ANOther editor, inspired by Pico

That is a recursive joke in the GNU tradition, the same style as GNU standing for "GNU's Not Unix". The name expands into a phrase that contains the name.

It was not called nano at first. Chris Allegretta wrote the original in late 1999 and called it TIP, short for Tip Isn't Pico, because it was a clone of an editor called Pico. That name lasted only a few months. There was already a Unix program called tip, an old tool that "establishes a full duplex terminal connection to a remote host", which shipped with many older Unix systems and with Solaris. Two programs cannot own the same command name, so in January 2000, at version 0.7.4, TIP became nano. The project's own release notes record the moment:

2000.01.09 - As of this version (0.7.4), TIP has officially
             been renamed to nano.

The new name carries a second joke that is easy to miss. Both pico and nano are SI prefixes for very small numbers, but they are not the same size: pico means a trillionth and nano means a billionth. A nano is a thousand times larger than a pico. For a clone that set out to keep Pico's interface while adding the features it lacked, that is exactly the right name.

The GNU in front came later, when nano was adopted as an official GNU package. That is why the title bar says GNU nano and why the program is licensed under the GPL, which turns out to be the whole reason it exists at all.

4. Simple Use Cases

4.1 Opening a File

Give nano a filename. If the file exists it opens; if it does not, nano starts an empty buffer and creates the file when you save.

$ nano /etc/hosts          # open an existing file
$ nano newfile.txt         # start a new one

Where it is missing, it is a small package and every distribution has it:

$ nano --version                 # is it here at all?
$ sudo apt install nano          # Debian, Ubuntu
$ sudo dnf install nano          # Fedora, RHEL
$ sudo pacman -S nano            # Arch
$ apk add nano                   # Alpine

That last line is there because of a machine on my own desk. I put Alpine Linux on an old thin client with an 8 GB SSD, because a normal Ubuntu install simply would not fit, and then found there was no nano to edit anything with. Alpine ships BusyBox instead, where vi is a symlink to /bin/busybox and there is no second editor at all. One command fixed it:

$ apk update && apk add nano

This is worth knowing even if you never touch a thin client, because Alpine is the usual base image for Docker containers. Open a shell inside one and you meet the same empty toolbox. The install is not heavy either: on Alpine nano is about 300 KB, or roughly 0.7 MB once its ncurses dependencies come with it, which is a reasonable trade even on a very small disk.

Run nano with no filename at all and you get an empty buffer with a friendly greeting:

  GNU nano 7.2                       New Buffer

               [ Welcome to nano.  For basic help, type Ctrl+G. ]
^G Help      ^O Write Out ^W Where Is  ^K Cut       ^T Execute   ^C Location
^X Exit      ^R Read File ^\ Replace   ^U Paste     ^J Justify   ^/ Go To Line

You can also jump straight to a line, which is useful when a program has just told you that something is wrong on line 47:

$ nano +47 /etc/apache2/apache2.conf      # open with the cursor on line 47
$ nano +47,10 file.txt                    # line 47, column 10
$ nano +/ServerName /etc/apache2/apache2.conf   # jump to the first match instead

4.2 Saving Your Work

The shortcut row calls saving Write Out, which is ^O. Press it and nano asks where to write, offering the current name:

File Name to Write: notes.txt
^G Help             M-D DOS Format      M-A Append          M-B Backup File
^C Cancel           M-M Mac Format      M-P Prepend         ^T Browse

Press Enter to accept the name and the file is written. Type a different name first and you have saved a copy instead, which is the quickest way to keep a backup before you change something risky.

Modern nano also has a plain save on ^S, the same key every graphical program uses. It writes the file immediately with no prompt at all:

                                [ Wrote 1 line ]

Once a buffer has unsaved changes, the title bar marks it with an asterisk, so you can always tell at a glance:

  GNU nano 7.2                     notes.txt *

4.3 Getting Out Again

This is the question that sends people to a search engine, and in nano the answer is written on the screen: ^X for Exit. If you have not changed anything, nano simply closes. If you have, it asks first:

Save modified buffer?
 Y Yes
 N No           ^C Cancel

That prompt is safe to answer honestly, because of how nano works. Opening a file does not lock or change it. nano reads a copy into memory, the buffer, and every keystroke edits the copy. The file on disk is untouched until you save, which is why answering N genuinely throws away only your changes and leaves the original exactly as it was.

Three keys, three outcomes, and none of them can catch you out:

• Y saves and then asks for the filename, exactly like ^O.
• N throws your changes away and quits.
• ^C cancels and puts you back in the file.

That prompt is the single biggest reason to reach for nano when you are tired or under pressure at two in the morning. It is very hard to lose work by accident.

4.4 Finding Things

Searching is ^W, labelled Where Is. Type your text and press Enter, and nano jumps to the next match. Press ^W then Enter again to repeat the same search.

Search:
^G Help         M-C Case Sens   M-B Backwards   ^P Older        ^T Go To Line
^C Cancel       M-R Reg.exp.    ^R Replace      ^N Newer

Look at that row of options, because it answers questions people usually assume nano cannot handle. M-C makes the search case sensitive, M-B searches backwards, and M-R switches to regular expressions. Search and replace is ^\, or ^R from inside the search prompt.

4.5 Cut and Paste

The one shortcut worth memorising immediately is ^K, which cuts the whole current line. Press it several times in a row and the lines pile up together, so ^K^K^K cuts three lines as one block. ^U pastes them back.

^K    cut this line (repeat to cut several lines as one block)
^U    paste

This pair is how most real config editing gets done: cut a line, paste it somewhere else, or cut it, retype it correctly, and move on. Note that these are nano's own clipboard, not the system clipboard, so pasting into another window still uses your terminal's normal paste.

6. Advanced Use Cases

6.1 The Config File

nano reads settings from /etc/nanorc for the whole system and ~/.nanorc for you personally. The system file on Debian and Ubuntu is nearly all comments; only a few lines are actually active:

$ grep -vE '^\s*#|^\s*$' /etc/nanorc
set historylog
set locking
set stateflags
include "/usr/share/nano/*.nanorc"

Everything else is switched off and waiting. Your own ~/.nanorc overrides it, and this is a reasonable starting point:

set linenumbers          # show line numbers
set softwrap             # wrap long lines on screen only
set autoindent           # keep the indent of the previous line
set tabsize 4            # a tab looks four columns wide
set tabstospaces         # pressing Tab inserts spaces
set constantshow         # always show the cursor position
set backup               # keep a ~ backup of the previous version
set mouse                # allow clicking to move the cursor

Every option in that file has a command-line twin, so anything you can set permanently you can also try once with a flag before committing to it.

6.2 Syntax Highlighting

That include line in /etc/nanorc is doing more than it looks. It loads a directory of syntax definitions, and on a standard Ubuntu install there are 42 of them:

$ ls /usr/share/nano/*.nanorc | wc -l
42

$ ls /usr/share/nano/ | head
asm.nanorc      c.nanorc        css.nanorc      go.nanorc
autoconf.nanorc changelog.nanorc default.nanorc  groff.nanorc
awk.nanorc      cmake.nanorc    elisp.nanorc    guile.nanorc

nano picks one by matching the filename, so opening script.sh, site.conf, or playbook.yml colours the file automatically with no setup. If a file has no extension, force it with -Y:

$ nano -Y sh /usr/local/bin/deploy      # treat it as a shell script

6.3 Tabs Versus Spaces

This matters more on a server than it does in a text document, because several file formats care deeply about the difference. Python and YAML want spaces. Makefiles require real tab characters and break in confusing ways without them.

$ nano -E playbook.yml     # Tab inserts spaces
$ nano Makefile            # leave it alone: this file needs real tabs

Section 7.2 covers a related behaviour that overrides both of these and surprises almost everyone.

6.4 Line Endings: The Other Invisible Character

Tabs are not the only thing you cannot see. Unix ends a line with a single line feed (\n); Windows ends it with a carriage return and a line feed (\r\n). A shell script written on Windows and uploaded to a server fails with errors that make no sense, because the stray \r becomes part of the last word on every line.

nano handles this well, and tells you when it happens. Open a file with Windows line endings and the status line says so:

$ nano dos.txt

                  [ Read 2 lines (Converted from DOS format) ]

The important part is what happens next. nano remembers the format and writes it back the same way. Editing a Windows file on a Linux server does not silently convert it:

$ file dos.txt
dos.txt: ASCII text, with CRLF line terminators      # before

$ nano dos.txt        # make an edit, save, exit
$ file dos.txt
dos.txt: ASCII text, with CRLF line terminators      # after: unchanged

That is the right default, but it means nano will not fix a broken script for you either. When you actually want Unix endings, ask for them with -u (short for unix):

$ nano -u script.sh    # edit, save, exit
$ file script.sh
script.sh: ASCII text                                 # the CRs are gone

You can also toggle the format for a single save: press ^O and the prompt bar offers M-D for DOS format and M-M for Mac format, which switch the file over as you write it.

The third flag is the diagnostic one. -N (short for noconvert) tells nano not to convert on reading, so the carriage returns appear in the text as ^M and you can see exactly what you are dealing with:

$ nano -N dos.txt

  GNU nano 7.2                     dos.txt
first line^M
second line^M

                                [ Read 2 lines ]

If a script is failing for no visible reason, that is a fast way to prove the line endings are the cause before you start editing anything.

6.5 Rebinding Keys

If a shortcut fights your muscle memory, change it in ~/.nanorc. This is how people who came from other editors make nano feel normal:

bind ^Z undo main          # Ctrl+Z undoes, as everywhere else
bind ^Y redo main
bind ^F whereis main       # Ctrl+F searches
bind ^Q exit all

The last word is the context the binding applies in: main for the editing window, all for everywhere including prompts.

That first line is safer than it used to be. Older nano suspended on ^Z, dropping you to the shell until you typed fg, which startled people who expected an undo. Since nano 6.0 the plain keystroke does not suspend; it tells you what to press instead:

                           [ To suspend, type ^T^Z ]

So rebinding ^Z to undo now costs you nothing, and if you actually want single-key suspension back you ask for it explicitly with bind ^Z suspend main.

6.6 Restricted Mode

The -R flag (short for restricted) stops nano from reading or writing any file other than the one it was given. No saving elsewhere, no reading other files in, no shell commands, no suspending.

$ nano -R /etc/motd

This exists for situations where nano is launched on someone's behalf and should not become a way to roam the filesystem. If you ever set up a restricted account that can edit one file, this is the flag that makes that safe.

6.7 Running Commands Without Leaving

^T is labelled Execute. Press it and the shortcut rows change into a menu that is easy to miss, because it is where several separate features live:

Command to execute:
^G Help         M-F New Buffer  ^S Spell Check  ^J Full Justify ^V Cut Till End
^C Cancel       M-\ Pipe Text   ^Y Linter       ^O Formatter    ^Z Suspend

Type a command and its output is inserted into your buffer, which is genuinely useful when you are writing a config and need a value from the system:

^T   then type:  ip -4 addr show
     the command output lands in the file

M-F first sends the output to a new buffer instead, leaving your file untouched. M-\ pipes the buffer through a command and replaces it with the result, so you can sort a list or reformat a block using any tool on the system. The spell checker, linter and formatter hang off the same menu where a syntax defines them.

6.8 nano as the System Editor

A lot of programs open "the editor" without you choosing one: crontab -e, git commit, visudo, sudoedit. On Debian and Ubuntu that editor is nano, wired up through the alternatives system:

$ update-alternatives --display editor
editor - auto mode
  link best version is /bin/nano
  link currently points to /bin/nano
  link editor is /usr/bin/editor

Two environment variables override it for your account. EDITOR is the general one and VISUAL takes priority in programs that check both:

export EDITOR=nano
export VISUAL=nano        # put these in ~/.bashrc to make them stick

Git keeps its own setting, which wins over both variables, so set that one separately if you write commit messages on the command line:

$ git config --global core.editor "nano"
$ git config --global core.editor        # check what it is now
nano

To change it system-wide on Debian or Ubuntu, use select-editor for your own account or update-alternatives --config editor as root. This is worth setting deliberately: the worst moment to discover your server opens vi by default is halfway through a visudo session.

8. Best Practices

• Learn four keys and you are done. ^O save, ^X exit, ^W search, ^K cut. Everything else can be read off the screen when you need it.
• Back up before you edit anything important. Either cp file file.bak first, or use ^O with a different filename, or turn on set backup permanently.
• Use sudoedit instead of sudo nano. Same result, and the editor never runs as root.
• Open logs and other people's configs with -v. Read-only mode removes the chance of a stray keystroke changing a file you only meant to look at.
• Turn on line numbers. set linenumbers in ~/.nanorc pays for itself the first time a service reports an error on line 214.
• Check the file after you save it. A quick diff against your backup, or the service's own config test (nginx -t, apachectl configtest, sshd -t), catches mistakes before a restart does.
• Know your fallback. Learn just enough vi to open a file, change a line and save (i, Esc, :wq). One day nano will not be installed.
• Do not fight the editor. If nano is slowing you down on real editing work, that is a signal to learn vim, not to add fifty rebindings.
• Reach for the documentation. ^G inside nano is a complete key reference, and it is always there.

$ man nano             # the program
$ man nanorc           # every configuration option
$ nano --help          # the flags, with their long forms
  ^G                   # the built-in key reference, from inside nano

10. Summary

nano is the editor you use when the point is the file, not the editing. It asks nothing of you up front and it is very hard to lose work in.

• nano is a modeless terminal editor that prints its own shortcuts along the bottom. ^ means Ctrl, M- means Alt, and pressing Esc twice works as Ctrl when your keyboard fights you.
• The name is a recursive joke, "Nano's ANOther editor". It started as TIP (Tip Isn't Pico) and was renamed in January 2000 because the tip command already existed.
• It exists because Pico, the editor inside the Pine mail client, had a licence that kept it out of Linux distributions. Chris Allegretta wrote a GPL clone in a weekend in late 1999.
• The four keys that matter: ^O write out, ^X exit, ^W search, ^K cut with ^U to paste. ^S saves silently.
• It does have undo (M-U), redo (M-E), regular expression search (M-R), and text selection (M-A, or Shift with the arrow keys).
• ~/.nanorc configures it permanently; every setting has a command-line flag twin. Syntax highlighting is automatic, from 42 definitions in /usr/share/nano.
• nano -w is advice from before 2019. nano 4.0 made it the default, and the wrapping danger only ever applied to lines you typed into, at whitespace.
• Tab does not always insert a tab: the shipped YAML syntax sets tabgives " ", which overrides tabstospaces.
• nano detects Windows line endings, says so, and writes them back unchanged. -u converts to Unix, -N shows the carriage returns as ^M so you can diagnose a failing script.
• A dropped connection leaves your unsaved work in filename.save, and an open file is guarded by a .swp lock file.
• Prefer sudoedit over sudo nano, and learn just enough vi for the systems where nano is not installed.

This is the quick reference worth keeping:

nano file              open a file
nano +47 file          open with the cursor on line 47
nano -l file           show line numbers
nano -v file           read-only, cannot change the file
nano -E file           Tab inserts spaces
nano -u file           save with Unix (LF) line endings
nano -N file           show Windows carriage returns as ^M
sudoedit file          edit a root-owned file without a root editor

^O    write out (save)          ^X    exit
^S    save, no prompt           ^G    the full key reference
^W    search                    ^\    search and replace
^K    cut a line                ^U    paste
M-U   undo                      M-E   redo
M-A   set the mark              M-6   copy the marked region
^/    go to line number         ^C    show cursor position
^T    run an external command   ^R    read another file in
M-]   jump to matching bracket  ^Y/^V page up / page down

Small tools like nano are where a lot of server work actually happens: the one line in a virtual host, the setting in a cron file, the typo that took a site offline at four in the afternoon.