xyproto/orbiton: Snappy and configuration-free text editor/IDE for the terminal. Suitable for writing git commit messages, editing Markdown, config files, source code, man pages and for quick edit-format-compile cycles when programming. Has syntax hi

!Orbiton Logo

!screenshot

Stepping through the assembly instructions of a Rust program by entering debug mode with the ctrl-o menu and then stepping with ctrl-n:

!debug rust

Editing a C source file in og using the "synthwave" theme:

!synthwave theme

There are also light themes available:

!vs theme

!light theme

Writing commit messages:

!git

Packaging status

| orbiton | |--------------------------------------------------------------------------------------------------------------------------------| | |

Alternatively, download and install a release version. For example, for Raspberry Pi 2, 3 or 4 running Linux:

curl -sL 'https://github.com/xyproto/orbiton/releases/download/v2.74.5/orbiton-2.74.5-linux_armv7_static.tar.xz' | tar JxC /tmp && sudo install -Dm755 /tmp/orbiton-2.74.5-linux_armv7_static/o /usr/bin/o && sudo install -Dm644 /tmp/orbiton-2.74.5-linux_armv7_static/o.1.gz /usr/share/man/man1/o.1.gz

Setting o as the default editor executable for git

To set:

git config --global core.editor o

To unset:

git config --global --unset core.editor

Viewing man pages

By setting the MANPAGER environment variable, it's possible to use o for viewing man pages:

export MANPAGER=o

An alternative to viewing man pages in o is to use less:

export MANPAGER='less -s -M +Gg'

Setting up o on OpenSUSE

Install o manually, until an OpenSUSE package exists:

git clone https://github.com/xyproto/orbiton cd orbiton make && sudo make install

The following is not strictly needed, but it sets everything up to make full use of o:

Add this to ~/.alias:

alias o=/usr/bin/o

Add this to ~/.profile:

export MANPAGER=/usr/bin/o export EDITOR=/usr/bin/o

Log out and in again to activate the changes.

Unique features

These features are unique to o, as far as I am aware:

• If the loaded file is read-only, all text will be red by default.
• Smart cursor movement, trying to maintain the X position when moving up and down, across short and long lines.
• Press ctrl-v once to paste one line, press ctrl-v again to paste the rest.
• When pasting lines copied out of a diff into source code, the leading + and are removed.
• Press ctrl-c once to copy one line, press ctrl-c again to copy a block of lines (until a blank line), press ctrl-c again to copy the current function.
• Jump to matching bracket with ctrl-r, or open or close a portal. Toggle wrap when typing for prose with ctrl-r pressed twice. When a portal is open, copy lines across files (or within the same file) with ctrl-v.
• Build code with ctrl-space or ctrl-b and format code with ctrl-w, for a wide range of programming languages.
• Cycle git rebase keywords with ctrl-w or ctrl-r, when an interactive git rebase session is in progress.
• When opening a file with merge conflict markers, jump to the first marker. Press ctrl-n to jump to the next one.
• Jump to a line with ctrl-l. Either enter a number to jump to a line or just press return (or t) to jump to the top. Press ctrl-l and return again (or b) to jump to the bottom. Press c to jump to the center.
• When jumping to a specific line in a file with ctrl-l, jumping to a percentage (like 50%) or a fraction (like 0.5 or .5) is also possible. It is also possible to jump to one of the highlighted letters.
• If tab completion in the terminal went wrong and you are trying to open a main. file that does not exist, but main.cpp and main.o does exists, then main.cpp will be opened.
• Search by pressing ctrl-f, entering text and pressing return. Replace by pressing tab instead of return, then enter the replacement text and press return. Searching for unicode runes on the form u+0000 is also supported.
• Type iferr on a single line in a Go or Odin program and press return to insert a suitable if err != nil { return ... } block, based on koron/iferr.
• Use the built-in Markdown table editor by pressing ctrl-t when the cursor is on a table. This works best for tables that are not too wide.
• Format Markdown tables by moving the cursor to a table and pressing ctrl-w.
• For C-like languages, missing parentheses are added to statements like if, for and while when return is pressed.
• Pressing ctrl-f twice searches for the word under the cursor.
• Lines are highlighted only when the up and down arrow keys are used.
• The name of the function that the cursor is within, is shown in the upper right corner of the screen, for some programming languages.

Other features and limitations

• The syntax highlighting is instant.
• Opens files quickly.
• Can compile "Hello, World" in many popular programming languages simply by pressing ctrl-b.
• Create, build and run a simple program in C, by running o main.c, pressing ctrl-w and then a double ctrl-b.
• Configuration-free, for better and for worse.
• Can preview .png, .jpg, .jpeg, .gif, .ico and .bmp images directly in the terminal (using a scaled down version and up to 16 colors).
• The -p flag followed by a filename can be used for just pasting the clipboard to a new file, instead of editing a file.
• ctrl-t can jump between a C++ header and source file, when editing C++ code.
• ctrl-t shows the Markdown table editor, when editing Markdown and the cursor is on a Markdown table.
• Can only edit one file at the time, by design.
• Provides syntax highlighting for Go, Rust, C++, Markdown, Bash and several other languages. There is generic syntax highlighting built-in.
• Will jump to the last visited line when opening a recent file.
• Is provided as a single self-contained executable.
• Loads faster than both vim and emacs, for small files.
• Can render text to PDF either by itself or by using pandoc.
• Tested with alacritty, konsole, st, urxvt, xfce4-terminal, xterm and zutty.
• Tested on Arch Linux, Debian, OpenSUSE, macOS, FreeBSD and OpenBSD.
• Never asks before saving or quitting. Be careful.
• The NO_COLOR environment variable can be set to disable all colors.
• Rainbow parentheses makes lines with many parentheses easier to read.
• When limited to vt100 or vt220, hotkeys like ctrl-a and ctrl-e may need to be used instead of Home and End. And for browsing up and down, ctrl-n and ctrl-p may be used.
• Will strip trailing whitespace whenever it can.
• Usually expects to be given a filename at start.
• Has smart indentation.
• Requires that /dev/tty is available.
• xclip for X, wl-clipboard for Wayland or pbcopy for macOS needs to be installed to access the system clipboard.
• May take a line number as the second argument, with an optional + or : prefix.
• If the filename is COMMIT_EDITMSG, the look and feel will be adjusted for git commit messages.
• Supports UTF-8. (Requires a terminal emulator that supports unicode to be able to display unicode runes, though).
• Only UNIX-style line endings are supported (\n).
• Will convert DOS/Windows line endings (\r\n) to UNIX line endings (just \n), whenever possible.
• Will replace non-breaking space (0xc2 0xa0) with a regular space (0x20) whenever possible.
• Will replace annoying tilde (0xcc 0x88) with a regular tilde (~) whenever possible.
• Will replace the greek question mark that looks like a semicolon (0xcd 0xbe) with a regular semicolon (;) whenever possible.
• If interactive rebase is launched with git rebase -i, then either ctrl-w or ctrl-r will cycle the keywords for the current line (fixup, drop, edit etc).
• Want to quickly convert Markdown to HTML? Try o filename.md, press ctrl-b twice and quit with ctrl-q.
• The default syntax highlighting theme aims to be as pretty as possible with less than 16 colors, but it mainly aims for clarity. It should be easy to spot a keyword, number, string or a stray parenthesis.
• Press ctrl-t or ctrl-space to toggle the check mark in - [ ] TODO item boxes in Markdown.
• Can load, edit and save gzipped text files or man pages that ends with a .gz extension.
• Can organize imports, for Java and for Kotlin, when formatting code with ctrl-w.
• Has a built-in spellchecker (press ctrl-f and then t to search for a typo, ctrl-n for next match and then ctrl-a to add it and ctrl-i to ignore it).
• Can jump directly to a selection of highlighted letters on the screen, when ctrl-l is pressed.
• Comes with a file browser that can open, rename and delete files.
• Comes with a build tool that can auto-detect the required build flags for C and C++ (o -b).
• Has LSP support for Tab completion, for several programming languages.

Known issues

• For some terminal emulators, if o is busy performing an operation, pressing ctrl-s may lock the terminal. Some terminal emulators, like konsole, can be configured to turn off this behavior. Press ctrl-q to unlock the terminal again (together with the unfortunate risk of quitting o). To sidestep this issue, the ctrl-o menu can be used instead, for saving and quitting.
• The Markdown table editor does not have scrolling, so the table must fit within the current terminal emulator width and height. Resize the terminal as needed.

Hotkeys

There are pretty few hotkeys to remember:

• ctrl-s - Save.
• ctrl-q - Quit.
• ctrl-a - Go to start of text, then start of line and then to the previous line.
• ctrl-e - Go to end of line and then to the next line
• ctrl-n - Scroll down 10 lines, or go to the next match if a search is active.

• ctrl-p - Scroll up 10 lines, or go to the previous match if a search is active.

• ctrl-k - Delete characters to the end of the line, then delete the line.
• ctrl-_ - Insert a symbol by typing in a 2-letter digraph. Try the --digraphs or -s flag to list all possible digraphs.
• ctrl-d - Delete a single character.
• ctrl-t - For C and C++: jump between the current header and source file. For Agda and Ivy, insert a symbol.

• ctrl-o - Open a command menu with actions that can be performed.
• ctrl-x - Cut the current line. Double press to cut a block of text (to the next blank line). Press thrice to cut the current function.
• ctrl-c - Copy one line. Double press to copy a block of text. Press thrice to copy the current function.
• ctrl-v - Paste one trimmed line. Double press to paste multiple untrimmed lines.
• ctrl-b - Build program, render to PDF or export to man page. Double press to also run.

• ctrl-space - Build program, render to PDF or export to man page. Double press to also run.

• ctrl-j - Join the current line with the next one.
• ctrl-u - Undo (ctrl-z is also possible, but may background the application).
• ctrl-y - Redo.
• ctrl-l - Jump to a specific line number or percentage. Press return to jump to the top. If at the top, press return to jump to the bottom.

• ctrl-f - Search for a string. The search wraps around and is case sensitive. Press tab instead of return to search and replace.

• ctrl-w - Format the current file (see the table below), or cycle git rebase keywords. For Markdown, format the table under the cursor.

• F1 - Show the overview of hotkeys (same as ctrl-l and then /).
• F2 - Save (same as ctrl-s).
• F3 - Go to the next search match (same as ctrl-n).
• F4 - Launch the file browser, which is also available from the ctrl-o menu.
• F5 - Build or export (same as ctrl-space). In debug mode: continue.
• F6 - Toggle block editing mode, which is also available from the ctrl-o menu.
• F7 - Jump to the next typo.
• F8 - In debug mode: step over (same as F10, which some terminals take for themselves).
• F9 - In debug mode: toggle a breakpoint (same as ctrl-b).
• F10 - In debug mode: step over (same as ctrl-o).
• F11 - In debug mode: step out (same as ctrl-f).
• F12 - Go to a definition or include (same as ctrl-g).

• ctrl-g - Go to include or definition, go back or toggle the status bar.
• ctrl-r - Jump to matching bracket, otherwise open or close a portal. Double press to toggle "wrap when typing".

• ctrl-\ - Comment in or out a block of code, or reflow the current paragraph when editing prose.
• ctrl-~ - Insert the current date and time.
• esc - Go back after having gone to another location or file. Redraw everything and clear the last search.

Screen recordings for a few select programming languages

C

!Building, running and tab-completing C !Debugging C

Go

!Building, running and tab-completing Go !Debugging Go

C++

!Building, running and tab-completing C++

Rust

!Building, running and tab-completing Rust

Gleam

!Building, running and tab-completing Gleam

Zig

!Building, running and tab-completing Zig

Odin

!Building, running and tab-completing Odin

Python

!Building, running and tab-completing Python

Haskell

!Building, running and tab-completing Haskell

Bash

!Running and tab-completing Bash

Build and format

• Press ctrl-b to build or export the current file.
• Press ctrl-w to format the current file, in an opinionated way. If the current file is empty, a "Hello, World!" template will be inserted, for some file extensions.
• If a build or export returns an error code and the status message is not specific enough, the last called command can be run from the command line with $(o -l), to get more details. o -l can be used to preview the command.

/etc/fstab, JSON and HTML files are also supported, and can be formatted with ctrl-w.

• o will try to jump to the location where the error is and otherwise display Success.
• For regular text files, ctrl-w will reflow the text to a length of 99.
• If kotlinc-native is not available, this build command will be used instead: kotlinc $filename -include-runtime -d $name.jar

Debug support for C and C++

This is a brand new feature and needs more testing.

• If gdb is installed, it's possible to select "Debug mode" from the ctrl-o menu and then build and step through a program with ctrl-b, or set a breakpoint with ctrl-b and continue with ctrl-b.
• Messages printed to stdout are displayed as a status message when that line is reached.
• An indication of which line the program is at has not yet been added, and is a work in progress.
• There are status messages indicating when the debug session is started and ended.

LSP support

There is Tab-completion support for Go (gopls), Rust (rust-analyzer), C and C++ (clangd), Python (pyright-langserver or pylsp), Zig (zls), Odin (ols), Haskell (haskell-language-server-wrapper), Gleam (gleam lsp), Lua (lua-language-server), Ruby (ruby-lsp) and Bash (bash-language-server).

Markdown table editor

While in the Markdown table editor:

• Cells can be typed into.
• The arrow keys can be used to move around.
• tab can be used to go to the next cell, or insert new cells if the last cell is reached.
• return can be used to either jump to the blank cell below or to insert a new row below.
• backspace can be used to delete letters, but also for deleting the current row if it is empty.
• ctrl-n can be used to insert a new column to the right.
• ctrl-d can be used to delete the current column (if all cells in the column are empty).
• esc or ctrl-t can be used to close the Markdown table editor.
• ctrl-s can be used to save.

Themes

Themes can be selected with the ctrl-o menu. The theme menu also lists the theme names, which can be specified in the O_THEME environment variable.

The O_THEME environment variable is an exception to the claim that o is configuration-free, but it is completely optional.

For using ie. the Synthwave theme, the /usr/bin/sw symlink to /usr/bin/o can be used, or this can be added to ~/.profile:

export O_THEME=synthwave

It is also possibly to specify any base16 theme, like ie. this:

export O_THEME=/usr/share/base16/monokai.yaml

Inserting a symbol

• To insert a symbol, like æ, just press ctrl-_ and type in ae. To insert µ, type in My.
• These are the same digraphs as ViM uses.
• For a full overview of digraphs, see digraphs.txt.

Manual installation on Linux

git clone https://github.com/xyproto/orbiton cd orbiton make && sudo make install

And optionally:

make gui && sudo make gui-install

It is also possible to install the symlinks that are suggested further down in this document.

OpenBSD installation instructions

Install dependencies (use doas if needed):

add_pkg git gmake go vte3

Build both the editor o and the GUI frontend og:

gmake CXX="clang++ -w" o og

Install both executables, a man page, an icon and a desktop shortcut file (use doas if needed):

Just building and installing o also works:

• For building code with ctrl-b, gcc must be installed.
• For formatting code with ctrl-w, clang-format must be installed.
• For tab completion, clangd must be installed.

• For building code with ctrl-b, gcc/clang/cmake/make/ninja should be installed.
• For formatting code with ctrl-w, clang-format must be installed.
• For tab completion, clangd must be installed.

• For building code with ctrl-b, The go compiler must be installed.
• For formatting code with ctrl-w, goimports must be installed.
• For tab completion, gopls must be installed.

• For building and formatting Zig code, only the zig command is needed.
• For tab completion, zls must be installed.

• For building and formatting V code, only the v command is needed.

• For building code with ctrl-b, odin must be installed.
• For formatting code with ctrl-w, odinfmt must be installed.
• For tab completion, ols must be installed.

• For building code with ctrl-b, gleam must be installed.
• For tab completion, gleam lsp is used.

• For building code with ctrl-b, luac must be installed.
• For formatting code with ctrl-w, stylua must be installed.
• For tab completion, lua-language-server must be installed.

• For formatting code with ctrl-w, rubocop must be installed.
• For tab completion, ruby-lsp must be installed.

• For tab completion, bash-language-server must be installed.

• For building code with ctrl-b, Cargo.toml must exist and cargo must be installed.
• For formatting code with ctrl-w, rustfmt must be installed.
• For tab completion, rust-analyzer must be installed.

• For building the current file with ctrl-b, the ghc compiler must be installed.
• For formatting code with ctrl-w, ormolu must be installed.
• For tab completion, haskell-language-server-wrapper must be installed.

• ctrl-b only checks the syntax, without executing. This only requires python to be available.
• For formatting the code with ctrl-w, ruff must be installed.
• For tab completion, pyright-langserver or pylsp must be installed.

• For building and formatting Crystal code, only the crystal command is needed.

• For building code with ctrl-b, kotlinc must be installed. A .jar file is created if the compilation succeeded.
• For formatting code with ctrl-w, ktlint must be installed.

• For building code with ctrl-b, javac and jar must be installed. A .jar file is created if the compilation succeeded.
• For formatting code with ctrl-w, google-java-format must be installed.

• For building code with ctrl-b, scalac and jar must be installed. A .jar file is created if the compilation succeeded.
• The jar file can be executed with java -jar main.jar. Use scalac -d main.jar MyFile.scala if you want to produce a jar that can be executed with scala main.jar.
• For formatting code with ctrl-w, scalafmt must be installed.

• For building code with ctrl-b, gdc must be available.

• Formatting fstab files (usually /etc/fstab) is a built-in feature. Just press ctrl-w. If you need a standalone utility, fstabfmt is available.

• For formatting JavaScript code with , prettier must be installed.

• For ctrl-g in the filebrowser, lazygit is needed.
• For ctrl-t in the filebrowser, tig is needed.

Since kotlinc $filename -include-runtime -d builds to a .jar, I though I should do the same for Java. The idea is to easily compile a single or a small collection of .java files, where one of the files has a main function.

If you know about an easier way to build a .jar file from *.java, without using something like gradle, please let me know by submitting a pull request. This is pretty verbose...

javaFiles=$(find . -type f -name '*.java')
for f in $javaFiles; do
  grep -q 'static void main' "$f" && mainJavaFile="$f"
done
className=$(grep -oP '(?<=class )[A-Z]+[a-z,A-Z,0-9]*' "$mainJavaFile" | head -1)
packageName=$(grep -oP '(?<=package )[a-z,A-Z,0-9,.]*' "$mainJavaFile" | head -1)
if [[ $packageName != "" ]]; then
  packageName="$packageName."
fi
mkdir -p _o_build/META-INF
javac -d _o_build $javaFiles
cd _o_build
echo "Main-Class: $packageName$className" > META-INF/MANIFEST.MF
classFiles=$(find . -type f -name '*.class')
jar cmf META-INF/MANIFEST.MF ../main.jar $classFiles
cd ..
rm -rf _o_build

For Scala, this is the code that is used to produce a main.jar file that can be run directly with java -jar main.jar:

#!/bin/sh
scalaFiles=$(find . -type f -name '*.scala')
for f in $scalaFiles; do
  grep -q 'def main' "$f" && mainScalaFile="$f"
  grep -q ' extends App ' "$f" && mainScalaFile="$f"
done
objectName=$(grep -oP '(?<=object )[A-Z]+[a-z,A-Z,0-9]*' "$mainScalaFile" | head -1);
packageName=$(grep -oP '(?<=package )[a-z,A-Z,0-9,.]*' "$mainScalaFile" | head -1);
if [[ $packageName != "" ]]; then
  packageName="$packageName."
fi
mkdir -p _o_build/META-INF
scalac -d _o_build $scalaFiles
cd _o_build
echo -e "Main-Class: $packageName$objectName\nClass-Path: /usr/share/scala/lib/scala-library.jar" > META-INF/MANIFEST.MF
classFiles=$(find . -type f -name '*.class')
jar cmf META-INF/MANIFEST.MF ../main.jar $classFiles
cd ..
rm -rf _o_build

• If /usr/share/scala/lib/scala-library.jar is not found scalac -d run_with_scala.jar is used instead.
• If scala-library.jar was not found, then the resulting jar file will need scala to run.

ctrl-t brings up a menu with a selection of special symbols.

* Insert ⊤ by pressing ctrl-t and then t. * Insert ℕ by pressing ctrl-t and then n.

When editing PKGBUILD files, it is possible to press ctrl-o and select Call Guessica to update the pkgver= and source= fields, by a combination of guesswork and online searching. This functionality depends on the Guessica package update utility being installed, and will only work for some PKGBUILD files.

• a68g - for compiling ALGOL 68 code
• agda - for compiling Agda code
• asciidoctor - for writing man pages
• astyle - for formatting C# code
• bash-language-server - for tab completion for Bash
• cargo - for compiling Rust
• clang - for formatting C++ code with clang-format
• clangd - for tab completion for C and C++
• clojure - for compiling Clojure
• crystal - for compiling Crystal
• fpc - for compiling Object Pascal
• g++ - for compiling C++ code
• gdc - for compiling D code
• ghc - for compiling Haskell code
• gleam - for compiling Gleam code and for tab completion
• go - for compiling Go code
• go-tools - for formatting Go code and handling imports with goimports
• google-java-format - for formatting Java code
• gopls - for tab completion for Go
• haskell-language-server-wrapper - for tab completion for Haskell
• jad - decompile .class files on the fly when opening them with o
• java-environment - for compiling Java code and creating .jar files with javac and jar
• kotlin - for compiling Kotlin
• ktlint - for formatting Kotlin code
• lua - for compiling Lua to bytecode
• lua-language-server - for tab completion for Lua
• mlton - for compiling Standard ML
• mono - for compiling C# code
• ocaml - for compiling and formatting OCaml code
• odin - for compiling Odin
• odinfmt - for formatting Odin code
• ols - for tab completion for Odin
• ormolu - for formatting Haskell code
• pandoc - for exporting Markdown to PDF
• php-cs-fixer - for formatting PHP code
• prettier - for formatting JavaScript, TypeScript and CSS
• pyright-langserver - for tab completion for Python (or pylsp)
• python - for compiling Python to bytecode
• ruby-lsp - for tab completion for Ruby
• rust-analyzer - for tab completion for Rust
• rustc - for compiling Rust
• ruff - for formatting Python code
• rustfmt - for formatting Rust
• scala - for compiling Scala
• sdoc - for writing man pages
• stylua - for formatting Lua code
• tidy - for formatting XML
• v - for compiling and formatting V code
• zig - for compiling and formatting Zig code
• zls - for tab completion for Zig

• The o executable is 1.5M when built with GCC 12 (for 64-bit Linux) and compressed with upx.
• This isn't as small as e3, an editor written in assembly (which is 234k), but it's reasonably lean.

If the o executable is built with go instead, the size can be 8.7M, or just 2.8M when packed with upx:

These four ways of opening file.txt at line 7 are supported:

• o file.txt 7
• o file.txt +7
• o file.txt:7
• o file.txt+7`

... (README truncated for length)