v1.4.1 -- Built with Rust, 109 tests, zero unsafe code

rune

The simplicity of nano. The power you actually need.

curl -fsSL https://rune.byexec.com/install.sh | bash
scroll down
rune -- main.rs
 main.rs   config.rs   utils.rs 
 1 use std::collections::HashMap;
 2 use anyhow::Result;
 3 
 4 /// Application entry point
 5 fn main() -> Result<()> {
 6     let config = Config::load()?;
 7     let mut editor = Editor::new(config);
 8 
 9     for file in &args.files {
10         editor.open_tab(file)?;
11     }
12 
13     editor.run() 
14 }
   
 main.rs                       Ln 13, Col 17    Rust 
^S Save  ^F Find  ^G Go To  ^T New Tab  ^H Help  ^X Exit

Features
Everything you need. Nothing you don't.

Rune gives you a real editor for the terminal -- tabs, syntax highlighting, search and replace, hex view -- without the complexity of vim or the limitations of nano.

Tabs and Multi-buffer

Open multiple files in tabs. Ctrl+T new tab, Alt+Left/Right to switch. Open folders with rune . and get a fuzzy finder with Ctrl+P.

Syntax Highlighting

26 languages with lazy, cached highlighting. Rust, Python, JS/TS, Go, C/C++, Shell, and more. Comments, strings, keywords, types, numbers -- all highlighted.

Search and Replace

Incremental search with live match highlighting. Regex mode, case sensitivity toggle, 50-entry history. Interactive replace with Y/N/A per match.

Hex View

Ctrl+B toggles a live hex view of your buffer. Cursor stays synced between text and hex views. Inspect binary data without leaving the editor.

Smart Editing

Auto-indent, block indent/unindent (Alt+}/Alt+{), language-aware comment toggle (Alt+;), word completion from buffer (Alt+\).

Execute Commands

Ctrl+E runs shell commands from the editor. Pipe selections through external commands. 10-second timeout, 1MB output limit for safety.

Selection and Clipboard

Mark mode with Alt+A, visual highlighting, cut/copy/paste with Ctrl+K/Alt+6/Ctrl+U. Works with or without selection.

Fast and Reliable

Built with Rust, ratatui, and ropey. Rope data structure for large files. Lazy syntax highlighting. Zero unsafe code. 109 tests.


In Action
See it work.

Terminal mockups showing real rune features.

rune -- 3 tabs
 server.py   routes.py   models.py 
 1 from flask import Flask, jsonify
 2 from .routes import api_bp
 3 
 4 app = Flask(__name__)
 5 app.register_blueprint(api_bp)
 6 
 7 if __name__ == "__main__":
 8     app.run(debug=True) 
   
 server.py     Modified       Ln 8, Col 28    Python 

Tabs and Fuzzy Finder

Work with multiple files effortlessly. Open entire directories and jump between files instantly.

  • Ctrl+T to open a new tab
  • Alt+Left/Right to switch tabs
  • Ctrl+P fuzzy finder across all tabs
  • Alt+W to close current tab
  • Smart titles resolve name collisions
rune -- search
 main.rs 
 5 fn main() -> Result<()> {
 6     let config = Config::load()?;
 7     let mut editor = Editor::new(config);
 8     let config_path = dirs::config_dir();
 9     editor.load_config()?;
   
 Find: config                   4 matches  [^C case] [^R regex] 

Incremental Search

Find anything instantly with live match highlighting as you type.

  • All matches highlighted in real-time
  • Arrow keys navigate between matches
  • Toggle case sensitivity and regex
  • 50-entry search history
  • Interactive replace: Y/N/A per match
rune -- hex view
 binary.dat 
00000000  89 50 4e 47  0d 0a 1a 0a  00 00 00 0d  49 48 44 52  .PNG........IHDR
00000010  00 00 02 00  00 00 02 00  08 06 00 00  00 f4 78 d4  ..............x.
00000020  fa 00 00 00  01 73 52 47  42 00 ae ce  1c e9 00 00  .....sRGB......
00000030  00 04 67 41  4d 41 00 00  b1 8f 0b fc  61 05 00 00  ..gAMA......a...
   
 binary.dat    Hex View       Offset 0x00     1.2 KB 
^B Text View  ^F Find  ^G Go To Offset

Hex View

Inspect any file at the byte level without leaving the editor.

  • Ctrl+B toggles between text and hex
  • Cursor position synced across views
  • ASCII representation alongside hex
  • Works on the live buffer

Languages
26 languages. Lazy and fast.

Syntax highlighting that only processes visible lines, caches results, and loads on demand. Zero startup cost.

Rust Python JavaScript TypeScript Go C C++ Java Shell / Bash HTML CSS JSON TOML YAML Markdown SQL Ruby PHP Lua Swift Kotlin Dart Zig Haskell Elixir Dockerfile

Reference
All keybindings.

Every shortcut in one place. Search or filter by category.


Get Started
Install rune.

Pick your preferred method. All platforms supported: macOS (Intel and Apple Silicon), Linux (x86_64, ARM64, ARMv7), FreeBSD, NetBSD.

Quick Install (recommended)

Auto-detects your platform and installs the latest release.

curl -fsSL https://rune.byexec.com/install.sh | bash

Homebrew

macOS and Linux via Homebrew.

brew install exec/tap/rune

Cargo

Build from source with Rust's package manager.

cargo install --git https://github.com/exec/rune

Arch Linux (AUR)

Available in the AUR.

yay -S rune-editor

From Source

Clone and build yourself.

git clone https://github.com/exec/rune && cd rune && cargo build --release

Binary Releases

Download pre-built binaries directly.

github.com/exec/rune/releases
26
Languages
109
Tests
0
Unsafe code
6
Platforms