Iced Code Editor
A high-performance, canvas-based code editor widget for Iced.
Overview
This crate provides a fully-featured code editor widget with syntax highlighting, line numbers, text selection, and comprehensive keyboard navigation for the Iced GUI framework.
Screenshot of the demo application:

Features
- Syntax highlighting for multiple programming languages via syntect
- Line numbers with styled gutter
- Text selection via mouse drag and keyboard shortcuts
- Clipboard operations (copy, paste)
- Undo/Redo with smart command grouping and configurable history
- Custom scrollbars with themed styling
- Focus management for multiple editors
- Native Iced theme support - Automatically adapts to all 23+ built-in Iced themes
- Line wrapping to split long lines
- Code folding to collapse/expand indentation-based blocks
- High performance canvas-based rendering
- Search and replace text
- Command palette (
Ctrl+Shift+P) listing every editor action, extensible with the host application's own commands - Language Server Protocol (LSP) support
- Auto indentation with custom indent style
- Auto-closing brackets/quotes with surround selection
- Matching bracket/quote highlight — highlights the paired bracket or quote next to the cursor
- Bracket-pair colorization — colors each bracket by nesting depth (rainbow brackets)
- Multiple cursors for simultaneous editing at multiple positions
- Move and duplicate lines with keyboard shortcuts
- Toggle comment on the current line or selection (
Ctrl+/) - Visible whitespace rendering — spaces shown as
·, tabs as→ - Indentation guides — vertical lines marking each indentation level
- Inline color previews — a swatch next to every
#rrggbb,0xrrggbborrgb(…)literal - Sticky scroll — the headers of the enclosing blocks stay pinned above the viewport, and clicking one scrolls back to it
- Optional Vim mode with Normal, Insert, Visual, and Visual Line modes
Quick Start
Add this to your Cargo.toml:
[]
= "0.14"
= "0.5"
Basic Example
Here's a minimal example to integrate the code editor into your Iced application:
Note:
CodeEditordoes not automatically lose focus when another widget is clicked. You must calleditor.lose_focus()whenever another interactive widget is activated. The pattern below usesmouse_areato detect clicks on sibling widgets.
use ;
use ;
use ;
Vim Mode
Vim behavior is disabled by default and configured independently for each
CodeEditor instance. Enabling it enters Normal mode and collapses any
multi-cursor state to the primary cursor:
use ;
let mut editor =
new.with_vim_enabled;
assert!;
assert_eq!;
editor.set_vim_enabled;
assert_eq!;
With the editor focused, press Ctrl+Alt+V (or Command+Alt+V on macOS)
to switch between Vim and standard editing. Enabling Vim always starts in
Normal mode. The regular Ctrl/Command+V system-paste shortcut is unchanged.
The MVP supports these keys:
| Context | Keys | Behavior |
|---|---|---|
| Normal/Visual motion | h, j, k, l |
Move left, down, up, or right |
| Normal/Visual motion | w, b, e |
Move to the next word, previous word, or word end |
| Normal/Visual motion | 0, ^, $ |
Move to line start, first non-blank, or line end |
| Normal/Visual motion | gg, G |
Move to document start or end when no count is given |
| Normal/Visual motion | [count]gg, [count]G |
Jump to the 1-based logical line, e.g. 5G or 5gg jumps to line 5 |
| Enter Insert | i, a, I, A |
Insert before/after the cursor, at first non-blank, or at line end |
| Enter Insert | o, O |
Open line(s) below or above |
| Select | v, V |
Enter character-wise Visual or Visual Line mode |
| Operators | d{motion}, c{motion}, y{motion} |
Delete, change, or yank through any supported motion |
| Line operators | [count]dd, [count]cc, [count]yy |
Delete, change, or yank consecutive lines, e.g. 5yy yanks five lines |
| Visual operators | d, c, y |
Apply the operator to the Visual selection |
| Direct edits | x, p, P |
Delete characters; paste after or before from the unnamed register |
| History | u, Ctrl+R |
Undo or redo |
| Search | /pattern, then Enter |
Search forward from the cursor and wrap at the end |
| Search repeat | n, N |
Repeat the last search forward or backward |
| Go to line | :N, then Enter |
Jump to 1-based logical line N, clamped to the document |
| Save | :w, then Enter |
Request that the host save the current document |
| Exit Vim mode | :q, then Enter |
Disable Vim behavior for the current editor |
| Save and exit Vim mode | :wq, then Enter |
Request a save and disable Vim behavior |
| Command line | Backspace, Escape |
Edit or cancel the active / or : input |
| Mode exit | Escape |
Return to Normal mode and clear pending prefixes/selections |
| Count prefix | 1–9, then 0 |
Repeat motions, line operators, x, paste, undo, or opened lines; operator and motion counts multiply |
When Vim mode is enabled, a fixed status line below the editor shows the
current mode. While entering /pattern or :N, it shows the command and
current input; otherwise it shows pending Normal-mode keys such as 5d or
3g. The status line remains visible while the document scrolls.
j and k move by visible display lines, so they follow wrapped lines and
skip folded content. Vim mode is intentionally single-cursor; attempts to add
extra cursors are ignored while it is enabled.
Vim d, c, y, x, p, and P use an unnamed register stored inside
that editor instance. It distinguishes character-wise and line-wise content
and does not access the system clipboard. Platform Ctrl/Command clipboard
shortcuts (C, X, and V) keep their existing system-clipboard behavior
and take priority over Vim parsing.
Because the editor does not own a file path or perform disk I/O, :w, :wq,
and Ctrl/Command+S emit Message::WriteRequested. Hosts should intercept
that message and save the corresponding document. The demo app binds all
three inputs to its existing Save/Save As flow.
This is a focused MVP, not full Vim compatibility. Apart from the supported
:N line jump and :q/:w/:wq commands, it does not implement Ex
commands. It also does not implement regex search, search history, text
objects, macros, named registers, marks, . repeat, or configurable key
mappings.
Keyboard Shortcuts
The editor supports a comprehensive set of keyboard shortcuts:
Navigation
| Shortcut | Action |
|---|---|
| Arrow Keys (Up, Down, Left, Right) | Move cursor |
| Shift + Arrows | Move cursor with selection |
| Home / End | Jump to start/end of line |
| Shift + Home / Shift + End | Select to start/end of line |
| Ctrl + Home / Ctrl + End | Jump to start/end of document |
| Page Up / Page Down | Move cursor one page up/down |
| Shift + Page Up / Shift + Page Down | Select one page up/down |
| Ctrl + Page Up / Ctrl + Page Down | Not handled — left uncaptured for the host application to bind (the usual previous/next-tab combination). The same holds for Alt + Page Up/Down. |
| Shift + Tab | Move focus to the previous editor |
Editing
| Shortcut | Action |
|---|---|
| Backspace | Delete character before cursor (or delete selection if text is selected) |
| Delete | Delete character after cursor (or delete selection if text is selected) |
| Shift + Delete | Delete selected text (same as Delete when selection exists) |
| Enter | Insert new line |
| Tab | Insert indent |
| Alt + Up/Down | Move current line (or selected lines) up/down |
| Shift + Alt + Up/Down | Duplicate current line (or selected lines) above/below |
| Ctrl + / | Toggle line comment on current line (or selected lines) |
| Ctrl + S | Request a save from the host application (emits Message::WriteRequested) |
Clipboard
| Shortcut | Action |
|---|---|
| Ctrl + C or Ctrl + Insert | Copy selected text |
| Ctrl + X | Cut selected text |
| Ctrl + V or Shift + Insert | Paste from clipboard |
| Ctrl + A | Select the whole document |
Undo/Redo
| Shortcut | Action |
|---|---|
| Ctrl + Z | Undo last operation |
| Ctrl + Y or Shift + Ctrl + Z | Redo last undone operation |
The editor features smart command grouping - consecutive typing is grouped into single undo operations, while navigation or deletion actions create separate undo points.
Multiple Cursors
| Shortcut | Action |
|---|---|
| Alt + Click | Add a cursor at the clicked position |
| Ctrl + Alt + Up | Add a cursor on the line above |
| Ctrl + Alt + Down | Add a cursor on the line below |
| Ctrl + D | Select the next occurrence of the current word/selection |
| Escape | Collapse all cursors back to one (when search dialog is closed) |
All editing operations (typing, backspace, delete, enter, tab, paste) apply simultaneously to every cursor. Copy with multiple selections joins all selected texts with newlines. Paste with the same number of clipboard lines as cursors pastes one line per cursor.
Search and Replace
| Shortcut | Action |
|---|---|
| Ctrl + F | Open search dialog |
| Ctrl + H | Open search and replace dialog |
| F3 | Find next match |
| Shift + F3 | Find previous match |
| Tab / Shift + Tab | Cycle through the dialog fields |
| Escape | Close search dialog |
Go to Line
| Shortcut | Action |
|---|---|
| Ctrl + G | Open the go-to-line dialog |
| Enter | Jump to the entered 1-based line |
| Escape | Close the dialog |
The target line is clamped to the document, so a number past the end jumps to the last line.
Command Palette
| Shortcut | Action |
|---|---|
| Ctrl + Shift + P | Open the command palette |
| Up / Down | Move through the filtered commands |
| Enter | Run the highlighted command |
| Escape | Close the palette |
Typing filters the list by subsequence, so tc finds "Toggle Line Comment" and fldall finds "Fold All". Only commands that are usable right now are listed — undo does not appear with an empty history, and the folding commands stay out while folding is disabled. Each row shows the command's own keyboard shortcut, so the palette doubles as a way to learn them.
The three commands most recently run from the palette are listed first, above a separator line, and a toggle command shows its current state as an On/Off badge beside its label. The recent block is filtered like the rest of the list, and is kept per editor for the session.
See Extend the command palette to register the host application's own commands, hide the built-in ones, or turn the palette off entirely.
Code Folding
These shortcuts are active only when code folding is enabled:
| Shortcut | Action |
|---|---|
| Ctrl + . | Toggle fold of the block at the cursor |
| Ctrl + K | Fold all blocks |
| Ctrl + J | Unfold all blocks |
You can also click the fold chevrons (▼ / ▶) in the gutter to collapse or expand a block.
LSP Completion
These shortcuts are active only when the LSP completion menu is visible:
| Shortcut | Action |
|---|---|
| Arrow Up | Navigate to previous completion item |
| Arrow Down | Navigate to next completion item |
| Enter | Confirm and apply selected completion |
| Escape | Close completion menu |
| Arrow Left / Arrow Right | Clear completion menu |
Usage Examples
Custom context menu
Custom context-menu actions are identified by stable strings chosen by your application. Custom entries appear before the built-in editing actions:
use ;
let editor = new
.with_custom_context_menu_entries
.with_default_context_menu_enabled;
The editor automatically adds a separator between the custom and built-in
groups. Pass false to with_default_context_menu_enabled to replace the
built-in menu completely. At runtime, use
set_custom_context_menu_entries and
set_default_context_menu_enabled to update the same configuration.
Handle custom actions in the outer application before forwarding other editor
messages to CodeEditor::update:
match event
Unknown IDs should be ignored or logged explicitly. The editor emits custom action IDs unchanged and does not interpret or execute them internally.
The built-in labels follow the language configured with set_language.
Custom-entry labels are supplied by the host application, so localize those
strings before passing them to the editor.
Applications with a real filesystem path can opt into the built-in reveal request:
editor.set_reveal_in_file_manager_enabled;
match event
The menu label is platform-specific: Reveal in Finder on macOS, Reveal in File Explorer on Windows, and Open Containing Folder on other desktop platforms. The editor only emits the request; the host is responsible for invoking the operating system and reporting failures. The demo enables this item for tabs backed by a desktop path and keeps it hidden for untitled tabs and WebAssembly.
Extend the command palette
The palette lists the built-in editor commands out of the box. Register your application's own commands to have them listed first:
use ;
let editor = new
.with_custom_command_palette_entries;
Entries reuse ContextMenuItem, so an action offered in both surfaces is
described once and keeps a single identifier. An entry built with
with_enabled(false) is left out of the palette entirely rather than dimmed:
the palette is a search result list, so every row it offers is runnable.
A command that switches a setting can report that setting's state with
with_status, which the palette shows as an On/Off badge beside the label:
use ContextMenuItem;
let item = new
.with_status;
The badge is a snapshot taken when the entries are registered, so register them again whenever the setting changes. The context menu ignores the field.
Running a custom entry emits CommandPaletteAction carrying its ID. Handle it
in the outer application, exactly like a custom context-menu action:
match event
Built-in commands the editor cannot perform on its own — saving, revealing the file in the file manager — are emitted the same way they would be if the user had pressed the shortcut, so the host intercepts them where it already does.
Pass false to with_default_command_palette_enabled to list only your own
commands, and use set_command_palette_enabled(false) to disable the palette
altogether, freeing Ctrl+Shift+P for an application-provided one:
let editor = new
.with_default_command_palette_enabled
.with_command_palette_enabled;
// Or open it from your own menu item:
let task = editor.open_command_palette;
The built-in labels follow the language configured with set_language;
localize your own entry labels before passing them in.
Changing Themes
The editor uses TokyoNightStorm as the default theme. It automatically adapts to any Iced theme. All 23+ built-in Iced themes are supported:
use theme;
// Apply any built-in Iced theme
editor.set_theme;
editor.set_theme;
editor.set_theme;
editor.set_theme;
editor.set_theme;
// Or use any theme from Theme::ALL
for theme in ALL
Getting and Setting Content
// Get current content
let content = editor.content;
// Check if content has been modified
if editor.is_modified
// Mark content as saved (e.g., after saving to file)
editor.mark_saved;
Enable/disable search/replace
The search/replace functionality is enabled by default. It can be toggled on or off. When disabled, search shortcuts (Ctrl+F, Ctrl+H, F3) are ignored and the search dialog is hidden:
// Disable search/replace functionality
editor.set_search_replace_enabled;
// Or use builder pattern during initialization
let editor = new
.with_search_replace_enabled;
// Check current state
if editor.search_replace_enabled
This is useful for read-only editors or when you want to provide your own search interface.
Open search/replace from your own buttons
Besides keyboard shortcuts, you can open or close the dialogs via API:
// Open search dialog (same as Ctrl+F)
let task = editor.open_search_dialog;
// Open search+replace dialog (same as Ctrl+H)
let task = editor.open_search_replace_dialog;
// Close dialog (same as Esc)
let task = editor.close_search_dialog;
Return these tasks from your app update function after mapping to your message type.
Enable/disable line wrapping
Line wrapping is enabled by default at viewport width. Long lines can be wrapped automatically at the viewport width or at a fixed column:
// Enable line wrapping at viewport width
editor.set_wrap_enabled;
// Wrap at a fixed column (e.g., 80 characters)
let editor = new
.with_wrap_enabled
.with_wrap_column;
// Disable wrapping
editor.set_wrap_enabled;
// Check current state
if editor.wrap_enabled
When enabled, wrapped lines show a continuation indicator (↪) in the line number gutter.
Enable/disable code folding
Code folding is enabled by default. Foldable regions are detected from indentation: a line is a fold header when the following non-blank line is more deeply indented (language-agnostic, works for Rust, Python, YAML, etc.). When enabled, a fold margin with clickable chevrons (▼ expanded, ▶ collapsed) is shown in the gutter, and a ⋯ marker appears after a collapsed block header.
// Disable code folding (chevrons hidden, all lines shown)
editor.set_folding_enabled;
// Or use builder pattern during initialization
let editor = new
.with_folding_enabled;
// Check current state
if editor.folding_enabled
Folds can also be driven programmatically (useful for your own buttons or commands):
// Toggle the fold of the block whose header is a given logical line
editor.toggle_fold;
// Toggle / fold / unfold the innermost block containing a line
editor.toggle_fold_at;
editor.fold_at;
editor.unfold_at;
// Fold or unfold every block at once
editor.fold_all;
editor.unfold_all;
// Query whether a header line is collapsed
if editor.is_folded
When folding is disabled, the collapsed state is preserved (so re-enabling restores the previously collapsed blocks) but no lines are hidden.
Enable/disable line numbers
Line numbers are displayed by default. They can be hidden to maximize space for code:
// Hide line numbers
editor.set_line_numbers_enabled;
// Or use builder pattern during initialization
let editor = new
.with_line_numbers_enabled;
// Show line numbers (default behavior)
editor.set_line_numbers_enabled;
// Check current state
if editor.line_numbers_enabled
When disabled, the gutter is completely removed (0px width), providing more horizontal space for code display.
Visible whitespace rendering
Whitespace rendering is enabled by default. Spaces are displayed as · and tab characters as → (with · fill to preserve alignment), both drawn in a dimmed color that blends with the active theme.
// Disable whitespace rendering
editor.set_show_whitespace;
// Re-enable it
editor.set_show_whitespace;
// Check current state
if editor.show_whitespace
The whitespace color is derived automatically from the active theme via Style::whitespace_color and can be overridden in a custom Style.
Indentation guides
Indentation guides are enabled by default. A thin vertical line is drawn at every indentation level, making the nesting of a block visible without following its braces. Their spacing follows the configured IndentStyle, so switching from 4 spaces to 2 spaces (or to tabs) moves the guides accordingly.
// Disable indentation guides
editor.set_show_indent_guides;
// Or use builder pattern during initialization
let editor = new
.with_show_indent_guides;
// Check current state
if editor.show_indent_guides
Blank lines take the level of the surrounding block, so a blank line inside a block keeps its guides while a blank line between two blocks does not. Guides are not drawn on wrapped continuation segments, since those restart at the left edge of the code area. The guide color is derived automatically from the active theme via Style::indent_guide_color and can be overridden in a custom Style.
Inline color previews
Inline color previews are enabled by default. Every color literal in the visible text gets a small square, filled with the color it denotes, drawn just after it — so a palette can be read at a glance instead of decoded by eye.
The recognized notations are:
| Notation | Examples |
|---|---|
| CSS hexadecimal | #f0c, #f008, #1e1e2e, #ff000080 |
| Rust-style hexadecimal | 0x3A7BD5, 0xFF6B6BCC |
| Functional | rgb(58, 123, 213), rgba(255, 0, 0, 0.5), rgb(100%, 0%, 50%) |
// Disable inline color previews
editor.set_show_color_previews;
// Or use builder pattern during initialization
let editor = new
.with_show_color_previews;
// Check current state
if editor.show_color_previews
Detection is purely lexical, so a literal inside a comment or a string gets a swatch too — which is what a reader looking for colors expects. Runs of hexadecimal digits of any other length are rejected (#12345 is not a color), and a literal that continues an identifier (raw0xff0000) is ignored. The swatch is drawn as geometry and Iced renders all text above all geometry, so the character following the literal stays readable even when the square extends under it. Its frame uses Style::gutter_border, and translucent colors are composited over Style::background.
Sticky scroll
Sticky scroll is enabled by default. While scrolling deep inside a long block, the header lines of the blocks enclosing the topmost visible line stay pinned at the top of the viewport, outermost first — so the structural context (which impl, which function, which match) never leaves the screen. Clicking a pinned header scrolls back to that line; the cursor and the selection are left untouched.
// Disable sticky scroll
editor.set_sticky_scroll_enabled;
// Or use builder pattern during initialization
let editor = new
.with_sticky_scroll_enabled;
// Check current state
if editor.sticky_scroll_enabled
At most five headers are pinned at once, so a deeply nested block cannot bury the code being read. Enclosing blocks are detected from indentation, exactly like code folding: the feature needs no language grammar and works on any file, but it follows how the file is indented rather than how it parses. Only the detection is shared — the two features are independently toggled, so set_folding_enabled(false) removes the fold chevrons and leaves the pinned headers in place. Pinned headers keep the syntax colors of the code they mirror, reusing the per-line highlight cache, and stay anchored to the gutter instead of following the horizontal scroll, so they remain readable when a long line is scrolled sideways.
Indentation
Auto-indentation is enabled by default: pressing Enter copies the leading whitespace of the current line to the new line. The indentation style (spaces or tab) is 4 spaces by default and controls what is inserted when pressing Tab.
// Disable auto-indentation on Enter
editor.set_auto_indent_enabled;
// Check current state
if editor.auto_indent_enabled
use IndentStyle;
// Use 2 spaces per indent level
editor.set_indent_style;
// Use tabs instead of spaces
editor.set_indent_style;
// Restore the default (4 spaces)
editor.set_indent_style;
// Check current style
match editor.indent_style
Available styles via IndentStyle::ALL: Spaces(2), Spaces(4), Spaces(8), Tab.
Auto-closing brackets/quotes
Auto-closing is enabled by default. Typing an opening bracket or quote ((, [, {, ", ') auto-inserts its matching closing character with the cursor placed between them; typing the closing character right after an already-inserted match moves the cursor past it instead of duplicating it; and typing an opening bracket/quote while text is selected wraps the selection in the pair instead of replacing it.
// Disable auto-closing of brackets/quotes
editor.set_auto_close_brackets;
// Check current state
if editor.auto_close_brackets
Matching bracket/quote highlight
Matching bracket/quote highlight is enabled by default. Placing the cursor next to a bracket ((, ), [, ], {, }) or a quote (", ') highlights it and its matching pair.
// Disable the matching bracket/quote highlight
editor.set_bracket_match_highlight_enabled;
// Check current state
if editor.bracket_match_highlight_enabled
Bracket-pair colorization
Bracket-pair colorization is enabled by default. Each (, ), [, ], {, } is colored by its nesting depth, so a matching pair always shares the same color, cycling through a fixed palette (gold, orchid, light sky blue) as depth increases.
// Disable bracket-pair colorization
editor.set_bracket_pair_colorization_enabled;
// Check current state
if editor.bracket_pair_colorization_enabled
Language Server Protocol (LSP)
LSP support provides hover documentation, auto-completion, go-to-definition, and document formatting. It requires the lsp-process feature (not available on WASM):
[]
= { = "0.5", = ["lsp-process"] }
Enable/disable LSP on an editor
// Enable LSP (attach a client and open the document)
editor.set_lsp_enabled;
// Disable LSP (detach the client)
editor.set_lsp_enabled;
Connecting an LSP server
use mpsc;
use ;
// Create a channel to receive LSP events. It must be *bounded*: it is fed by
// a language server your application does not control, and an unbounded queue
// turns a chatty server into unbounded memory. When it fills, the client drops
// events rather than blocking the thread that drains the server's stdout —
// every event is a UI update superseded by the next one, so nothing is lost
// but a refresh.
let = ;
// Start the server (e.g., lua-language-server)
let client = new_with_server?;
// Attach the client to an editor with a document URI
editor.attach_lsp;
Rendering the overlay (hover + completion)
Use LspOverlayState to hold display state and view_lsp_overlay to render it:
use ;
Poll LspEvents from the channel on each tick and update the overlay state:
// On LspEvent::Hover
overlay.show_hover;
// On LspEvent::Completion
overlay.set_completions;
Formatting the document
Ask the server to reformat the whole buffer, then apply the edits it sends
back. The request is fire-and-forget like every other one: the reply arrives as
an LspEvent::Formatting, so the two halves live in different places.
// Trigger it from a menu entry, a shortcut, or just before saving.
// The formatting options follow the editor's own `IndentStyle`.
editor.lsp_request_formatting;
// On LspEvent::Formatting { uri, edits }
// Applies the whole batch as one undo step, keeping the cursor in place.
editor.apply_lsp_text_edits;
apply_lsp_text_edits returns false — leaving the buffer untouched — when
the reply changes nothing, or when its edits overlap (which LSP forbids).
For format on save, send the request first and write the file once the edits have been applied. Give that wait a deadline: a server that never answers must not be able to swallow the save. The demo app does this with a two-second timeout, after which it writes the file unformatted.
Supported servers
Out of the box, the following servers are supported (the binary must be on $PATH):
| Server key | Language |
|---|---|
rust-analyzer |
Rust |
pyright |
Python |
typescript-language-server |
JS / TS |
lua-language-server |
Lua |
gopls |
Go |
Changing font
The default font of the editor is iced::Font::MONOSPACE. It can be changed with one of the default iced font or by loading a specific font:
let font = SansSerif;
editor.set_font;
The editor support CJK font.
The default font size is 14px. It can be changed:
editor.set_font_size;
Themes
The editor natively supports all built-in Iced themes with automatic color adaptation.
Each theme automatically provides:
- Optimized background and foreground colors
- Adaptive gutter (line numbers) styling
- Appropriate text selection colors
- Themed cursor appearance
- Custom scrollbar styling
- Subtle current line highlighting
The editor intelligently adapts colors from the Iced theme palette for optimal code readability.

Supported Languages
The editor supports syntax highlighting for numerous languages via the syntect crate:
- Rust (
"rs"or"rust") - Python (
"py"or"python") - JavaScript/TypeScript (
"js","javascript","ts","typescript") - Lua (
"lua") - C/C++ (
"c","cpp","c++") - Java (
"java") - Go (
"go") - HTML/CSS (
"html","css") - Markdown (
"md","markdown") - And many more...
For a complete list, refer to the syntect documentation.
Demo Application
A full-featured demo application is included in the demo-app directory, showcasing:
- File operations (open, save, save as)
- Theme switching
- Modified state tracking
- Clipboard operations
- Full keyboard navigation
Run it with:
Simple Example
A minimal standalone example is available in the simple-example directory. It demonstrates the basic integration pattern with a text_input sibling widget and focus management:
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
Check docs\DEV.md for more details.
License
This project is licensed under the MIT License - see the LICENSE file for details.