micro

A modern and intuitive terminal-based text editor

25,033

1,169

25,033

910

View on GitHub

Top Related Projects

cmatrix

3,966

Terminal based "The Matrix" like implementation

kilo

7,320

A text editor in less than 1000 LOC with syntax highlight and search.

cmus

5,533

Small, fast and powerful console music player for Unix-like operating systems.

Quick Overview

Micro is a modern and intuitive terminal-based text editor. It aims to be easy to use and intuitive, while also taking advantage of the full capabilities of modern terminals. Micro is cross-platform and supports features like syntax highlighting, mouse support, and plugins.

Pros

User-friendly and intuitive interface, especially for users familiar with GUI text editors
Extensive feature set including syntax highlighting, mouse support, and plugin system
Cross-platform compatibility (Linux, macOS, Windows, and others)
Active development and community support

Cons

May not be as powerful or customizable as more advanced text editors like Vim or Emacs
Limited ecosystem compared to more established editors
Some users may find the default keybindings unfamiliar if they're used to traditional terminal editors

Getting Started

To install Micro on various platforms:

# macOS (using Homebrew)
brew install micro

# Linux (using snap)
snap install micro --classic

# Windows (using Scoop)
scoop install micro

# Using Go
go install github.com/zyedidia/micro/v2@latest

After installation, you can open a file with:

micro filename.txt

Basic usage:

Ctrl+Q to quit
Ctrl+S to save
Ctrl+F to find
Ctrl+G to find next
Ctrl+Z to undo
Ctrl+Y to redo

For more information and advanced usage, refer to the official documentation at https://github.com/zyedidia/micro#readme.

Competitor Comparisons

cmatrix

3,966

Terminal based "The Matrix" like implementation

Pros of cmatrix

Lightweight and fun visual effect for terminal environments
Simple to use with minimal configuration required
Cross-platform compatibility (Unix-like systems)

Cons of cmatrix

Limited functionality beyond the matrix-style animation
Less practical for everyday text editing tasks
Fewer customization options compared to micro

Code Comparison

cmatrix (main animation loop):

for (j = 0; j <= LINES; j++) {
    for (i = 0; i <= COLS - 1; i++) {
        move(j, i);
        if (matrix[i][j].val == 1)
            addch(matrix[i][j].c | COLOR_PAIR(1));
        else
            addch(' ');
    }
}

micro (basic text insertion):

func (v *View) Insert(char rune) {
    v.Cursor.InsertRune(char)
    v.Cursor.Move(1, 0)
    v.Relocate()
}

Summary

While cmatrix provides an entertaining visual effect for terminals, micro offers a more practical text editing solution with extensive features. cmatrix is ideal for creating a fun, nostalgic atmosphere, whereas micro serves as a fully-functional text editor with syntax highlighting, multiple buffers, and customizable keybindings. The choice between the two depends on whether the user needs a visual effect or a robust text editing tool.

kilo

7,320

A text editor in less than 1000 LOC with syntax highlight and search.

Pros of Kilo

Extremely lightweight and minimalistic (less than 1,000 lines of C code)
Educational resource for learning how to build a text editor from scratch
No dependencies, easy to compile and run on various systems

Cons of Kilo

Limited features compared to more full-featured editors
Lacks syntax highlighting and advanced editing capabilities
Not actively maintained or updated

Code Comparison

Kilo (raw terminal handling):

void editorRefreshScreen() {
  write(STDOUT_FILENO, "\x1b[2J", 4);
  write(STDOUT_FILENO, "\x1b[H", 3);
  editorDrawRows();
  editorDrawStatusBar();
  editorDrawMessageBar();
  write(STDOUT_FILENO, "\x1b[H", 3);
}

Micro (using termbox-go for terminal handling):

func (t *View) draw(buf *Buffer) {
  t.drawLines(buf)
  t.drawStatus(buf)
  t.drawTabbar()
  screen.Show()
}

Micro offers a more feature-rich and user-friendly experience, with syntax highlighting, multiple buffers, and extensive plugin support. It's actively maintained and has a larger community. However, it's more complex and has dependencies.

Kilo is ideal for learning and minimalism, while Micro is better suited for practical, everyday use as a feature-complete text editor.

atom

60,150

:atom: The hackable text editor

Pros of Atom

Extensive plugin ecosystem with thousands of packages
Rich UI with customizable themes and layouts
Built-in Git integration for version control

Cons of Atom

Slower startup time and higher resource usage
Larger installation size and more complex setup
Less suitable for quick edits or remote server use

Code Comparison

Atom (CoffeeScript):

class MyView extends View
  @content: ->
    @div class: 'my-view', =>
      @h1 'Hello, Atom!'
      @p 'This is a custom view.'

Micro (Go):

func (h *Handler) drawStatusLine() {
    w, _ := h.win.Size()
    h.win.SetContent(h.win.Height()-1, 0, w, 1, tcell.StyleDefault, h.statusLine)
}

Summary

Atom is a feature-rich, extensible editor with a large community and plugin ecosystem, making it suitable for complex development environments. However, it can be resource-intensive and slower to start up.

Micro, on the other hand, is a lightweight, terminal-based editor written in Go. It offers faster performance and lower resource usage, making it ideal for quick edits and remote server work. However, it lacks the extensive UI customization and plugin ecosystem of Atom.

The choice between the two depends on the user's needs, with Atom excelling in feature-rich environments and Micro in lightweight, efficient editing scenarios.

cmus

5,533

Small, fast and powerful console music player for Unix-like operating systems.

Pros of cmus

Lightweight and efficient console-based music player
Extensive audio format support and library management features
Highly customizable with keybindings and color schemes

Cons of cmus

Limited to audio playback, not a general-purpose text editor
Steeper learning curve for users unfamiliar with console interfaces
Less active development compared to micro

Code comparison

cmus (C):

static int cmus_play_file(const char *filename)
{
    struct track_info *ti;
    ti = cmus_get_track_info(filename);
    if (!ti)
        return -1;
    player_set_file(ti);
    return 0;
}

micro (Go):

func (v *View) Save(w io.Writer) error {
    v.Buf.UpdateRules()
    if v.Type.Format {
        return v.Buf.Format(w)
    }
    return v.Buf.SaveString(w)
}

While both projects are terminal-based applications, they serve different purposes. cmus is a music player focused on audio playback and library management, while micro is a text editor designed for ease of use and extensibility. The code snippets reflect their respective functionalities, with cmus handling audio file playback and micro managing text file operations.

emacs

4,412

Mirror of GNU Emacs

Pros of Emacs

Extensive customization and extensibility through Emacs Lisp
Vast ecosystem of packages and modes for various programming languages and tasks
Powerful built-in features like Org mode for organization and productivity

Cons of Emacs

Steeper learning curve and more complex configuration
Larger resource footprint and slower startup time
Less intuitive for users accustomed to modern text editors

Code Comparison

Micro:

func (h *BufPane) HandleEvent(event tcell.Event) {
    switch e := event.(type) {
    case *tcell.EventKey:
        h.HandleKeyEvent(e)
    case *tcell.EventMouse:
        h.HandleMouseEvent(e)
    }
}

Emacs:

(defun handle-event (event)
  (cond
   ((eq (car event) 'key-press)
    (handle-key-event event))
   ((eq (car event) 'mouse-click)
    (handle-mouse-event event))))

Both examples show event handling, but Micro uses Go's switch statement for type-based dispatch, while Emacs uses Lisp's cond for pattern matching. Micro's approach is more typical of modern languages, while Emacs' reflects its Lisp heritage and extensibility.

vim

36,358

The official Vim repository

Pros of Vim

Extensive plugin ecosystem and customization options
Powerful and efficient text editing capabilities with modal editing
Large, established community and long-term support

Cons of Vim

Steep learning curve for beginners
Configuration can be complex and time-consuming
Default interface may appear outdated compared to modern editors

Code Comparison

Vim configuration (.vimrc):

set nocompatible
filetype plugin indent on
syntax on
set number
set expandtab

Micro configuration (settings.json):

{
    "colorscheme": "default",
    "tabsize": 4,
    "autoindent": true,
    "syntax": true
}

Summary

Vim is a powerful and highly customizable text editor with a steep learning curve, while Micro is a modern, user-friendly alternative with simpler configuration. Vim offers extensive features and a large community, but may be overwhelming for beginners. Micro provides an easier entry point for new users, but may lack some advanced capabilities found in Vim. Both editors have their strengths and cater to different user preferences and needs.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

micro is a terminal-based text editor that aims to be easy to use and intuitive, while also taking advantage of the capabilities of modern terminals. It comes as a single, batteries-included, static binary with no dependencies; you can download and use it right now!

As its name indicates, micro aims to be somewhat of a successor to the nano editor by being easy to install and use. It strives to be enjoyable as a full-time editor for people who prefer to work in a terminal, or those who regularly edit files over SSH.

Here is a picture of micro editing its source code.

Screenshot

To see more screenshots of micro, showcasing some of the default color schemes, see here.

You can also check out the website for Micro at https://micro-editor.github.io.

Features
Installation
Usage
Documentation and Help
Contributing

Features

Easy to use and install.
No dependencies or external files are needed â just the binary you can download further down the page.
Multiple cursors.
Common keybindings (Ctrl-s, Ctrl-c, Ctrl-v, Ctrl-z, â¦).
- Keybindings can be rebound to your liking.
Sane defaults.
- You shouldn't have to configure much out of the box (and it is extremely easy to configure).
Splits and tabs.
nano-like menu to help you remember the keybindings.
Extremely good mouse support.
- This means mouse dragging to create a selection, double click to select by word, and triple click to select by line.
Cross-platform (it should work on all the platforms Go runs on).
- Note that while Windows is supported, Mingw/Cygwin is not (see below).
Plugin system (plugins are written in Lua).
- micro has a built-in plugin manager to automatically install, remove, and update plugins.
Built-in diff gutter.
Simple autocompletion.
Persistent undo.
Automatic linting and error notifications.
Syntax highlighting for over 130 languages.
Color scheme support.
- By default, micro comes with 16, 256, and true color themes.
True color support (set the MICRO_TRUECOLOR environment variable to 1 to enable it).
Copy and paste with the system clipboard.
Small and simple.
Easily configurable.
Macros.
Smart highlighting of trailing whitespace and tab vs space errors.
Common editor features such as undo/redo, line numbers, Unicode support, soft wrapping, â¦

Installation

To install micro, you can download a prebuilt binary, or you can build it from source.

If you want more information about ways to install micro, see this wiki page.

Use micro -version to get the version information after installing. It is only guaranteed that you are installing the most recent stable version if you install from the prebuilt binaries, Homebrew, or Snap.

A desktop entry file and man page can be found in the assets/packaging directory.

Pre-built binaries

Pre-built binaries are distributed in releases.

To uninstall micro, simply remove the binary, and the configuration directory at ~/.config/micro.

Quick-install script

curl https://getmic.ro | bash

The script will place the micro binary in the current directory. From there, you can move it to a directory on your path of your choosing (e.g. sudo mv micro /usr/bin). See its GitHub repository for more information.

Eget

With Eget installed, you can easily get a pre-built binary:

eget zyedidia/micro

Use --tag VERSION to download a specific tagged version.

eget --tag nightly zyedidia/micro # download the nightly version (compiled every day at midnight UTC)
eget --tag v2.0.8 zyedidia/micro  # download version 2.0.8 rather than the latest release

You can install micro by adding --to /usr/local/bin to the eget command, or move the binary manually to a directory on your $PATH after the download completes.

See Eget for more information.

Package managers

You can install micro using Homebrew on Mac:

brew install micro

Note for Mac: All micro keybindings use the control or alt (option) key, not the command key. By default, macOS terminals do not forward alt key events. To fix this, please see the section on macOS terminals further below.

On Linux, you can install micro through snap

snap install micro --classic

Micro is also available through other package managers on Linux such as dnf, AUR, Nix, and package managers for other operating systems. These packages are not guaranteed to be up-to-date.

Linux:
- distro-specific package managers:
  - dnf install micro (Fedora).
  - apt install micro (Ubuntu and Debian).
  - pacman -S micro (Arch Linux).
  - emerge app-editors/micro (Gentoo).
  - zypper install micro-editor (SUSE)
  - eopkg install micro (Solus).
  - pacstall -I micro (Pacstall).
  - apt-get install micro (ALT Linux)
  - See wiki for details about CRUX, Termux.
- distro-agnostic package managers:
  - nix profile install nixpkgs#micro (with Nix and flakes enabled)
  - flox install micro (with Flox)
Windows: Chocolatey, Scoop and WinGet.
- choco install micro.
- scoop install micro.
- winget install zyedidia.micro
OpenBSD: Available in the ports tree and also available as a binary package.
- pkg_add -v micro.
NetBSD, macOS, Linux, Illumos, etc. with pkgsrc-current:
- pkg_add micro
macOS: Available in package managers.
- sudo port install micro (with MacPorts)
- brew install micro (with Homebrew)
- nix profile install nixpkgs#micro (with Nix and flakes enabled)
- flox install micro (with Flox)

Note for Linux desktop environments:

For interfacing with the local system clipboard, the following tools need to be installed:

For X11, xclip or xsel
For Wayland, wl-clipboard

Without these tools installed, micro will use an internal clipboard for copy and paste, but it won't be accessible to external applications.

Building from source

If your operating system does not have a binary release, but does run Go, you can build from source.

Make sure that you have Go version 1.16 or greater and Go modules are enabled.

git clone https://github.com/zyedidia/micro
cd micro
make build
sudo mv micro /usr/local/bin # optional

The binary will be placed in the current directory and can be moved to anywhere you like (for example /usr/local/bin).

The command make install will install the binary to $GOPATH/bin or $GOBIN.

You can install directly with go get (go get github.com/zyedidia/micro/cmd/micro) but this isn't recommended because it doesn't build micro with version information (necessary for the plugin manager), and doesn't disable debug mode.

Fully static binary

By default, the micro binary will dynamically link with core system libraries (this is generally recommended for security and portability). However, there is a fully static prebuilt binary that is provided for amd64 as linux-static.tar.gz, and to build a fully static binary from source, run

CGO_ENABLED=0 make build

macOS terminal

If you are using macOS, you should consider using iTerm2 instead of the default terminal (Terminal.app). The iTerm2 terminal has much better mouse support as well as better handling of key events. For best keybinding behavior, choose xterm defaults under Preferences->Profiles->Keys->Presets..., and select Esc+ for Left Option Key in the same menu. The newest versions also support true color.

If you still insist on using the default Mac terminal, be sure to set Use Option key as Meta key under Preferences->Profiles->Keyboard to use option as alt.

WSL and Windows Console

If you use micro within WSL, it is highly recommended that you use the Windows Terminal instead of the default Windows Console.

If you must use Windows Console for some reason, note that there is a bug in Windows Console WSL that causes a font change whenever micro tries to access the external clipboard via powershell. To fix this, use an internal clipboard with set clipboard internal (though your system clipboard will no longer be available in micro).

Colors and syntax highlighting

If you open micro and it doesn't seem like syntax highlighting is working, this is probably because you are using a terminal which does not support 256 color mode. Try changing the color scheme to simple by pressing Ctrl-e in micro and typing set colorscheme simple.

If you are using the default Ubuntu terminal, to enable 256 color mode make sure your TERM variable is set to xterm-256color.

Many of the Windows terminals don't support more than 16 colors, which means that micro's default color scheme won't look very good. You can either set the color scheme to simple, or download and configure a better terminal emulator than the Windows default.

Cygwin, Mingw, Plan9

Cygwin, Mingw, and Plan9 are unfortunately not officially supported. In Cygwin and Mingw, micro will often work when run using the winpty utility:

winpty micro.exe ...

Micro uses the amazing tcell library, but this means that micro is restricted to the platforms tcell supports. As a result, micro does not support Plan9 or Cygwin (although this may change in the future). Micro also doesn't support NaCl (which is deprecated anyway).

Usage

Once you have built the editor, start it by running micro path/to/file.txt or micro to open an empty buffer.

micro also supports creating buffers from stdin:

ip a | micro

You can move the cursor around with the arrow keys and mouse.

You can also use the mouse to manipulate the text. Simply clicking and dragging will select text. You can also double click to enable word selection, and triple click to enable line selection.

Documentation and Help

micro has a built-in help system which you can access by pressing Ctrl-e and typing help. Additionally, you can view the help files here:

I also recommend reading the tutorial for a brief introduction to the more powerful configuration features micro offers.

There is also an unofficial Discord, which you can join at https://discord.gg/nhWR6armnR.

Contributing

If you find any bugs, please report them! I am also happy to accept pull requests from anyone.

You can use the GitHub issue tracker to report bugs, ask questions, or suggest new features.

For a more informal setting to discuss the editor, you can join the Gitter chat or the Discord. You can also use the Discussions section on Github for a forum-like setting or for Q&A.

Sometimes I am unresponsive, and I apologize! If that happens, please ping me.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

Top Related Projects

Quick Overview

Pros

Cons

Getting Started

Competitor Comparisons

Pros of cmatrix

Cons of cmatrix

Code Comparison

Summary

Pros of Kilo

Cons of Kilo

Code Comparison

Pros of Atom

Cons of Atom

Code Comparison

Summary

Pros of cmus

Cons of cmus

Code comparison

Pros of Emacs

Cons of Emacs

Code Comparison

Pros of Vim

Cons of Vim

Code Comparison

Summary

Convert designs to code with AI

README

Table of Contents

Features

Installation

Pre-built binaries

Quick-install script

Eget

Package managers

Building from source

Fully static binary

macOS terminal

WSL and Windows Console

Colors and syntax highlighting

Cygwin, Mingw, Plan9

Usage

Documentation and Help

Contributing

Top Related Projects

Convert designs to code with AI