e

e is a tiny, fully customizable, self-aware, Emacs-like console editor written in Chez Scheme. It feels like Emacs in many ways (buffers, recursive window splits, incremental search, built-in Scheme), but it's not trying to be an Emacs clone.

The latest tagged release is v0.2.

It's "self-aware" because it knows its own internals (like most Lisp systems). It's "fully customizable" because its code is just one big configuration (code is data :)

The editor is itself a Scheme system built from R6RS libraries. Editing and saving a reloadable extension from within e applies its changes immediately. The kernel, base services, main loop and their linked libraries require a restart; see the reload boundary.

Highlights:

• Key helper. C-x TAB lists the keys that work where you are, in a pane above the echo area: the app's or mode's own keys first, then the global ones, each with the command it runs and what that command does, straight from the command's documentation. The listing follows the active window, works inside prompts too, and C-x TAB again pages through it.
• Local installation. By default, configuration, compiled libraries, downloaded reference data, recovery snapshots and diagnostic logs live in the installation directory (where you cloned e). Stop the base before removing the installation. External extension checkouts and a custom base directory, if configured, live separately.
• Multi-head and persistent sessions. On its first invocation, e starts a daemon base to which multiple heads can connect (local connections only for now). Heads detach on exit and reattach on the next invocation. Reattaching with the same head name restores its layout. The base owns the buffers, terminals, and some app state, so multiple heads can access them and edit simultaneously. Work can resume after an SSH disconnect, much like with tmux.
• Scheme evaluation. M-x evaluates Scheme in the editor's context, with structural multiline input, fuzzy symbol completion, parameter hints, history, and captured output (evaluation results, stdout, and stderr are captured separately).
• Apps. Besides normal editing buffers, there are app buffers. They update their presentation from internal structures and can optionally respond to user input. Examples include logs, Git history, live reference pages, rendered Markdown, and the file and buffer pickers.
• Easy filesystem navigation. The <finder> and <buffet> apps have live, filterable tables with multi-column sorting and keyboard or mouse navigation. Finder combines an editable leading path with recursive search tokens, and offers missing paths as file/directory creation rows.
• Tiling. Windows form a recursive tiling layout that is easy to reshape: split in either direction (C-x 2, C-x 3) and drag edges with a mouse.
• Virtual terminals. C-c t opens a new PTY-backed terminal buffer able to run shells, full-screen programs, or another editor such as legmacs. C-x and M-x reach e by default; C-] or the clickable ● / ◐ indicator toggles full / partial capture.
• Descriptive undo. Undo and redo describe meaningful edits: typed runs, pastes, replacements, and formatter passes. Undo targets your own changes by default; choose another actor's changes or opt into undoing everyone's work.
• Agent readiness. The same shared-state APIs are available to scripted clients for attributed edits, change notifications, scoped undo and communication between actors. The editor is agent-ready; bundled agent integrations remain deferred.

Start

Prerequisites

The core editor needs a threaded build of Chez Scheme 10 or newer, Linux, FreeBSD or macOS, and a terminal. Package installation examples:

# Linux (Debian/Ubuntu)
$ sudo apt install chezscheme

# FreeBSD
$ pkg install chez-scheme

# macOS
$ brew install chezscheme

Cloning the repository and the Git browser use the installed git command. HTTPS features, including reference downloads, need OpenSSL's libssl or the optional curl backend and trusted CA certificates; see HTTPS. Opening web links uses the configured browser command.

Install

Run e directly from a source checkout; stable Git tags mark the releases.

Install as a personal editor:

$ git clone https://github.com/paveluv/e ~/.e
$ ~/.e/e file.txt

Or vendor it inside a project so the editor and project-specific extensions travel with the source:

$ git clone https://github.com/paveluv/e ~/git/project/.e
$ rm -rf ~/git/project/.e/.git
$ ~/git/project/.e/e file.txt

Each installation keeps its libraries, configuration, downloaded data and compiled objects beside its loader: lib/, config.e, data/, optional base-config.e and eo/. By default, the daemon owns .base/ there, including its socket, recovery snapshot and daily diagnostic logs, so checkouts have independent settings, caches and daemons. --base-working-dir DIR selects another base directory. lib/ groups flat-named .sls libraries by responsibility. Base and attached implementations use separate eo/base/ and eo/client/ caches of .so objects. The first start compiles the required libraries; later starts reuse them. Configurations retain the .e extension; tools use .sps. See the module layout.

On FreeBSD, where Chez installs a differently named script interpreter, change the shebang as explained in the loader. Automatic base startup executes that same loader.

Keep a session across SSH logins

Run this on the host where the files live, each time you log in:

$ ~/.e/e --name work

C-x C-c detaches that screen. Attach with the same name to restore its layout, positions and local buffers; use a different name for an independent screen. Shared edits and terminal processes continue while no screen is attached. M-x (main:shutdown!) saves shared text and head checkpoints, then stops the base and all its screens. It asks about local drafts, live processes and other screens. Set (main:shutdown-on-exit #t) in config.e to use this shutdown when the last screen quits. e --restart --name work also starts the replacement base and reattaches. All graceful stops, including kill -TERM PID, use the same save path; the next start restores shared text with its retained undo/redo history and plain local buffer text checkpointed under each head's name. Local undo history, the structured log and pending interactions are not saved; terminal text returns as read-only transcripts without restarting its processes. These snapshots are saved on graceful stops, not continuously during editing. New heads check library sources and protocol compatibility against the running base and ask for e --restart when they differ. e --help shows the base's status, version, buffer and process counts, attached and detached screens, and commands to resume them. Starting a new base prints its details and stop options before the screen opens; detaching prints only the session summary. Connections currently use a local Unix socket under the same OS user. See the base and its heads for configuration, lifecycle and scripted clients.

Essential keys

Key	Action
C-x C-f	Browse and recursively filter files in <finder>
C-x C-s	Save
C-x C-r	Reread the file from disk, undoably
C-x !, C-x l	Review reload conflicts, or the delta log, in the pop-up
C-x C-w	Save as
C-x C-c	Detach this screen; keep shared buffers and terminals running
C-x b, C-x C-b	Filter and switch buffers; Enter initially selects the previous buffer
C-x 2, C-x 3	Split the current window below or right
C-x 0, C-x 1	Delete this window or every other window
M-Arrows	Move between windows along the cursor's screen ray
C-s	Incremental search
M-%	Replace all, over the region or the buffer
C-_, C-M-_	Undo, redo
C-@, C-w, M-w, C-y	Mark, kill, copy, yank
M-x	Evaluate Scheme interactively
C-x C-e, C-M-x	Evaluate the expression before point, the top-level form around it
C-M-f, C-M-b, C-M-n, C-M-p	Move over the next or previous expression, or list
C-M-u, C-M-d, C-M-a, C-M-e	Up out of a list, down into one, to a top-level form's start or end
C-M-k, C-M-BS, C-M-SPC, C-M-h, C-M-t, C-M-q	Kill, mark, transpose or indent expressions
C-h f, M-., C-h k	Describe a name, symbol at point, or key
C-x TAB, C-x S-TAB	List the keys that work here in the pop-up, and page down or up
C-x ESC, C-x C-g	Hide the pop-up, window 0
C-x g	Browse Git history and patches
C-c t	Open a terminal buffer
C-c a	Answer a question another actor left for you
C-g	Cancel the current interaction
Escape	Leave the current interaction; accepts the current match in incremental search

In Finder, edit the leading path or add search tokens after a space. Left/Right navigate directories and Enter opens a row; entering a directory resets the filter to its full path. Missing path components appear as italic [create] rows; choosing one creates it and its missing parents. A trailing / creates directories only. Existing files are opened without replacement. In both Finder and Buffet, click column headings or use F1–F6 to cycle ascending, descending and off, with multiple sort keys in the order you add them. M-x (edit:visit-file! (file "~/notes.txt")) uses the same file and directory creation logic.

Scheme at the center

The live top-level environment exposes the published editor API and loaded modules. You can call it via M-x:

M-x (head:buffer-name (head:current-buffer))
M-x (search:replace! "old" "new")
M-x (log-view:buffer! 'eval:report!)
M-x (terminal:open!)
M-x (describe:this terminal:open!)

Module APIs use their prefixes, including the command layer: edit:, head:, log-view:, terminal:. Value constructors such as (file "~/notes.txt"), (buffer "notes.txt") and (window 2) are bare. A single ! marks an effectful procedure; interactive commands use the same suffix, with prompting recorded in their documentation metadata.

Configuration is Scheme too. Copy config.template.e to config.e, uncomment the settings worth changing, and save it; the running editor applies it immediately.

Documentation

• Buffers and windows: files, splits, scrolling, line numbers, scrollbars, mouse behavior, <buffet>, and the buffer API.
• Finder: directory navigation, recursive path filtering, completion, explicit creation, match counts and sortable filesystem metadata.
• Base, heads and agents: the daemon, attaching and reattaching named screens, what is shared and what is local, questions between actors, and the agent-ready session and permission APIs.
• Evaluation: M-x, eval:run!, multiline commands, output capture, interruption, history, and result copying.
• Terminal buffers: full/partial capture, emulation, scrollback, titles, process lifetime, and the terminal API.
• Search and replacement: incremental search, smart case, replacement over the region or the buffer, and Scheme forms for selecting its scope.
• Indentation and formatting: Scheme layout, conservative and intrusive formatting, save hooks, and the CLI formatter.
• Interactive prompts: editing, multiline input, completion, styling, suggestions, and prompt APIs.
• Echo area and log: structured messages, progress, histories, formatters, and dynamic log views.
• Describe: live reference pages, key discovery, corpus installation, structured queries, and module-published documentation.
• Markdown viewing: the rendered companion of a Markdown buffer, links, tables, and the viewer API.
• Configuration: startup options and head names, config.e and base-config.e, reload semantics, precedence, and common settings.
• Key bindings: the C-x TAB key listing, key syntax, contextual maps, overrides, unbinding, and inspection.
• Styles: the style DSL, faces, colors, terminal behavior, and configuration lifecycle.
• App buffers: dynamic views, interaction, input capture, mouse events, and the <buffet> buffer switcher.
• Git: structured repository queries and the history browser.
• Pretty Scheme: structural delimiter glyphs, depth and rainbow variants, and semantic symbol styling.
• HTTPS: the HTTP(S) client, its TLS transport, the curl backend, and portability notes.
• Modules and architecture: the library layout, hot reload, registrations, modes, highlighters, and extension conventions.

Limits

Tabs and other control characters display as one space cell. Input is UTF-8, and buffer cursor, wrapping, selection, and mouse geometry account for wide characters and combining/emoji clusters. Widths use the host locale and the same glyph rules as the terminal emulator.

Version history

• v0.2 (2026-09-27) -- a persistent daemon with named screens, saved-session recovery and reviewed restart; shared terminals and attributed undo; agent-ready APIs; the C-x TAB key listing, every key a documented command and the apps driven by the same commands; the pop-up as a window, and links between windows; interactive Finder and Buffet apps with filtering, compound sorting and per-window column widths; undoable disk reloads with interactive conflict resolution; fuzzy Scheme completion and extension loading with shared evaluation tools; paced terminal frames and less allocation while scrolling. The repository uses the settled R6RS library layout.
• v0.1 (2026-09-02) -- the first tagged release. The core editor: buffers, recursive tiling windows, incremental search and query replace, meaningful undo, mouse support, styles. M-x with semantic completion and captured output; hot-reloadable extension modules; app buffers; a VT-conformant terminal emulator (C-c t); the describe reference corpus; a read-only markdown view; the Git history browser; Scheme indentation and formatting; an FFI HTTPS client with certificate verification and a curl fallback. Runs on Linux, FreeBSD, and macOS.

How to contribute

Prototype a feature (AI agents are welcome) and submit a pull request. Don't worry about whether it's well designed or tested. Most likely, I'll merge it and then rewrite it.

Or just open an issue on GitHub.

Licence

MIT