sxyazi/yazi
40.5
Weak · 14 November 2026
68.8k
lines of production code
Rust
with Lua
5
measurements over time
What this system is
Features
Add cache clearing capability
Users can now clear the preview cache directory via the CLI. The new \Cache::clear\ implementation safely removes the cache files if the directory is the default temporary location, or warns the user to clear it manually if a custom cache directory has been configured.
yazi-cli/src/cache · high confidence
Add desktop entry for Yazi file manager
A new .desktop file has been added to the assets, enabling Yazi to be recognized as a system application. This allows the file manager to appear in desktop environment application menus and supports opening directories via file URIs, with the entry configured to run in a terminal and associated with the inode/directory MIME type.
assets · high confidence
Added build and version-bump automation scripts
Two new shell scripts are introduced to streamline the release process. The \scripts/build.sh\ script ensures the \zip\ utility is installed and then invokes the \cargo xtask dist\ command to produce distribution artifacts for a specified target. The \scripts/bump.sh\ script automates version updates by updating version strings in all \Cargo.toml\ files, adjusting internal path dependencies, and updating the \CHANGELOG.md\ with the new version header and comparison links.
scripts · high confidence
Added help menu action parsers
The yazi-parser crate now includes modules to parse help-related actions, specifically supporting the close and toggle operations. This enables the help menu to function as a command palette by allowing these actions to be deserialized from Lua and other sources, facilitating the new interactive help interface.
yazi-parser/src/help · high confidence
Added shared file utility functions for existence checks and sealed file operations
The \yazi-cli/src/shared\ module now provides shared asynchronous utilities for file system interactions. Users benefit from new helper functions \must\_exists\ and \maybe\_exists\ for robust path existence checks, as well as \copy\_and\_seal\ to copy files while setting them to read-only, and \remove\_sealed\ to handle permission adjustments (specifically on Windows) before deleting read-only files.
yazi-cli/src/shared · high confidence
Added transliteration support for natural sorting
Users can now transliterate filenames during natural sorting, allowing files with accented or non-ASCII characters (such as 'café' or 'naïve') to be sorted alongside their ASCII equivalents ('cafe', 'naive'). This new \yazi-shared/src/translit\ module provides a \Transliterator\ trait and a lookup table to convert Unicode characters to their ASCII representations, ensuring consistent and predictable file ordering regardless of special characters in names.
yazi-shared/src/translit · high confidence
Autocomplete scripts generated for the \`ya\` CLI
The \yazi-cli\ crate now automatically generates shell completion scripts for the \ya\ command during the build process. This supports Bash, Fish, Zsh, Elvish, PowerShell, Nushell, and Fig, enabling users to get command-line autocompletion for \ya\ without manual setup.
yazi-cli · high confidence
Automated generation of dark and light theme icons
A new Lua script has been added to automatically generate and save icon definitions for both dark and light themes. The script reads icon data from separate source modules, rearranges them, and writes the resulting lists into the corresponding \theme-dark.toml\ and \theme-light.toml\ configuration files, ensuring that theme-specific icon sets are kept in sync with the source definitions.
scripts/icons · high confidence
Configurable manager layout ratios and mouse event handling
The manager configuration now exposes \ratio\ and \mouse\_events\ settings, allowing users to define the proportional widths of the parent, current, and preview panes via a three-element array and to selectively enable specific mouse interactions (click, scroll, touch, move, drag) through a string list. These options are validated at load time to ensure the layout ratio is non-zero and mouse event names are valid, providing finer control over the file manager's visual layout and input behavior.
yazi-config/src/mgr · high confidence
Configurable popup positioning and confirmation dialog details
Users can now customize the position and content of various UI popups. The configuration schema now supports setting specific origins and offsets for trash, delete, overwrite, and quit confirmation dialogs, as well as for input fields (cd, create, rename, filter, find, shell) and the open-picker. Additionally, confirmation dialogs now display file icons and truncate long lists to improve readability.
yazi-config/src/popup · high confidence
Configurable sorting for the which-key menu
Users can now customize how items are ordered in the which-key menu. The new configuration options allow sorting by key, in descending order, and with transliteration support, providing finer control over the menu's display.
yazi-config/src/which · high confidence
Configurable task worker limits and image memory bounds
Users can now explicitly configure the number of concurrent workers for file, plugin, fetch, preload, and process tasks, as well as the retry count for bizarre operations, using the new \Tasks\ configuration struct. Additionally, users can control image memory usage by setting the maximum allocation (\image\_alloc\) and bounds (\image\_bound\), and can suppress pre-caching tasks via the \suppress\_preload\ option.
yazi-config/src/tasks · high confidence
Dynamic Lua API for managing opener rules
Users can now inspect and modify opener configurations at runtime via Lua. The \opener\ object exposes methods to insert, remove, and match opener rules, allowing scripts to dynamically adjust how files are opened without restarting the application.
yazi-config/src/opener · high confidence
Dynamic Lua-based virtual filesystem engine
The VFS engine now supports a dynamic Lua provider, allowing users to define custom virtual filesystems via Lua scripts. This new engine implementation (located in yazi-vfs/src/engine/lua) exposes a full file-system API—including file open, read, write, directory listing, and metadata operations—backed by Lua code, enabling extensible, script-driven file access without recompiling the application.
yazi-vfs/src/engine/lua · high confidence
Dynamic keymap configuration via Lua API
The keymap configuration system now supports dynamic modification at runtime through a new Lua API. Users can programmatically insert, remove, and update keybindings using methods like \insert\, \remove\, and \update\ on the keymap objects, allowing for flexible, script-driven customization of keybindings beyond static TOML configuration files.
yazi-config/src/keymap · high confidence
Implement Freedesktop Trash support on Linux
Added a new trash backend for Linux that implements the Freedesktop Trash specification, enabling users to move files to the system trash and restore them. The implementation parses .trashinfo metadata to track original file locations and backing paths, supports listing, removing, and emptying the trash, and handles edge cases such as non-conforming orphaned trash items and recursive restoration of trashed directories.
yazi-fs/src/trash/freedesktop · high confidence
Implement macOS trash restore with original path recovery
The macOS trash implementation now parses the \.DS\_Store\ file to recover the original parent directory and filename for trashed items, enabling the restore operation to place files back in their exact previous locations rather than a generic destination. This change introduces the \DsStore\ parser and updates the \Trash\ module to resolve and use these original paths during restoration.
yazi-fs/src/trash/macos · high confidence
Initial Nix flake support with shell completions and desktop integration
This change introduces the Nix build infrastructure for Yazi, providing \nix/shell.nix\ for a development environment with the nightly Rust toolchain and \nix/yazi-unwrapped.nix\ for building the application. The package now installs shell completions for both \yazi\ and \ya\ commands, along with man pages, a desktop entry, and application icons. It also bundles essential runtime dependencies such as \ffmpeg\, \resvg\, \poppler-utils\, and \imagemagick\ to ensure full functionality out of the box.
nix · high confidence
Initial SFTP request protocol definitions
The \yazi-sftp\ crate introduces the foundational request structures for the SFTP protocol, enabling file operations such as opening, reading, writing, and closing files, as well as directory management (mkdir, rmdir, read\_dir), metadata handling (stat, lstat, fstat, set\_stat), and advanced features like symlinks, hardlinks, and POSIX renames. These structs define the serialization format for SFTP commands, allowing the plugin to communicate with remote SFTP servers.
yazi-sftp/src/requests · high confidence
Initial yazi-fs crate scaffolding and documentation
The yazi-fs crate has been introduced as a new internal component of Yazi, accompanied by a README clarifying that it is not intended for external use due to API stability guarantees. The crate includes a build script that configures platform-specific feature flags (trash\_unsupported, trash\_unix, trash\_freedesktop) to handle trash operations across different operating systems.
yazi-fs · high confidence
Input action parsing logic added to yazi-parser
The \yazi-parser\ crate now includes parsers for input-related actions (\close\, \recall\, \show\), enabling the system to interpret commands that control the input widget's lifecycle and configuration. Specifically, \CloseForm\ handles submission states, \RecallForm\ manages history navigation steps, and \ShowForm\ processes display options via \InputOpt\.
yazi-parser/src/input · high confidence
Introduce DDS (Data Distribution Service) for cross-instance synchronization
Adds a new DDS subsystem that enables multiple Yazi instances to share state and synchronize events in real-time. The implementation includes a client-server architecture using Unix domain sockets (with Windows support via UDS) for transport, a pub/sub system for broadcasting events (such as file moves, renames, theme changes, and tab navigation), and persistent state management to restore context when new instances connect. This allows plugins and the UI to react to changes happening in other Yazi windows or tabs seamlessly.
yazi-dds/src · high confidence
Introduce SFTP filesystem abstraction with Unix path support
The \yazi-sftp\ crate now includes a dedicated filesystem module (\src/fs\) that implements the core abstractions for interacting with remote servers via SFTP. This adds support for Unix-style paths, enabling correct handling of remote file attributes (such as size, permissions, and timestamps), directory listings, and asynchronous file I/O (read, write, seek). Users can now browse and manipulate files on SFTP servers using a consistent, Unix-oriented interface.
yazi-sftp/src/fs · high confidence
Introduce SFTP response serialization structures
The \yazi-sftp\ crate now includes a dedicated \responses\ module that defines the data structures for serializing SFTP protocol responses. This adds support for encoding file attributes, file data, extended requests, file handles, directory listings, status codes (including specific error handling like \FileAlreadyExists\ and \ConnectionLost\), and version negotiation, enabling the provider to correctly communicate with SFTP servers.
yazi-sftp/src/responses · high confidence
Introduce \`yazi-build\` build automation tool
A new \yazi-build\ crate has been added to provide a dedicated build system for Yazi, exposing three tasks via \cargo xtask\: \build\ to compile the project (with optional cross-compilation targets and completion generation), \dist\ to package the binaries into a Debian \.deb\ archive and a release zip, and \install\ to copy the built binaries to a specified directory or the default Cargo bin path.
yazi-build/src · high confidence
Introduce bottom-right notification widget
Adds a new notification system that renders messages in the bottom-right corner of the terminal to avoid covering file content. The implementation uses \ratatui\ to display styled, bordered paragraphs for each notification, supporting variable heights and horizontal positioning based on message progress percentage.
yazi-fm/src/notify · high confidence
Introduce dedicated file operation scheduler
The \yazi-scheduler\ crate is added to manage background tasks for file operations (copy, move, link, hardlink, delete, trash, download, upload) and preloading. It provides a structured way to track task progress, handle cleanup states, and manage concurrent operations via priority channels, replacing ad-hoc execution with a centralized scheduling system.
yazi-scheduler · high confidence
Introduce dynamic virtual filesystem specification parsing
Added a new \spec\ module that parses and represents virtual filesystem URLs, supporting distinct kinds such as Hub, View, and Mount. This includes logic for decoding authentication domains, URI/URN ports, and path components, along with Lua bindings that expose these specifications to the user-facing API.
yazi-shared/src/spec · high confidence
Introduce new Url, UrlBuf, and UrlCow types for URL handling
The \yazi-shared/src/url\ module has been replaced with a new multi-file implementation introducing \Url\, \UrlBuf\, and \UrlCow\ types. This change provides a unified, covariant URL abstraction that supports both OS-native and Unix-specific paths, handles authentication and view contexts, and enables zero-copy conversions and serialization. Users will see improved URL handling across the application, including better support for remote file systems, virtual file systems, and Lua bindings.
yazi-shared/src/url · high confidence
Introduce new \`ui.Pick\` component for item selection
A new \Pick\ component has been added to the \yazi-core\ crate, providing a scrollable UI element for selecting items from a list. This component manages a title, a vector of string items, and cursor/offset state, implementing the \Scrollable\ trait to handle navigation within the visible window. It serves as the foundational data structure and rendering logic for the improved \pick\ component UX mentioned in recent updates.
yazi-core/src/pick · high confidence
Introduce new completion (cmp) core module
The \yazi-core/src/cmp\ directory now contains the foundational data structures for the auto-completion feature. This includes the \Cmp\ struct which manages the completion state (matches, cursor, visibility), the \CmpItem\ struct representing individual completion suggestions, and the \CmpOpt\ struct for configuration options. This change establishes the internal model for how completion results are stored and accessed, serving as the backend for the UI components that display these suggestions.
yazi-core/src/cmp · high confidence
Introduce preset initialization and utility libraries
The \yazi-plugin/preset\ area now includes \setup.lua\ to initialize core plugins (dds, extract, place, trash), \compat.lua\ for compatibility handling, and \ya.lua\ which exposes utility functions like \dict\_merge\, \readable\_size\, and \readable\_path\ for use by plugins and users.
yazi-plugin/preset · high confidence
Introduce task action parsing forms in yazi-parser
The \yazi-parser\ crate now includes a \tasks\ module that defines data structures for parsing task-related actions. This adds forms for \Output\, \ProcessOpen\, \Spawn\, and \UpdateSucceed\, enabling the parser to extract specific configuration and identifiers from these events.
yazi-parser/src/tasks · high confidence
Introduce trash bin management capabilities
This change adds a new trash bin subsystem to the file system layer, enabling users to manage deleted items. The implementation provides a Lua-exposed API to list, inspect, rename, remove, and restore files and directories from the trash. It includes platform-specific support for Unix (via \trash\ crate), macOS, and Windows, while gracefully handling unsupported platforms by returning appropriate errors. The module also handles metadata retrieval for symlinks and supports recursive restoration of trashed items.
yazi-fs/src/trash · high confidence
Introduce virtual file system watcher for incremental updates
Added a new virtual file system watcher component that processes incremental change reports (URLs and cache keys) to keep the file manager's view in sync. This watcher batches incoming updates, resolves file stamps, and applies operations such as deleting missing files or upserting existing ones, while also triggering uploads for modified files.
yazi-watcher/src/virtual · high confidence
Introduce yazi-adapter for terminal image previewing
The new yazi-adapter crate provides the core logic for displaying image previews in the terminal. It automatically selects the best available rendering driver (Kitty Graphics Protocol, Sixel, IIP, Chafa, or Überzug++) based on the detected terminal emulator and environment, ensuring images are shown with correct color profiles and orientation.
yazi-adapter · high confidence
Introduce yazi-boot crate for application initialization
The new \yazi-boot\ crate centralizes the application's startup logic, exposing global static cells for arguments (\ARGS\), a unique client identifier (\ID\), and boot state (\BOOT\). Users can now specify a client ID via the \--client-id\ flag, define local and remote event reporting targets via \--local-events\ and \--remote-events\, and control working directory or selected file output paths using \--cwd-file\ and \--chooser-file\. The crate also supports passing multiple entry paths as positional arguments and includes a link to the quick-start guide in the help output.
yazi-boot/src · high confidence
Introduce yazi-parser notify module with push and tick actions
The new \yazi-parser\ crate includes a \notify\ module that defines two new action types: \push\, which allows sending notifications with customizable options via \MessageOpt\, and \tick\, which supports configuring a time interval for periodic events. These additions provide the underlying parsing and action-conversion logic for notification-related features within the parser layer.
yazi-parser/src/notify · high confidence
Introduce yazi-shim utility library for core Rust primitives
The yazi-shim module adds a new internal utility library providing cross-cutting helpers for the application. This includes safe, thread-aware cell types (SyncCell, RoCell), extended traits for byte and string manipulation (kebab/snake casing, UTF-8 validation), and a unified Lua userdata error system that maps standard I/O errors to Lua-friendly types. It also introduces a custom word-wrapping and line-composition engine for the ratatui terminal UI, platform-agnostic Unix socket networking for Windows, and specialized TOML deserialization logic to support overlaying configuration changes.
yazi-shim/src · high confidence
Introduce yazi-version crate for build-time versioning
A new \yazi-version\ crate has been added to the project, providing a centralized way to generate and display version information. The \build.rs\ script uses \vergen\_gitcl\ to embed the Git SHA, build date, and Rustc details into the binary at compile time. The library exposes functions like \version()\, \version\_long()\, and \version\_full()\ to format this data, and includes a \setup!\ macro that automatically prints the full version details and exits when the \--version\ flag is passed to the CLI.
yazi-version · high confidence
Introduces a string and byte interning pool to reduce memory usage
The \yazi-shared\ crate now includes a new \pool\ module that implements string and byte interning. This feature deduplicates identical strings and byte slices by storing only one copy in a global, thread-safe pool, which significantly reduces memory consumption for frequently used data like MIME types and URL domains. The implementation provides \Symbol\ types that behave like standard references but share underlying storage, and includes a \Deserialize\ implementation for \Symbol\<str\>\ to allow interning during configuration parsing.
yazi-shared/src/pool · high confidence
Introduces a unified 'Strand' type for path and string handling
The \yazi-shared\ crate now uses a new \Strand\ abstraction to represent text and paths, supporting UTF-8, OS-native, and raw byte representations. This change provides a consistent API for string operations, conversions, and serialization (including Lua and serde support) across the application, replacing previous ad-hoc handling of \OsString\, \String\, and byte slices.
yazi-shared/src/strand · high confidence
Introduction of Spark parser for Lua event handling
The \yazi-parser/src/spark\ module has been added to parse Lua events into a structured \Spark\ enum. This new component maps specific event kinds (such as \mgr:enter\, \app:title\, and \input:close\) to their corresponding internal forms, enabling the application to process user interactions and system events defined in Lua scripts.
yazi-parser/src/spark · high confidence
Introduction of new parser forms for completion and file operations
The \yazi-parser\ crate now includes new form definitions for completion (\cmp\) and file operation (\spot\) modules. Specifically, \CloseForm\ allows users to control whether the completion menu should submit and close, \ShowForm\ exposes completion options (\CmpOpt\) for display customization, and \TriggerForm\ enables triggering completions with an optional ticket identifier. Additionally, \CopyForm\ is introduced to handle file copy operations, specifying the type of copy action. These forms provide the underlying data structures for parsing user actions related to completion behavior and file copying.
yazi-parser/src/cmp · high confidence
Introduction of the Spot widget for overlay rendering
The \spot\ module has been added to the file manager, introducing a new \Spot\ widget that renders overlay content on top of the active window. This widget iterates through a list of child widgets stored in the core's active spot lock, transforms their areas to match the current window coordinates, and renders only those that intersect with the visible window area, effectively enabling layered UI elements.
yazi-fm/src/spot · high confidence
Introduction of the Spotter preview system
A new 'spot' module has been added to manage the spotter feature, which provides a dedicated preview pane for files. This includes the \Spot\ struct to handle the lifecycle of the preview (activation, aborting, and resetting) and the \SpotLock\ struct to store the state of the current preview, such as the file URL, metadata, and the rendered table data. The system integrates with the plugin system to match files with specific spotters based on MIME type and file properties.
yazi-core/src/spot · high confidence
Introduction of the yazi-boot crate
A new \yazi-boot\ crate has been added to the project structure. This crate contains the build script responsible for generating shell completion files for Bash, Fish, Zsh, Elvish, PowerShell, Nushell, and Fig when the \YAZI\_GEN\_COMPLETIONS\ environment variable is set. The crate is intended for internal use within the Yazi project and does not guarantee API stability for external consumers.
yazi-packing · high confidence
Introduction of the yazi-proxy crate for external command integration
A new \yazi-proxy\ crate has been added to provide a structured interface for external applications to interact with the Yazi file manager. This library exposes proxy modules for core components—including the app, file manager (mgr), input, confirm, pick, tasks, notify, cmp, and which (keybinding) systems—allowing external processes to trigger actions such as file opening, navigation, input prompts, and task spawning via a relay-based event system.
yazi-proxy/src · high confidence
Introduction of the yazi-vfs crate for unified virtual filesystem operations
The new yazi-vfs crate provides a unified abstraction layer for file system interactions, supporting local, SFTP, and Lua-based virtual file systems. It introduces traits for managing file entries, statistics, and file handles, along with utilities for cache stamping and HTTP file writing. This change enables concurrent chunked uploads/downloads over SFTP, dynamic previewer APIs via Lua, and custom VFS providers, allowing users to interact with remote and virtual file systems with the same consistency as local files.
yazi-vfs/src · high confidence
Introduction of yazi-build crate for bootstrapping
A new \yazi-build\ crate has been added to the project, containing a \build.rs\ script and documentation. This component is designed to handle the bootstrapping process by cloning the Yazi repository and building/installing the binaries during the build phase, specifically targeting scenarios where the manifest directory indicates a registry or git checkout source. It is explicitly marked as internal-only with no stability guarantees for external use.
yazi-build · high confidence
Lua bindings for DDS pub/sub messaging
Plugins can now publish and subscribe to events using the Data Distribution Service (DDS) via new Lua functions: \pub\, \pub\_to\, \sub\, \sub\_remote\, \unsub\, and \unsub\_remote\. This exposes the underlying DDS pub/sub mechanism to the plugin API, allowing scripts to send messages and listen for specific event kinds.
yazi-plugin/src/pubsub · high confidence
Lua bindings for the 'which' component activation
The yazi-parser crate now exposes Lua bindings for activating the 'which' component (the key-sequence hint overlay). Users can trigger this via Lua scripts using the \ActivateForm\, which accepts the component's options (\WhichOpt\) either directly or via an action object, enabling programmatic control of the which hint display.
yazi-parser/src/which · high confidence
New 'which key' component with configurable columns and borders
The 'which key' overlay, which displays available keybindings, has been implemented with support for configurable column counts and customizable borders. Users can now adjust the number of columns displayed via the \THEME.which.cols\ setting, and the component's appearance can be styled using \THEME.which.border\ and \THEME.which.mask\. The rendering logic handles layout splitting and padding to ensure the keybinding hints are displayed clearly within the terminal window.
yazi-fm/src/which · high confidence
New DDS event types for file operations and state changes
The \yazi-dds/src/ember\ module now defines a comprehensive set of new event types (Ember) to handle file operations and state changes. These include \bulk-rename\, \delete\, \download\, \duplicate\, \move\, \patch\, \rename\, \trash\, and \yank\ for file management, as well as \cd\, \load\, \hover\, \input\, \tab\, \theme\, \mount\, \hi\, \hey\, and \bye\ for session and UI state. Each event type is implemented with specific data structures (e.g., \EmberBulkRename\ for multiple URL changes, \EmberDuplicateItem\ for source/destination pairs) and supports serialization to Lua for plugin interaction.
yazi-dds/src/ember · high confidence
New Domain type for URL-safe byte sequences
A new \Domain\ type has been introduced in the shared domain layer to represent URL-safe byte sequences. It provides built-in percent-encoding methods (\encode\ and \encode\_parent\) for safe serialization of paths and identifiers, along with serialization support for JSON and Lua interop.
yazi-shared/src/domain · high confidence
New FFI layer for platform-specific capabilities
This change introduces the \yazi-ffi\ crate, providing a new Foreign Function Interface layer that enables platform-specific features. On Windows, it adds support for COM initialization, device interface enumeration, storage partition detection, and a message loop integration for async runtime compatibility. It also implements a mount manager that monitors disk and volume changes via Windows device notifications. On macOS, it uses IOKit for system integration. Additionally, the FFI layer introduces locale-aware date and time formatting that respects the user's system settings on all platforms (macOS, Windows, and Unix), and implements cross-platform named shared memory for efficient data transfer between processes.
yazi-ffi/src · high confidence
New Input UI component with context-aware icons
The \yazi-fm/src/input\ module now provides a dedicated \Input\ widget for user text entry. This component renders a bordered block that dynamically displays a context-aware file icon based on the input's purpose (e.g., \cd\, \create-file\, \rename-dir\), leveraging the current theme's icon configuration. It integrates with the core manager to handle positioning and delegates the actual text rendering to the underlying input state.
yazi-fm/src/input · high confidence
New Lua API for building custom UI elements
The \yazi-binding/src/elements\ module now exposes a comprehensive set of Lua-bindable UI primitives, allowing users to construct custom terminal interfaces programmatically. This includes layout management (Layout, Constraint, Rect, Area), text rendering (Text, Line, Span, Align, Wrap), structural components (Table, Row, Cell, List, Gauge, Fill, Bar), and visual styling (Color, Style, Border, Pad, Edge). These bindings enable dynamic creation and manipulation of the terminal UI directly from Lua scripts.
yazi-binding/src/elements · high confidence
New Lua API for dynamic theme and icon customization
Users can now access and modify theme properties dynamically via Lua using the \th\ global object. This change introduces a new \yazi-plugin/src/theme\ module exposing Lua bindings for the \app\ (including the new \overall\ background color), \mgr\ (including \marker\_symbol\ and \syntect\_theme\), \tabs\, \mode\, \indicator\, \status\, and other UI components. A new \icon\ submodule allows checking file icon matches based on hover state, enabling plugins and users to adjust visual styling and icon behavior at runtime.
yazi-plugin/src/theme · high confidence
New Lua API for managing background tasks
Users can now control background operations (such as file extraction or URL downloads) directly from Lua scripts. The new \TaskOpt\ and \Task\ bindings expose methods to spawn tasks, set their display names, and monitor or manipulate their lifecycle via \progress\, \log\, \cancel\, \succeed\, and \fail\ calls.
yazi-plugin/src/tasks · high confidence
New Lua API for spawning and managing child processes
The \yazi-binding\ crate now exposes a \Command\ API in Lua, allowing scripts to spawn external processes, configure arguments, environment variables, and working directories, and manage their standard input/output/error streams. Users can read from stdout/stderr, write to stdin, and wait for process completion, receiving the exit status and output buffers. On Windows, spawned processes are automatically assigned to a job object to ensure they are terminated when the parent exits, and on Unix systems, a memory limit can be set for the child process.
yazi-binding/src/process · high confidence
New Lua API for tasks, UI, and plugin synchronization
The plugin system now exposes a comprehensive set of new Lua APIs. Users can manage background operations via the \task\ API (supporting copy, move, plugin, and custom tasks) and interact with the UI through the \ui\ namespace (providing elements like Text, Table, and Gauge, plus functions like \area\, \hide\, \redraw\, and \render\). Plugin logic is enhanced with synchronization primitives including \ya.co()\ for coroutines, \ya.sync()\ for blocking execution, \ya.async()\ for isolated async blocks, and \ya.join()\ for concurrent function execution. Additional utilities include \ya.which()\, \ya.input()\, and \ya.confirm()\ for interactive prompts, \ya.notify()\ for notifications, and helpers for JSON, HTTP, image processing, and text manipulation.
yazi-plugin/src/utils · high confidence
New Lua APIs for filesystem operations and keymap access
This change introduces new Lua bindings for the \fs\ and \keymap\ modules. The \fs\ module now exposes functions to calculate directory sizes (\calc\_size\), access file metadata (\stat\), perform file operations like copy, create, rename, and remove, retrieve partition information, and manage file operations via a \FilesOp\ interface. Additionally, the \keymap\ module allows Lua scripts to access and modify keymap configurations for specific layers.
yazi-plugin/src/fs · high confidence
New Lua HTTP client with streaming and Unix socket support
The \yazi-binding/src/http\ module now provides a complete HTTP client implementation exposed to Lua. Users can construct requests with headers, raw bytes, URL-encoded fields, and multipart file parts via \HttpBuilder\. The client supports streaming request bodies and responses through \HttpSession\ and \HttpResponse\, allowing efficient handling of large data. Additionally, it supports connecting to HTTP servers via Unix domain sockets when a socket path is specified, enabling local service communication. Also in this area: 1 commit (0 fixes) modifying (repo-wide).
yazi-binding/src/http · low confidence · unverified
New Lua binding infrastructure for channels, iterators, and runtime management
The \yazi-binding\ crate now exposes a comprehensive set of Lua bindings for internal Rust primitives, enabling plugins to interact with the application's concurrency and state models. Users can now use Lua to manage asynchronous communication via \MpscTx\/\MpscRx\ and \OneshotTx\/\OneshotRx\ channels, iterate over sequences with the cacheable \Iter\ type, and control execution scope using the \Scope\ cancellation token. Additionally, the bindings provide a \Composer\ for cached Lua state access, \Handle\ for aborting async tasks, and \PercentMode\ for URL encoding, while the \Runtime\ module exposes the internal execution stack and blocking context to Lua scripts.
yazi-binding/src · high confidence
New Lua bindings for Position and Style types
The yazi-binding module now exposes Lua-accessible \Position\ and \Style\ types, allowing scripts to construct and manipulate UI layout and formatting. The \Position\ binding supports specifying an origin (e.g., TopLeft, Center, Hovered) and offset (x, y, width, height), with methods to apply padding and calculate final screen rectangles. The \Style\ binding provides methods to get/set foreground/background colors and toggle text modifiers like bold, italic, underline, and blink, enabling fine-grained control over terminal output appearance from Lua.
yazi-binding/src/position · high confidence
New Lua runtime API for dynamic configuration and environment introspection
The \yazi-plugin/src/runtime\ module introduces a new Lua API (\rt\) that exposes runtime state and configuration options to plugins. This allows users to dynamically read and adjust settings such as the manager layout ratio (\rt.mgr.ratio\), sorting preferences (\rt.mgr.sort\\\), previewer parameters (\rt.preview.\\), and worker counts (\rt.tasks.\\). It also provides access to environment details like terminal capabilities (\rt.term\), application arguments (\rt.args\), and plugin registries (\rt.plugin\), enabling more responsive and context-aware plugin behavior.
yazi-plugin/src/runtime · high confidence
New Lua time API with locale-aware formatting
The \yazi-binding/src/time\ module now exposes a new \Time\ type and \Duration\ type to Lua, allowing scripts to access current time, perform arithmetic, and format timestamps. A key behavioral change is that the \Time:format()\ method now respects the user's locale settings when passed an options table, replacing the previous behavior of strictly requiring a format string. This ensures date and time output matches the user's regional preferences.
yazi-binding/src/time · high confidence
New Lua-based UI component architecture
The preset UI components (app, backdrop, current, dnd, entity, header, linemode, marker, markers, modal, parent, preview, progress, rail, rails, root, status, tab, tabs, tasks) have been rewritten in Lua. This introduces a new component model with explicit reflow and redraw phases, supports mouse events (click, scroll, drag-and-drop), and implements the new tab layout with resizable panes, a custom header with search/filter indicators, and a status bar with mode, length, name, permissions, and position information.
yazi-plugin/preset/components · high confidence
New SFTP provider crate with custom binary serialization
The \yazi-sftp\ crate introduces a new SFTP virtual filesystem provider for Yazi. It implements a custom binary serialization format (using \serde\) for SFTP packets, supporting only specific types like \u8\, \u32\, \u64\, strings, and bytes, while rejecting others. The provider includes an \Operator\ for executing SFTP operations (open, read, write, stat, etc.) and a \Session\ that manages the connection using \russh\, handling async I/O, request/response matching via IDs, and timeouts.
yazi-sftp/src · high confidence
New VFS authentication and authority model
The application introduces a new internal authentication and authority model to support advanced Virtual File System (VFS) features. This change adds a structured \Auth\ system that distinguishes between regular, hub, view, and custom schemes, enabling hierarchical parent-child relationships for authentication contexts. It specifically supports 'hub' and 'view' VFS kinds, allowing users to access remote or virtual file systems with proper credential handling and path resolution, while maintaining backward compatibility for local file operations.
yazi-shared/src/auth · high confidence
New \`ya pack\` command for managing plugins and flavors
Users can now install, upgrade, and delete plugins and themes (flavors) via the new \ya pack\ CLI subcommand. This feature introduces a \package.toml\ configuration file to track dependencies, supporting Git-based sources with revision locking and integrity verification via content hashing. The implementation handles cloning repositories, materializing Git symlinks for consistent hashes, and deploying assets and source files to the user's configuration directory, with a \--discard\ flag available to override local modifications.
yazi-cli/src/package · high confidence
New \`ya\` CLI subcommands for terminal drawing, screenshot capture, and synchronous execution
The \ya\ CLI now supports three new subcommands that communicate with running Yazi instances via the DDS protocol. \ya draw\ connects to an active instance to listen for and display specific message kinds (e.g., file operations), reconnecting automatically if the connection is lost. \ya shot\ sends a one-time message to a receiver (such as triggering a screenshot) and verifies version compatibility and receiver capabilities before sending. \ya exec\ allows executing an action within a Yazi instance and awaiting the result, returning the data or an error to the caller. These commands enable external scripts and tools to interact with Yazi's UI and state programmatically.
yazi-cli/src/dds · high confidence
New \`ya\` CLI tool for package management, DDS communication, and environment inspection
The \yazi-cli\ crate introduces the \ya\ command-line interface, providing users with a standalone tool to manage plugins (\ya pkg\), communicate with running Yazi instances via DDS (\ya emit\, \ya emit-to\, \ya exec\, \ya pub\, \ya pub-to\, \ya sub\), and inspect system state (\ya env\, \ya cache\). This CLI enables external scripts and processes to interact with the file manager's plugin system and internal messaging bus, supporting features like executing actions with awaited results, publishing messages with various body formats, and managing package installations and upgrades.
yazi-cli/src · high confidence
New \`yazi env\` command for environment diagnostics
Users can now run \yazi env\ to print a comprehensive diagnostic report of the current environment. This output includes Yazi and Ya versions, configuration file states (init, yazi, keymap, theme, vfs, package), detected terminal emulator and desktop environment details, SSH/WSL status, relevant environment variables, configured text openers, detected multiplexers (tmux, Zellij), versions of external dependencies (file, ueberzugpp, ffmpeg, etc.), clipboard tools, and a test of the \file\ command output. This aids in troubleshooting setup issues and verifying that all required components are correctly detected.
yazi-cli/src/env · high confidence
New app-level event forms for clipboard, drag-and-drop, and Lua actions
The \yazi-parser/src/app\ module now includes dedicated form structs for handling specific application events, including clipboard operations, drag-and-drop interactions, mouse events, and inline Lua code execution. These forms (e.g., \ClipboardForm\, \DndForm\, \LuaForm\) standardize how these events are parsed from actions and passed into the application logic, enabling features like custom app titles, plugin interception, and Vim-like Lua snippets.
yazi-parser/src/app · high confidence
New asynchronous event stream backend for terminal input
The terminal input handling now uses a new \EventStream\ implementation located in \yazi-term/src/stream\. This change introduces a dedicated worker thread that polls the event source and pushes events into an asynchronous channel, allowing the main application to consume terminal events via a standard \Stream\ interface. This replaces the previous synchronous or less structured event consumption model, enabling non-blocking event processing and better integration with the async runtime.
yazi-term/src/stream · high confidence
New codegen derives for flexible config deserialization and overlaying
The \yazi-codegen\ crate now provides \DeserializeOver\, \DeserializeOver1\, \DeserializeOver2\, and \Overlay\ procedural macros. These allow configuration structs to be deserialized with support for flattened fields and custom serde attributes, while the \Overlay\ derive enables merging new configuration values into existing ones, facilitating dynamic config updates and theme hot-reloading.
yazi-codegen/src · high confidence
New completion popup widget
Added a new completion popup component that renders a list of completion items (files and directories) with icons and styling, positioned relative to the input area using the new ratatui-core rendering system.
yazi-fm/src/cmp · high confidence
New configurable sorting for the which-key menu
The which-key component now supports sorting its candidate list. Users can configure the sort order (by key or description), case sensitivity, sort direction, and transliteration via the \which.sort\_by\, \which.sort\_sensitive\, \which.sort\_reverse\, and \which.sort\_translit\ settings, allowing for a more predictable and customizable keymap navigation experience.
yazi-core/src/which · high confidence
New configuration subsystem with global state and layout management
The \yazi-config\ crate now provides a complete configuration subsystem that manages global state for the application. It introduces a \Layout\ struct to define screen regions for the current view, preview, and progress indicators, and a \Yazi\ struct that aggregates all major configuration sections (manager, preview, opener, tasks, etc.). The system initializes these settings from preset defaults and user-provided TOML files, exposing them via global static cells (\YAZI\, \KEYMAP\, \THEME\, \VFS\) for application-wide access. It also includes a \Pattern\ module for matching file URLs and MIME types, and a \mixing\ mechanism to merge configuration layers while handling deduplication.
yazi-config/src · high confidence
New confirm component for user prompts
A new \Confirm\ component has been added to the core module, providing the data structure for displaying confirmation dialogs. This struct holds the title, body text, and list of options to present to the user, along with positioning, visibility state, and a completion token to manage the interaction lifecycle.
yazi-core/src/confirm · high confidence
New confirm component with customizable styling
Users now have a dedicated confirm component that displays a title, a scrollable list of items, and Yes/No buttons, all rendered with a rounded border. This component supports custom styles for the border, title, body text, list content, and button labels, allowing users to tailor the appearance of confirmation dialogs via their theme configuration.
yazi-fm/src/confirm · high confidence
New input widget with history, undo/redo, and configurable navigation gait
The input widget in \yazi-widgets/src/input\ has been rewritten to support persistent input history, undo/redo via a versioned snap system, and configurable word-navigation gait (Fine, Lean, Wide). It also introduces an obscure mode for password entry, real-time and completion callbacks, and Lua bindings for programmatic control.
yazi-widgets/src/input · high confidence
New mount and partition management system with platform-specific monitoring
The filesystem module now includes a dedicated mount manager that automatically detects and monitors local partitions and drives on Linux, macOS, and Windows. This system reads mount points and partition metadata (such as labels, filesystem types, capacity, and whether a drive is external or removable) from OS-specific sources like /proc/mounts, Disk Arbitration, and Windows Volume APIs. It continuously watches for changes to keep the list of available mounts up to date, allowing the application to correctly identify and handle different storage devices and filesystems across all supported platforms.
yazi-fs/src/mounts · high confidence
New plugin configuration types: fetchers, preloaders, previewers, and spotters
The plugin configuration module now defines dedicated configuration structures for fetchers, preloaders, previewers, and spotters. Each type includes its own matcher logic, Arc-based wrapper for shared ownership, and Lua userdata bindings that expose methods for inserting, removing, and updating rules dynamically. The main \Plugin\ config struct now aggregates these four collections, supporting prepend and append operations to allow users to mix custom rules with defaults.
yazi-config/src/plugin · high confidence
New preset plugins for archive, extraction, and file management
This change introduces a suite of new built-in Lua plugins in the preset directory, significantly expanding Yazi's file handling capabilities. The new \archive\ plugin provides a tree-view preview for archives (including compressed tarballs) and supports listing metadata, while the \extract\ plugin allows users to extract archives with password support and automatic target directory handling. Additional plugins include \dnd\ for drag-and-drop support (files, HTTP URLs, data URIs, and PNGs), \trash\ for managing the trash bin, \clipboard\ for handling clipboard operations, and \place\ for viewing Windows drives. The update also adds \fd\ and \rg\ plugins for file searching, \fzf\ for fuzzy finding, and \session\ for syncing yanked state across instances.
yazi-plugin/preset/plugins · high confidence
New preview configuration options for image delay, quality, and text wrapping
Users can now configure specific preview behaviors through the \yazi-config\ module. The \image\_delay\ option (0–100) allows debouncing image previews to reduce terminal lag during fast scrolling, while \image\_quality\ (50–90) lets users adjust the compression level of generated images. Additionally, the \wrap\ setting controls whether text previews wrap lines, and \cache\_dir\ specifies where preview artifacts are stored, defaulting to the system temp directory if left empty.
yazi-config/src/preview · high confidence
New shared utility library for core primitives and helpers
The \yazi-shared\ crate has been introduced to centralize common types and utilities used across the application. This includes a new \Id\ type for unique identifiers, a \Layer\ enum to define UI stacking contexts, and a \Condition\ parser for evaluating logical expressions. It also provides foundational helpers such as natural sorting (\natsort\), string manipulation (\chars\), debouncing and throttling streams, and a \Twiddle\ encoder/decoder for compact string serialization.
yazi-shared/src · high confidence
New task management system with scheduler and Lua bindings
The task manager has been ported to Lua and restructured into a new \yazi-core/src/tasks\ module. This introduces a dedicated scheduler that handles file operations (move, copy, link, hardlink, remove/trash) and plugin preloading/fetching. Users now have finer control over concurrent workers and can see progress for each individual task. The system also supports immediate task cancellation and integrates with the new event system for better responsiveness.
yazi-core/src/tasks · high confidence
New terminal event subsystem with clipboard and drag-and-drop support
The \yazi-term/src/event\ module has been replaced with a new event handling architecture that introduces native support for terminal clipboard operations and drag-and-drop interactions. Users can now interact with the system clipboard via OSC 5522 sequences, receiving read/write success or error events. Additionally, the terminal now supports the drag-and-drop protocol (OSC 72), allowing files and URLs to be dragged into the file manager, with events exposing coordinates, operations (move/copy), and MIME types. The event system also includes refined keyboard handling (including Kitty protocol support and lock-key state management), mouse event reporting, and platform-specific wakers for efficient I/O notification on Unix and Windows.
yazi-term/src/event · high confidence
New terminal input parser with Kitty protocol and clipboard support
The terminal input parser has been rewritten to support advanced terminal features, including the Kitty keyboard protocol (enabling precise key reporting and diacritic handling), OSC 5522 for clipboard operations, and OSC 72 for drag-and-drop events. The new parser also handles CSI reports for device attributes, cursor shape, and color scheme, while adding state limits and timeouts to prevent potential denial-of-service issues from malformed sequences.
yazi-term/src/parser · high confidence
New theme configuration system with custom sections and filetype rules
The theme configuration system has been redesigned to support user-defined custom sections and granular filetype styling. Users can now define arbitrary custom style sections in their theme configuration, which are accessible via a new Lua API. Additionally, a new \\[filetype\]\ section allows users to define rules that apply specific styles to files based on their properties (such as name, extension, or metadata), enabling more precise visual customization of the file list.
yazi-config/src/theme · high confidence
New unified Data and DataAny types for structured data handling
The \yazi-shared/src/data\ module now introduces a new \Data\ enum and \DataAny\ trait to provide a unified, serializable, and Lua-compatible representation for structured data. \Data\ supports nested structures (lists, dicts) and specific types (URLs, paths, bytes, IDs), while \DataAny\ allows arbitrary Rust types to be wrapped and passed to Lua. This change enables more flexible data exchange between the core and Lua scripts, supporting deserialization from various sources and conversion to Lua values.
yazi-shared/src/data · high confidence
New wire protocol and Lua serialization support
Added a new binary wire format for serializing data between the Rust core and the Lua environment, including a custom encoder/decoder, a \Wire\ data type, and Lua bindings for seamless conversion.
yazi-shared/src/sendable, yazi-shared/src/wire · high confidence
New yazi-emulator crate for terminal capability detection
The new \yazi-emulator\ crate centralizes the detection and management of terminal emulator capabilities. It identifies specific terminal brands (such as Kitty, WezTerm, iTerm2, and tmux) via environment variables and CSI responses, probes for features like Sixel, Kitty Graphics Protocol (KGP), and color schemes, and handles necessary workarounds for multiplexers like tmux to ensure correct passthrough and cursor synchronization.
yazi-emulator · high confidence
New yazi-tty crate for cross-platform terminal I/O and escape sequences
The \yazi-tty\ crate has been introduced to centralize terminal input/output handling and escape sequence generation. It provides a unified \Handle\ abstraction for reading from and writing to standard input/output on both Unix and Windows, including fallbacks to \/dev/tty\ and \CONIN$\/\CONOUT$\. The crate exposes a global \Tty\ singleton with thread-safe readers and writers, and includes a comprehensive \sequence\ module for generating terminal control codes. This module supports cursor manipulation, color styling (SGR), screen clearing, bracketed paste, mouse capture, focus reporting, synchronized updates, and advanced features like drag-and-drop (OSC 72) and clipboard operations (OSC 52). It also includes Lua bindings to allow scripts to queue these sequences directly to the terminal.
yazi-tty · high confidence
New yazi-widgets crate with Lua-exposed UI primitives and clipboard support
The \yazi-widgets\ crate has been introduced to centralize UI rendering logic, exposing a set of Lua-bindable widgets (Line, Text, List, Bar, Clear, Fill, Border, Input, Gauge, Table) via the \Renderable\ enum and \Renderables\ reducer. This change adds a cross-platform clipboard abstraction (\yazi-widgets/src/clipboard.rs\) that retrieves and sets system clipboard content on both Unix (using pbpaste/wl-paste/xclip) and Windows (using clipboard\_win), and introduces a \Scrollable\ trait with a \Step\ enum to handle viewport-relative and absolute scrolling for list-like widgets.
yazi-widgets/src · high confidence
Platform-specific terminal state restoration
A new \restorer\ module has been added to \yazi-term\ to handle saving and restoring terminal settings when exiting. On Unix systems, it captures and restores \termios\ attributes using \rustix\, while on Windows it saves and restores console input/output modes and code pages via the Windows Console API. This ensures the terminal returns to its original state after the application runs.
yazi-term/src/restorer · high confidence
Repository initialization and development environment setup
The repository has been initialized with essential configuration files for the development workflow. This includes a Nix flake (\flake.nix\) and lock file (\flake.lock\) for reproducible builds, a \.envrc\ to automatically load the Nix environment, and formatting configurations for Rust (\rustfmt.toml\) and Lua (\stylua.toml\). Additionally, a \.luarc.json\ file configures the Lua language server to target Lua 5.5, reflecting the project's runtime version, while \AGENTS.md\ and \CONTRIBUTING.md\ provide guidelines for contributors and AI agents.
(repo-wide) · high confidence
SFTP virtual filesystem engine added
Users can now access remote files via SFTP using the \sftp://\ URL scheme. This change introduces a new VFS engine in \yazi-vfs/src/engine/sftp\ that manages connection pooling, supports password and public-key authentication (including certificates), and implements standard file operations such as reading directories, opening files for read/write, creating/removing directories and files, renaming, and setting file attributes.
yazi-vfs/src/engine/sftp · high confidence
Unified VFS engine with Lua and SFTP support
The VFS engine in yazi-vfs has been refactored to support multiple backend types through a unified abstraction. The new engine dispatches operations to local, SFTP, or Lua-based filesystems depending on the URL scheme, enabling custom VFS providers via Lua scripts and remote file access via SFTP. This change introduces new modules for handling absolute paths, directory entries, file reading/writing, and copy operations across these backends, while maintaining a consistent API for file operations.
yazi-vfs/src/engine · high confidence
Unified path representation with URI/URN awareness
The \yazi-shared/src/loc\ module introduces a new path abstraction (\Loc\, \LocBuf\, \LocCow\) that generalizes path handling to support both standard filesystem paths and URI-like structures. This change allows the application to manage paths with embedded URI and URN components, enabling features like VFS (Virtual File System) support and SFTP path encoding while maintaining compatibility with standard OS paths.
yazi-shared/src/loc · high confidence
Removals
Removal of core file manager modules
The \src/core/manager\ directory has been completely removed, deleting the \folder\, \manager\, \mode\, \preview\, \tab\, \tabs\, and \watcher\ modules. This eliminates the application's internal file browsing, tab management, preview rendering, and file-watching capabilities.
src/core/manager · high confidence
Removal of core task management subsystem
The entire \src/core/tasks\ module has been deleted, removing the internal implementation for background task scheduling, file operations (copy, move, delete, trash), process execution, and media precaching (image/video thumbnails). This eliminates the code responsible for managing and displaying the progress of these operations within the application.
src/core/tasks · high confidence
Removal of header UI components
The header UI module has been removed from the application. This change deletes the \layout.rs\, \mod.rs\, and \tabs.rs\ files, eliminating the code responsible for rendering the current working directory path and the tab navigation indicators in the user interface.
src/ui/header · high confidence
Removal of legacy UI manager components
The \src/ui/manager\ module has been removed, deleting the \folder.rs\, \layout.rs\, \preview.rs\, and \mod.rs\ files. This eliminates the previous implementation of the file list rendering, window layout constraints, and image/text preview logic that relied on the \ratatui\ library and \Kitty\ terminal image protocol.
src/ui/manager · high confidence
Removal of legacy configuration manager and sorting logic
The previous configuration manager implementation and its associated sorting logic have been removed from the codebase. This deletes the \Manager\ struct that handled loading settings from \yazi.toml\, including default values for the current working directory and cache path, as well as the \SortBy\ enum and its deserialization logic used for file sorting. Users relying on this specific configuration structure will need to migrate to the new configuration system.
src/config/manager · high confidence
Removal of legacy configuration module and pattern matching logic
The \src/config\ module, which previously managed global configuration state for keymaps, managers, opening behavior, previews, and themes via lazy initialization, has been removed. Additionally, the \Pattern\ struct and its associated glob-matching logic (including folder-specific matching and deserialization) have been deleted. This change eliminates the previous centralized configuration system and its pattern-matching capabilities from the codebase.
src/config · high confidence
Removal of legacy file-opening configuration module
The \src/config/open\ module, which previously handled file-opening logic via \yazi.toml\ configuration (including opener definitions and MIME-based rules), has been removed. This change eliminates the legacy configuration structure for opening files, indicating that this functionality is no longer supported or has been replaced by a different mechanism elsewhere in the application.
src/config/open · high confidence
Removal of legacy keymap configuration system
The \src/config/keymap\ module has been completely removed, eliminating the previous keybinding configuration system. This deletes the \Key\ struct (which parsed modifier strings like \\<C-a\>\), the \Exec\ struct (which parsed command strings), and the \Keymap\ loader that read \yazi/keymap.toml\ from the XDG config directory. Users can no longer define custom keybindings via this TOML-based configuration file.
src/config/keymap · high confidence
Removal of legacy preview configuration module
The preview configuration module located in src/config/preview has been removed. This deletes the previous implementation that handled preview settings such as tab size, max width, and max height via a dedicated Manager and Preview struct hierarchy. Users relying on this specific configuration structure will no longer have access to these settings through this module.
src/config/preview, src/config/theme · high confidence
Removal of legacy status bar UI components
The previous status bar implementation, including the layout logic, progress gauge widget, and module exports, has been removed from the application. This change eliminates the hardcoded horizontal layout and specific color styling that were previously rendered in the UI status area.
src/ui/status · high confidence
Removal of misc utility modules
The \defer\, \fns\, and \chars\ modules within the \misc\ crate have been removed, eliminating helper functions for terminal size detection, path manipulation, file size calculation, and copy progress tracking from this location.
src/misc · high confidence
Removal of the legacy UI module
The entire \src/ui\ module has been removed from the codebase. This deletion eliminates the previous terminal user interface implementation, including the main application loop (\app.rs\), the context and state management (\context.rs\), the keybinding dispatcher (\dispatcher.rs\), and all associated rendering components for the header, manager, status bar, input field, and task list. Users will no longer have access to this specific UI layer.
src/core/input, src/ui · high confidence
Removal of the main application entry point
The \src/main.rs\ file has been deleted, removing the application's entry point that previously initialized configuration and launched the UI. This change eliminates the code responsible for starting the \App\ instance and setting up the async runtime.
src · high confidence
Architecture
Extract terminal handling into a dedicated yazi-term crate
Terminal input/output management, dimension detection, and raw/cooked mode switching have been moved into a new \yazi-term\ crate. This refactoring isolates platform-specific terminal logic (Unix via \rustix\ and Windows via \windows-sys\) and provides a unified \setup()\ entry point, improving code organization and maintainability without changing user-facing behavior.
yazi-term/src · high confidence
Introduce yazi-parser crate for action form deserialization
The new \yazi-parser\ crate provides a centralized location for parsing and deserializing action forms (such as \ArrowForm\, \CloseForm\, \ShowForm\, and \VoidForm\) from Lua and internal action events. This refactoring extracts parser logic from the main application, introducing macros to streamline module exports and type conversions, which supports the broader architectural shift toward a custom VFS provider and actor model.
yazi-parser/src · high confidence
Introduction of the actor model for command processing
The application's internal command processing has been refactored to use a new actor model, defined in the \yazi-actor\ crate. This change introduces a structured \Actor\ trait and a suite of actor implementations (such as \Bootstrap\, \Plugin\, \Input\, and \Theme\) that handle core operations. For users, this represents a significant architectural shift in how the application manages state and executes commands, laying the groundwork for improved concurrency and a more modular plugin system.
yazi-actor/src · high confidence
Manager action parsing moved to yazi-parser
The \yazi-parser/src/mgr\ module now contains the dedicated form structs that parse and validate all file-manager actions (such as \cd\, \copy\, \create\, \link\, \remove\, \rename\, \sort\, \tab\ operations, and \yank\/\paste\). This change centralizes the deserialization logic for these commands, ensuring consistent argument handling and validation before they are executed by the core manager.
yazi-parser/src/mgr · high confidence
Manager subsystem refactored into modular components
The file manager's internal architecture has been restructured into distinct, focused modules within the \mgr\ crate. The core \Mgr\ struct now explicitly composes \Tabs\, \Yanked\ (clipboard), \Batcher\, \Watcher\, and \Mimetype\ services, replacing the previous monolithic implementation. New modules handle specific concerns: \cd.rs\ defines navigation sources (e.g., \Cd\, \Reveal\, \Follow\), \filter.rs\ and \find.rs\ manage search/query options, \open.rs\ standardizes file opening parameters, and \snap.rs\ provides snapshotting capabilities for tabs and yanked files. This change improves code organization and separation of concerns within the manager layer.
yazi-core/src/mgr · high confidence
New modular application architecture with dedicated entrypoint and event dispatching
Yazi has been restructured into a modular architecture centered around the new \yazi-fm\ crate, which serves as the main application entrypoint. This change introduces a dedicated \Dispatcher\ to route terminal events (keys, mouse, resize, focus, paste, drag-and-drop, clipboard) and a \Router\ to handle keymap lookups and chord matching based on the current UI layer. An \Executor\ now manages action execution across distinct layers (App, Mgr, Tasks, Spot, Pick, Input, Confirm, Help, Cmp, Which, Notify). The application lifecycle is explicitly managed through separate modules for logging (\Logs\), signal handling (\Signals\), and panic recovery (\Panic\), while the UI rendering is coordinated by a \Root\ widget and a Lua-driven \Renderer\. This separation replaces the previous monolithic structure, providing a clearer separation of concerns for event handling, action execution, and UI composition.
yazi-fm/src · high confidence
New modular manager structure with modal and preview components
The file manager's internal structure has been reorganized to support a new rendering architecture. A new \mgr\ module has been introduced, containing \modal.rs\ and \preview.rs\ which implement the \Widget\ trait for rendering modals and file previews respectively. The preview component specifically handles layout validation by checking if the preview area matches the configured layout before rendering child widgets, ensuring correct spatial alignment within the terminal interface.
yazi-fm/src/mgr · high confidence
New procedural macro library for shared utilities
The \yazi-macro\ crate has been introduced to centralize procedural macros used across the application. This new module provides reusable utilities for loading configuration, plugin, and theme presets; implementing data serialization and Lua bindings via \impl\_data\_any\; emitting and relaying application events; handling conditional rendering triggers; and managing platform-specific logic and logging. This refactoring consolidates these cross-cutting concerns into a single library to reduce code duplication in other parts of the codebase.
yazi-macro/src · high confidence
Refactored local filesystem engine into modular components
The local filesystem engine has been restructured from a single monolithic implementation into a set of specialized, modular components. This change introduces dedicated modules for handling absolute path resolution (absolute.rs), asynchronous directory size calculation (calculator.rs), safe directory removal without following symlinks (clear.rs), file building operations (demand.rs), directory entry metadata handling (dir\_entry.rs), file identity verification (identical.rs), and directory reading (read\_dir.rs). The main engine logic (local.rs) now delegates to these components, improving code organization and maintainability while preserving the existing local file operation capabilities.
yazi-fs/src/engine/local · high confidence
Behavioural changes
1 commit (0 fixes) modifying (repo-wide)
A change to existing behaviour in (repo-wide) — 1 commit, 78 files: “feat: make selected and yanked states indexable (\#4494)” (refs \#4494).
yazi-fs/src/files, yazi-fs/src/splatter · low confidence · unverified
1 commit (0 fixes) modifying yazi-cli/src/cmp, yazi-headless, yazi-widgets/src/cmp
A change to existing behaviour in yazi-cli/src/cmp, yazi-headless, yazi-widgets/src/cmp — 1 commit, 7 files: “feat: autocomplete VFS URLs and package IDs (\#4464)” (refs \#4464).
yazi-cli/src/cmp, yazi-headless, yazi-widgets/src/cmp · medium confidence · unverified
5 commits (0 fixes) modifying yazi-binding/src/runtime
A change to existing behaviour in yazi-binding/src/runtime — 5 commits, 5 files: “feat: Windows drives view (\#4412)”; “feat: rework filesystem APIs (\#4483)”; “feat: compress files (\#4477)”; and 2 more (refs \#4412, \#4483, \#4477, \#4431, \#4451).
yazi-binding/src/runtime · medium confidence · unverified
Added build-time checks for Windows unwinding and crate installation
The yazi-fm crate now includes a build script that enforces specific build configurations. On Windows, it ensures unwinding is enabled by panicking if the standard release profile is used, directing users to use a specific profile instead. It also prevents building from crates.io without using the \yazi-build\ tool, addressing Cargo limitations for that distribution method.
yazi-fm · high confidence
Configurable open rules with prepend/append support
The \\[open\]\ section in \yazi.toml\ now supports \prepend\_rules\ and \append\_rules\ fields, allowing users to inject custom open rules before or after the default preset rules. This ensures that user-defined rules can reliably override or extend the built-in behavior for opening files and directories, rather than being ignored or having their precedence determined by insertion order alone.
yazi-config/src/open · high confidence
Core state management and file synchronization refactored
The internal architecture for managing application state and file system changes has been restructured. A new \Ctx\ struct now provides a unified context for actions, replacing the previous \context\ module and simplifying access to the core manager and tab state. The \Core\ struct has been expanded to include new components like \Pick\, \Confirm\, and \Which\, while the \Invalidator\ and \Reconciler\ modules have been introduced to handle file operations more robustly. Specifically, the \Reconciler\ ensures that selected and yanked file states are correctly updated during full list updates, creations, deletions, and modifications, preventing stale state issues. The \Invalidator\ efficiently marks folders as stale when files are deleted or modified, ensuring the UI reflects the current file system state accurately.
yazi-core/src · high confidence
Dual file-watcher architecture with virtual filesystem support
The file watcher now distinguishes between local and virtual filesystems, routing change notifications through separate backends. Local file changes are reported to the manager for immediate UI refresh, while virtual filesystem changes (such as remote or cached paths) are handled via a dedicated virtual reporter. A refresher component manages asynchronous directory loading and incremental updates, ensuring that file listings stay consistent across both local and virtual sources without blocking the main thread.
yazi-watcher/src · high confidence
Dual watcher with symlink resolution for local file changes
The local file watcher now uses a dual strategy: it attempts to use the system's recommended watcher first, but automatically falls back to a polling-based watcher if the primary one fails to initialize, preventing crashes on unsupported systems. Additionally, a new linked-path resolver tracks symbolic links and resolves them to their canonical targets, ensuring that file changes are correctly reported and processed even when files are accessed via symlinks.
yazi-watcher/src/local · high confidence
Help menu now functions as a command palette
The help interface has been refactored to support command-palette-style interaction. The new implementation in \yazi-fm/src/help\ introduces a dedicated \Bindings\ widget that renders key chords and their descriptions in a two-column list, and a \Help\ widget that manages the layout, including an input area for filtering and a divider. This structural change replaces the previous static help display with a dynamic, searchable interface.
yazi-fm/src/help · high confidence
Help menu now supports live filtering via an input component
The help menu has been updated to include a text input field that allows users to filter keybindings in real-time. As you type, the list of displayed bindings is dynamically narrowed down based on exact matches, case-insensitive prefixes, substring matches, and command descriptions, making it easier to find specific shortcuts without scrolling through the entire list.
yazi-core/src/help · high confidence
Input component refactored with history and guard mechanisms
The input module has been restructured to support input history and safer state management. A new history system tracks up to 20 recent entries per group, allowing users to recall previous inputs. Additionally, input guards have been introduced to manage access to the main and alternative input states, ensuring thread-safe interactions with the input component.
yazi-core/src/input · high confidence
Introduce new VFS engine architecture with capabilities and file attributes
The file-system engine has been restructured to support a pluggable Virtual File System (VFS) model. This change introduces a new \Engine\ trait that defines core file operations (such as \open\, \copy\_to\, \create\_dir\, and \trash\) and a \Capabilities\ struct that allows different VFS backends to declare which operations they support. It also adds an \Attrs\ struct for handling file metadata (timestamps, permissions) and a \Stat\ type for file status information, enabling the application to interact with diverse storage providers through a unified interface. Also in this area: 1 commit (0 fixes) modifying (repo-wide).
yazi-fs/src/engine, yazi-fs/src/stat · low confidence
Introduction of structured notification system with message levels
The notification subsystem has been refactored to support structured messages with distinct severity levels (Info, Warn, Error). This change introduces a new \MessageLevel\ enum that allows notifications to be styled and iconized differently based on their type, and updates the message calculation logic to account for border widths and icon sizes when determining display dimensions. Users will see notifications rendered with appropriate visual indicators corresponding to their severity.
yazi-core/src/notify · high confidence
New VFS configuration system with service-based architecture
The VFS configuration has been restructured to use a service-oriented model where connections are defined by scheme and domain pairs rather than flat paths. This introduces a new \vfs.toml\ configuration file and a \Service\ enum supporting SFTP, Mount, Hub, Scope, and View service kinds. Authorities are now organized by scheme, allowing multiple domains per scheme with catch-all support, and the configuration is exposed via a Lua API for dynamic management of VFS services.
yazi-config/src/vfs · high confidence
New event system with prioritized channels and Lua integration
The event system in yazi-shared has been replaced with a new architecture that introduces high-priority and normal-priority channels for event delivery, allowing critical events to preempt standard ones. This change adds a new \Action\ type that wraps commands with layer and source metadata, and introduces \ActionCow\ for efficient copy-on-write handling of event data. The system now supports Lua integration via \FromLua\/\IntoLua\ implementations for actions and action lists, enabling plugins to emit and receive events. A \Replier\ mechanism is added to support synchronous command execution with result return, and the event module exposes a global \NEED\_RENDER\ flag to coordinate UI updates.
yazi-shared/src/event · high confidence
New input actor implementation with vim-like editing modes
The input widget now uses a new actor-based architecture that supports Normal, Insert, and Replace modes, enabling vim-style editing behaviors. Users can now use commands like 'backward' and 'forward' with configurable 'gait' for word-aware navigation, perform 'kill' operations (delete to end of line, backward/forward word, etc.), and utilize 'yank' and 'paste' for clipboard operations. The input also supports 'undo' and 'redo' history, 'casefy' for changing case of selected text, 'complete' for path completion, and 'recall' for browsing input history.
yazi-widgets/src/input/actor · high confidence
New input parser options for text editing actions
The input parser module now includes dedicated option structs for backspace, backward/forward movement, case conversion, completion, deletion, text feeding, insertion, killing, and pasting. This introduces structured configuration for these actions, such as configurable gait for backward/forward navigation, casefy options for upper/lower transformation, and specific flags for insert/paste positioning, enabling more granular control over text input behavior.
yazi-widgets/src/input/parser · high confidence
New plugin system architecture with slim and standard Lua environments
The plugin subsystem has been restructured into a new \yazi-plugin\ crate that initializes two distinct Lua environments: a 'slim' preset for lightweight plugin execution and a 'standard' preset for the full application runtime. The standard environment now explicitly loads a suite of UI components (such as app, backdrop, current, dnd, header, preview, status, and tabs) and utilizes a generational garbage collector for improved performance, while the slim environment provides a reduced set of globals (ui, ya, fs, vf, rt, km, th) for isolated plugin contexts.
yazi-plugin/src · high confidence
New ratatui-based terminal backend
The yazi-tui crate now implements a new virtual terminal backend using \ratatui-core\ (previously \ratatui\), replacing the previous TUI implementation. This change introduces a new \RatermBackend\ and \Raterm\ struct that handle terminal drawing, cursor management, and event streaming via the \ratatui\ framework, enabling features like partial screen updates and improved terminal capability probing.
yazi-tui · high confidence
New shell argument escaping and splitting logic
The \yazi-shared/src/shell\ module now provides platform-specific functions to escape and split command-line arguments, replacing previous ad-hoc implementations. On Unix, arguments are single-quoted with proper handling of special characters like single quotes and backslashes, and the \split\ function supports an end-of-options (\--\) marker. On Windows, arguments are double-quoted, with specific escaping for backslashes, quotes, and environment variable expansion characters (e.g., \%\), and splitting uses the native \CommandLineToArgvW\ API. This ensures that file paths and command arguments containing spaces, Unicode, or special shell characters are passed to external commands correctly on both platforms.
yazi-shared/src/shell · high confidence
New unified rendering architecture with sync-optimized redraws
The application now uses a new rendering architecture that introduces a \SyncGuard\ to batch terminal updates, reducing flicker and improving performance during redraws. The \App\ struct manages a centralized event loop that dispatches events and triggers renders based on a \need\_render\ flag, with support for partial renders to update specific UI components like notifications and tasks without redrawing the entire screen. This change also integrates a new \ratatui-core\ backend for rendering and uses a \Dispatcher\ to handle event routing, replacing the previous rendering and event handling mechanisms.
yazi-fm/src/app · high confidence
New virtual terminal event source backend
The terminal event source has been replaced with a new virtual backend that handles input polling and parsing differently across platforms. On Unix, it now uses \rustix\ for polling (with a macOS-specific \select\ fallback due to \poll\ limitations on \/dev/tty\) and explicitly handles \SIGWINCH\ for terminal resizing. On Windows, it switches to \WaitForMultipleObjects\ for console input. The new implementation also includes logic to drain terminal responses on abnormal exit and ensures the event stream quits cleanly when it closes, improving stability during terminal shutdown.
yazi-term/src/source · high confidence
New yazi-fs crate for filesystem operations
The filesystem logic has been extracted into a dedicated \yazi-fs\ crate, introducing a new \Cwd\ abstraction that manages the current working directory via a thread-safe \ArcSwap\ and ensures the OS directory is synchronized with the application's virtual URL state. This change adds a \FsAuth\ trait to handle authentication caching and stamping for remote filesystems, a \Normalizer\ to apply Unicode NFC/NFD normalization to regex patterns used in filtering and searching, and a \FilesSorter\ that supports a new \SortFallback\ option to define secondary sorting behavior. The crate also includes a \Scanner\ for efficient directory traversal using \rustix\ on Unix-like systems, a \Splatter\ for shell command formatting, and a \FolderStage\ enum to track loading states.
yazi-fs/src · high confidence
New yazi-runner plugin execution engine
The yazi-runner crate introduces a new architecture for executing Lua plugins, replacing the previous synchronous model with an async, coroutine-based system. This change introduces dedicated runners for entry, fetcher, preloader, previewer, and provider plugins, allowing them to run concurrently without blocking the main application thread. It also adds a new Lua \require\ implementation that supports async module loading and nested runtime scopes, enabling plugins to perform asynchronous operations safely.
yazi-runner · high confidence
Refactored case-sensitivity detection into a modular, cross-platform subsystem
The case-sensitivity logic has been restructured into a dedicated \casefold\ submodule with platform-specific implementations for Linux, macOS, BSD, and Windows. This change ensures that file name resolution and case-insensitive matching now correctly account for the underlying file system's behavior on each operating system, improving reliability when navigating directories with mixed-case names or case-insensitive file systems.
yazi-fs/src/casefold · high confidence
Refactored file data structures and Lua bindings
The file module has been restructured to improve modularity and Lua integration. The core \File\ struct is now defined in \file.rs\ with dedicated modules for extra metadata (\file\_extra.rs\), covariance (\file\_cov.rs\), and signatures (\file\_sig.rs\). Lua bindings have been moved into this crate, introducing \FileRef\ for safe borrowing and an inventory system for extensible registration. This change simplifies the directory refresh flow and prepares the codebase for new VFS kinds. Also in this area: 1 commit (0 fixes) modifying (repo-wide).
yazi-fs/src/file · low confidence · unverified
Refactored pick component to use ratatui-core and yazi\_widgets
The \pick\ component's rendering logic has been refactored to utilize \ratatui-core\ and \yazi\_widgets\ instead of the previous \ratatui\ and \tui\ crates. This change updates the \List\ and \Pick\ widgets to use the new \ratatui\_core::widgets\ and \ratatui\_widgets\ APIs, ensuring consistent rendering behavior with the broader framework migration while maintaining the existing visual output for the pick list.
yazi-fm/src/pick · high confidence
Reimplemented file copying with platform-optimized strategies and progress reporting
The file copier has been rewritten to use native, high-performance copy mechanisms on each supported platform: Linux now prefers copy\_file\_range and sendfile with automatic fallback to buffered reads; macOS leverages fclonefileat for fast cloning and fcopyfile for extended attributes, security settings, and transparent compression (decmpfs) preservation; Windows uses CopyFileExW with callback-based progress tracking. All implementations now report copy progress to the UI, handle cancellation checks during the operation, and preserve file metadata (timestamps, permissions, extended attributes) with robust error recovery and retry logic where applicable.
yazi-fs/src/copier · high confidence
Reimplemented file removal with platform-specific backends and progress tracking
The file removal logic has been completely rewritten to use dedicated platform-specific implementations (using \rustix\ on Unix and \windows-sys\ on Windows) instead of the previous standard library approach. This new architecture introduces a structured removal process that tracks progress via a \Delta\ struct (total, succeeded, failed, processed counts) and provides real-time updates through a channel, allowing users to monitor the status of bulk deletions. The change also adds robust error handling for edge cases like sharing violations on Windows and symlink resolution on Unix, ensuring more reliable removal of complex directory trees.
yazi-fs/src/remover · high confidence
Removal of core image adapter and event system modules
The \src/core\ module has removed the \adapter\ (specifically the Kitty image display implementation) and \event\ modules, along with their re-exports in \mod.rs\. This eliminates the previous mechanism for rendering images in the Kitty terminal emulator and the global static event bus used for UI communication, indicating a significant architectural shift in how the application handles image previews and internal event dispatching.
src/core · high confidence
Restructure app module with dedicated plugin and quit option types
The app module has been reorganized to separate core concerns into distinct files. A new \plugin.rs\ introduces structured \PluginOpt\ and \PluginMode\ types, enabling more granular control over plugin execution modes (Auto, Sync, Async) and methods (Entry, Peek, Seek), while normalizing plugin names by stripping \.main\ suffixes for consistent internal identification. Additionally, a new \quit.rs\ defines a \QuitOpt\ struct that allows users to specify an exit code and control whether the current working directory file is saved upon quitting, exposing these options via Lua bindings and action deserialization.
yazi-core/src/app · high confidence
Tabs now maintain independent navigation history and selection state
The tab component has been restructured to manage its own backstack, file history, and selection state. Users can now navigate backward and forward within each tab independently using the new backstack, while the history system preserves the state of previously visited folders so that returning to a folder restores its previous cursor and scroll position. Additionally, file selections are now tracked per-tab, ensuring that visual selections do not interfere with other tabs.
yazi-core/src/tab · high confidence
Tasks UI rendered via dedicated ratatui widgets
The tasks area now uses dedicated \ratatui\ widget implementations (\List\, \Progress\, \Tasks\) to render the task list and progress indicators. This change introduces a structured rendering pipeline where the \Tasks\ widget manages layout and styling (using \ratatui\_widgets\ for blocks and borders), while \List\ and \Progress\ delegate to a central \Renderer\ for their specific content, ensuring consistent visual presentation of task states.
yazi-fm/src/tasks · high confidence
Unified path handling with OS and Unix backends
The path module has been refactored to support a dual-backend architecture, allowing paths to be represented natively as either OS-specific (\std::path::Path\) or Unix-style (\typed\_path::UnixPath\). This change introduces new types like \PathDyn\, \PathBufDyn\, and \PathCow\ to manage these variants, along with traits like \PathLike\ and \DynPath\ to provide a unified interface for path operations. Users can now work with paths that preserve their original encoding and structure, enabling better support for cross-platform scenarios and Unix-specific path semantics within the application.
yazi-shared/src/path · high confidence
Unified path normalization, expansion, and sanitization
The \yazi-fs/src/path\ module has been restructured into dedicated components (\clean\, \expand\, \normalize\, \relative\, \safename\) to provide a consistent and robust path handling layer. Users benefit from improved URL and path cleaning that correctly resolves \.\ and \..\ segments across various VFS schemes (including SFTP and Hub), reliable environment variable expansion (e.g., \$HOME\, \%USERPROFILE%\) in paths, and stricter filename sanitization that handles invalid characters, reserved names (like \CON\ on Windows), and trailing whitespace/dots. This ensures that relative path calculations and absolute path conversions are more predictable and secure across different operating systems and remote file providers.
yazi-fs/src/path · high confidence
Windows trash backend reimplemented using Win32 API
The Windows trash backend has been completely rewritten to use the Win32 Shell API (via \IShellItem\ and \IFileOperation\) instead of the previous implementation. This change makes the trash operations path-agnostic, improves reliability by correctly handling nested items and original file locations, and ensures that restoring trashed items works recursively for directories. Users on Windows will now experience more robust trash and restore behavior that aligns with the system's native Recycle Bin.
yazi-fs/src/trash/windows · high confidence
Dependencies
Workspace dependency and version updates
The project's Cargo workspace has been updated to version 4, and internal crate versions have been bumped to 26.9.1. Several external dependencies were updated, including \clap\_complete\ to 4.6.11, \clap\_complete\_fig\ to 4.5.2, \clap\_complete\_nushell\ to 4.6.2, \tracing-appender\ to 0.2.5, \tracing-subscriber\ to 0.3.23, \tikv-jemallocator\ to 0.7.0, \fdlimit\ to 0.3.0, \signal-hook\ to 0.4.5, \notify\ to 8.2.0, \deadpool\ to 0.13.1, \russh\ (workspace), \typed-path\ (workspace), \memchr\ to 2.8.3, \vergen-gitcl\ to 10.0.3, \hyper\ to 1.12.0, \hyper-util\ to 0.1.21, \http-body-util\ to 0.1.5, \windows\ to 0.62.2, \windows-sys\ to 0.61.2, \uds\_windows\ to 1.2.1, \trash\ to 5.2.9, \clipboard-win\ to 5.4.1, \moxcms\ to 0.9.1, \palette\ to 0.7.7, \quantette\ to 0.6.0, \ds\_parser\ to 0.4.0, \async-priority-channel\ to 0.2.0, and \syn\ to 3.0.7.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 44 → 41 (-3.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 91 → 88 (-2.6)
- Architecture 83 → 83 (+0.4)
- Maturity 65 → 64 (-0.5)
- Readiness 80 → 80 (+0.1)
- Security 69 → 55 (-14.1)
- Domain Modelling 100 → 100 (+0.0)
- Event-Driven 10 → 10 (+0.0)
- Performance 100 → 100 (+0.0)
Resolved (59)
- Duplicated block (10 lines × 2) (yazi-fs/src/splatter.rs)
- Duplicated block (10 lines × 3) (yazi-scheduler/src/file/progress.rs)
- Duplicated block (10 lines × 4) (yazi-scheduler/src/file/progress.rs)
- Duplicated block (13 lines × 2) (yazi-parser/src/help/toggle.rs)
- Duplicated block (13 lines × 2) (yazi-scheduler/src/file/out.rs)
- Duplicated block (13 lines × 2) (yazi-shared/src/auth/display.rs)
- Duplicated block (14 lines × 2) (yazi-fs/src/splatter.rs)
- Duplicated block (15 lines × 2) (yazi-core/src/highlighter.rs)
- Duplicated block (15 lines × 2) (yazi-parser/src/cmp/show.rs)
- Duplicated block (15 lines × 2) (yazi-parser/src/help/close.rs)
- Duplicated block (15 lines × 3) (yazi-parser/src/cmp/close.rs)
- Duplicated block (5 lines × 2) (yazi-adapter/src/drivers/drivers.rs)
- Duplicated block (5 lines × 2) (yazi-adapter/src/drivers/kgp.rs)
- Duplicated block (5 lines × 2) (yazi-binding/src/http/response.rs)
- Duplicated block (5 lines × 2) (yazi-binding/src/process/child.rs)
- Duplicated block (5 lines × 2) (yazi-config/src/keymap/chord.rs)
- Duplicated block (5 lines × 3) (yazi-dds/src/ember/delete.rs)
- Duplicated block (5 lines × 3) (yazi-term/src/parser/csi.rs)
- Duplicated block (5 lines × 4) (yazi-adapter/src/drivers/chafa.rs)
- Duplicated block (5–7 lines × 2) (yazi-tty/src/sequence/dnd.rs)
- …and 39 more
New (183)
- Duplicated block (10 lines × 2) (yazi-scheduler/src/file/file.rs)
- Duplicated block (10 lines × 3) (yazi-scheduler/src/plugin/progress.rs)
- Duplicated block (10 lines × 4) (yazi-scheduler/src/file/progress.rs)
- Duplicated block (12–13 lines × 2) (yazi-actor/src/lives/yanked.rs)
- Duplicated block (13 lines × 2) (yazi-shared/src/auth/display.rs)
- Duplicated block (13 lines × 3) (yazi-parser/src/app/focus.rs)
- Duplicated block (13 lines × 3) (yazi-scheduler/src/fetch/out.rs)
- Duplicated block (13 lines × 7) (yazi-parser/src/cmp/close.rs)
- Duplicated block (5 lines × 2) (yazi-fs/src/remover/removal.rs)
- Duplicated block (5 lines × 2) (yazi-plugin/src/slim.rs)
- Duplicated block (5 lines × 2) (yazi-sftp/src/fs/file.rs)
- Duplicated block (5 lines × 2) (yazi-term/src/event/dnd.rs)
- Duplicated block (5 lines × 3) (yazi-dds/src/ember/delete.rs)
- Duplicated block (5 lines × 3) (yazi-term/src/parser/csi.rs)
- Duplicated block (5–7 lines × 2) (yazi-tty/src/sequence/dnd.rs)
- Duplicated block (6 lines × 2) (yazi-scheduler/src/file/file.rs)
- Duplicated block (6 lines × 2) (yazi-shared/src/data/de.rs)
- Duplicated block (6 lines × 2) (yazi-shared/src/data/de.rs)
- Duplicated block (6 lines × 4) (yazi-adapter/src/drivers/chafa.rs)
- Duplicated block (7 lines × 2) (yazi-actor/src/mgr/bulk_create.rs)
- …and 163 more
Changes since last survey
- 13 commits — 10 feature/other, 3 fixes
By area
- (root) — 2 commits
- yazi-actor/src — 2 commits
- yazi-term/src — 2 commits
- yazi-config/src — 1 commit
- yazi-core/src — 1 commit
- yazi-dds/src — 1 commit
- yazi-fs/src — 1 commit
- yazi-parser/src — 1 commit
- yazi-plugin/preset — 1 commit
- yazi-shared/src — 1 commit
Notable commits
- fix: fix: allow for omitted fields in the DnD protocol (#4467)
- fix: fix: invalidate affected directories after file operations
- fix: fix: restore directory cursors after sorting (#4468)
- change: ci: include MSI installer in WinGet release workflow
- change: feat: Windows MSI installers for stable and nightly releases (#4473)
- change: feat: autocomplete VFS URLs and package IDs (#4464)
- change: feat: compress files (#4477)
- change: feat: expose mouse modifiers to Lua (#4495)
- change: feat: make selected and yanked states indexable (#4494)
- change: feat: new create and bulk-create DDS events for file creations (#4484)
- change: feat: new focus DDS event for terminal focus changes (#4474)
- change: feat: random read/write for virtual file systems (#4451)
- change: feat: rework filesystem APIs (#4483)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
sxyazi/yazi was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit d5e4beb6b5212c28d1026d8e7d4ae985dcf174cb — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.