mawww/kakoune

Features

• Modal Editing Systems - Implements a selection-first modal editing system for precise text and code manipulation.
• Modal Editors - The editor manipulates text and code through a selection-based modal interface.
• Client-Server Text Editor Architectures - Employs a client-server architecture allowing multiple terminal windows to connect to a single editing session.
• Regex-Based Bulk Editing - Leverages regular expressions to manage multiple cursors and execute bulk edits across complex text patterns.
• Text Search and Replace - The editor identifies all occurrences of a pattern across a buffer and replaces them.
• Command Line Interfaces - Provides a command line to enter and validate text instructions or search queries.
• Command Piping - Pipes selected text through shell programs to transform content or insert command output.
• Custom Key Mappings - Provides a flexible system for registering user-defined keyboard shortcuts to trigger editor actions.
• Modal Keymap States - Implements custom modal states that redefine how keys are interpreted based on the active interaction mode.
• Editor Buffer Managers - Provides comprehensive management of editor buffers, including lifecycle control for read-only and scratch buffers.
• Modal Input Systems - Isolates keyboard interpretations into distinct namespaces based on the active interaction mode.
• Multi-Cursor Editing - The editor handles several active edit points simultaneously to apply changes across selections.
• Multi-Cursor Editing Systems - The editor moves cursors and performs edits like yanking and pasting across active selections.
• Selection-Based Command Execution - The editor modifies text and source code using a selection-based command-line interface.
• Shell Command Execution - Integrates deeply with the shell by executing external commands and piping their output directly into the editor.
• Shell Integration Tools - Deeply integrates with the shell by piping text selections through external programs and filters.
• Unified Command Interfaces - Provides a unified language for both interactive prompts and automation scripts to execute internal operations.
• Terminal Text Editors - A programmable terminal-based code editor featuring regex-based selections and multiple cursors.
• Client-Server Architectures - Employs a client-server architecture allowing multiple terminal windows to connect to a single editing session.
• Filesystem Loading - Allows loading text directly from the host filesystem into the editor's buffers or registers.
• Text Editing Modes - The editor inserts characters at the cursor and provides basic manipulation and completion.
• Scriptable Automation - Provides a programmable environment for automating text manipulation through command strings and event hooks.
• Text Object Selection - The editor selects logical units of text like paragraphs and blocks for efficient editing.
• Unified Command Languages - Employs a consistent command language for both interactive user input and programmable automation scripts.
• Output Externalization - Sends selection content to an external shell filter and replaces it with the resulting output.
• Client-Server Architecture - The editor connects multiple terminal windows to a single editing session using a client-server architecture.
• Selection Manipulation Engines - Employs regular expressions to split, filter, and multiply cursor positions for simultaneous editing.
• Terminal Input Modes - Manages isolated mapping namespaces to organize commands and prevent conflicts with built-in keys.
• Selection Logic - Ensures all operations require a predefined text selection before a command is applied.
• Multiple - The editor creates and filters multiple selections based on regex patterns or shell results.
• Regex-Based Highlighting - The editor uses regular expressions to apply visual styles to specific text patterns.
• Text Selection Control - The editor selects a region of text before applying an operation to ensure consistency.
• Regex-Based Selection - The editor finds occurrences of text via regex to create or jump between selections.
• Terminal Element Styling - The editor defines foreground colors, background colors, and text attributes to control the visual appearance of components.
• Structural Text Transformations - The editor executes structural changes like alignment and case conversion across active selections.
• External Feed Integrations - Uses named pipes to stream data asynchronously between the editor and external shell processes.
• Capture Group Implementation - The editor stores grouped sub-matches from a search into indexed registers.
• Asynchronous Buffer Population - The editor uses FIFO buffers to run background commands and display results progressively.
• Custom Command Definitions - Allows users to define new editor commands to extend the programmable environment.
• Command Palette Executions - Provides a keyboard-driven command interface for executing internal editor instructions with history and completion.
• Command Aliasing - Supports creating short nicknames for existing commands to accelerate interactive text editing.
• Command Completion Systems - Provides configurable completion logic for command parameters using buffers, files, or shell scripts.
• Multiline Command Sequences - Runs a sequence of commands or simulated keypresses as a single unit of work.
• Runtime State Injection - Replaces placeholders with real-time values from the editor's internal state during command execution.
• Command Scripting - Evaluates a set of commands as if they were entered interactively into the prompt.
• Document Marks - The editor records selections as spans with timestamps to return to specific document locations.
• Editor State APIs - Provides read-only access to internal metadata like cursor position and buffer names for use in scripts.
• Event Hooks - Triggers specific commands automatically when predefined editor events occur.
• File Navigation Tools - Allows rapid navigation to specific locations within a file or jumping to referenced files.
• In-Editor Text Completion - Implements real-time text suggestions based on configurable search paths and completion engines.
• Key Sequence Patterns - Supports binding specific sequences of keys to commands across different operational scopes.
• Sequence-Based Mappings - Allows keys to trigger other complex sequences or commands across different interaction modes.
• Macro Recorders - Captures a sequence of commands into a register to automate repetitive tasks.
• Workflow Customization - Enables highly personalized editing environments through scripted event hooks and custom modal namespaces.
• Selection History Traversal - Enables navigation through a history of previous selection positions and jumps to specific lines.
• Named Pipe Streaming - Reads content from a named pipe into a buffer and updates the view as new data arrives.
• Text Register Managers - The editor stores named lists of text for later retrieval from yanked content.
• Selection History Persistence - The editor saves text lists and selection locations into named registers for later use.
• Terminal Development Environments - Provides a complete terminal-based development environment using a client-server architecture for multiple windows.
• Configuration Scripting - Provides a scripting environment for dynamically configuring editor behavior and settings at startup.
• Scope-Selector Configurations - Maintains configuration values at global, window, and buffer levels for granular control.
• Configuration Scope Hierarchies - Provides a hierarchical configuration system with values scoped at global, window, and buffer levels.
• Editor Gutter Components - The editor adds flags or symbols in the buffer margin to show warnings or metadata.
• Line Numbering Utilities - The editor renders line numbers in the gutter with relative numbering and highlighting options.
• Modal Display Controllers - The editor shows modal or anchored messages and documentation to the user.
• Highlighter Management - The editor adds or removes syntax or pattern highlighters within the current window.
• Range-Based Styling - The editor applies visual styles or replaces text ranges based on coordinate specifications.
• Region-Based Highlighting - The editor segments text into regions using delimiters to apply styles to nested blocks.
• Syntax Highlighting - Applies visual styles by matching text patterns against a prioritized set of regular expressions.
• Navigation Patterns - The editor moves the cursor or extends selections using character or pattern-based movements.
• Selection Filtering - The editor reduces a set of selections to those matching a specific regular expression.
• Selection State Persistence - The editor stores current selection positions in registers to restore or merge them later.
• Visual Style Customization - The editor defines color faces and loads colorschemes to control the visual styling.
• Text Editors - Modal editor with a focus on selection.

Star history