Crates for dealing with files and filesystems
Cross-platform filesystem notification library
managing temporary files and directories
tiny low-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows, macOS and Redox by leveraging the mechanisms…
equivalent of Unix command "which". Locate installed executable in cross platforms.
UTF-8 paths
A drop-in replacement for std::fs with more helpful error messages
Support for matching file paths against Unix shell style patterns
Shell-like expansions in strings
Small crate to infer file type based on magic number signatures
Idiomatic wrapper for inotify
Platform-agnostic accessors of timestamps in File metadata
No libc, pure Rust cross-platform file locks. Original fs2, now supports async and replace libc by rustix.
fd is a simple, fast and user-friendly alternative to find
Apache OpenDAL™: One Layer, All Storage
path or URL using the program configured on the system
a cross-platform library for opening OS pipes
Rust Custom Derive Macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev
Filesystem walk performed in parallel with streamed and sorted results
Normalize Windows paths to the most compatible format, avoiding UNC where possible
tiny low-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows, macOS and Redox by leveraging the mechanisms defined by the XDG base/user…
Fuzzy Finder in rust!
moving files and folders to the Recycle Bin
tiny mid-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows and macOS by leveraging the mechanisms defined…
A safe, reliable implementation of remove_dir_all for Windows
diffing paths to obtain relative paths
Portable, relative paths for Rust
Expanding std::fs and std::io. Recursively copy folders with information about process and much more.
Opinionated and portable globs that can be matched against paths and directory trees
Determines the MIME type of a file by traversing a filetype tree
unix extended filesystem attributes
Conversion to/from a file path from/to slash path
execute commands in response to file modifications
Read/write Compound File Binary (structured storage) files
gitoxide project dealing .gitattributes files
typed variants of Path and PathBuf for Unix and Windows
Cross-platform file locks and file duplication
A more intuitive version of du
Glob-matched recursive file system walking
determining the file format of a given file or stream
Rust data types for common types used within the Conda ecosystem
A virtual filesystem for Rust
Log rotation for files
copy-on-write mechanism on supported file systems
Filesystem in Userspace (FUSE) for Rust
Ensure that files can only be read or written by trusted users
A smarter cd command for your terminal
Reading and writing at an offset
A pure-Rust library to work with GPT partition tables
GTK frontend of Czkawka
Flexible Mandatory Access Control for Linux
C-friendly API to make path resolution safer on Linux
temporary directory with cleanup
Atomic file-writes
A high-performance glob matching crate for Rust
your file collections using Rust!
A virtio-fs vhost-user device daemon
Manipulate file system access control lists (ACL) on macOS, Linux, and FreeBSD
Chris Titus Tech's Linux Toolbox - Linutil is a distro-agnostic toolbox designed to simplify everyday Linux tasks
reading, creating, and modification of SquashFS file systems
Read the ELF dependency tree
fast, encrypted, deduplicated backups that powers rustic-rs
Find files with SQL-like queries
NFS Server implementation
Copy directories recursively with flexible options
LRU eviction of Docker images
Get system information in Rust. For now it supports Linux, Mac OS X, illumos, Solaris, FreeBSD, OpenBSD, and Windows
More reliable path manipulation
Path canonicalization that works with non-existing paths
cleanname or path.Clean
High level bindings for the libmagic C library
libmagic
A virtual file system for rust-analyzer
FAT filesystem library
Do two directories have different contents?
Yazi file manager
Extensions to the Rust standard library
A CLI for Git worktree management, designed for parallel AI agent workflows
A procmacro attribute to run your test in an isolated environment
No-std compatible Rust library for reading ext2/ext4 filesystems
notify event debouncer optimized for ease of use
Find files that are not recorded in the Gentoo package database
A fast Git hook manager written in Rust, designed as a drop-in alternative to pre-commit, reimagined
Semi-persistent, scoped test directories
Reliable, flexible, and fast command-line tool for Amazon S3
A fork of github.com/zesterer/ariadne
Auto launch any application or executable at startup. Supports Windows, macOS, and Linux.
Locked files that can be used like normal File
File System and Path utility functions
Convenient file and directory operations with progress reporting built on top of std::fs
WebContainer implementation for wapm.io
Navigation utility for AMD SEV-SNP guest environment
ISO-9660 filesystem
More ergonomic wrappers around RawFd and RawHandle
A programming language for distributed systems
Trait per function for system related functionality
handle git references
small, but highly customizable, file explorer widget for ratatui
Aube — a fast Node.js package manager
Pure Rust library to read and modify GUID partition tables
(partial) clone of the Unix cp command, with more user-friendly feedback and some performance optimisations. See the README for features and limitations.
cp
A beautiful and feature-rich directory tree visualization tool with colors, emojis, and comprehensive ignore file support
ArceOS filesystem module
Generate a filesystem tree from a macro or a YAML tree
Fuse(filesystem in userspace) servers and virtio-fs devices
working with FAT filesystems (FAT12/FAT16/FAT32/exFAT)
Is there an executable file at the given path?
TUI Program for Custom Proton Download and installation written in rust
Stratis daemon
Given a mimetype, suggest a file extension
find,filter and delete duplicate files
Reads security transaction statements (as pdf) from neo-broker Trade Republic and renames them as transactiondate_ordertype_name
Path handling library for Nushell
give information on mounted filesystems
Fast, Parallelized touch(1) file utility
managing temporary files and directories, with UTF-8 paths
Standalone MCP filesystem tools server — view, edit, shell, workdir
Tester for Solid State Disks, Non-Volatile Memory Storage, Hard Disks, USB Sticks, SD-Cards, etc
A fast, keyboard-focused terminal file manager (TUI). Highly configurable and lightweight.
A replacement for the 'rm' command with a trash feature for safer file deletion
Write files atomically to a file system
Librarian runs pre-configured commands against a group of files that match a set of filters
FUSE user-space library async version implementation
macro to generate tests from files in a directory
A tempfile implementation with a global registry to assure cleanup
FUSE Filesystem Library
A terminal dashboard for the Zettabyte File System, in the spirit of htop
A Zip archive reader and writer
An opinionated, fast music organiser
Fork of glob. Support for matching file paths against Unix shell style patterns.
Command-line interface for mounting OmnIFS virtual filesystems
Secure path handling for untrusted input. Prevents directory traversal, symlink escapes, and 19+ real-world CVE attack patterns.
Parses and models composer.json files
files as locks
AWS SDK for Amazon FSx
An incremental file deduplicator which minimizes amount of data read. Replaces duplicate files with identical content with hardlinks.
CLI frontend of Czkawka
Basic Opinionated Activity Tracker, a command line interface inspired by bartib
Terminal file manager inspired by ranger
A Microsoft symsrv symbol server consumer (downloader + cache)
A TUI tool to connect to AWS EC2 instances via SSM Session Manager
Detect IO circles in your CLI apps arguments
Save filesystem and asset scopes and restore them when the app is reopened
A fast, multi-threaded filesystem search tool with regex/glob support and extremely pretty colours!
associating MIME types to file extensions
File type detector
Rust Macro which embeds files into your executable. A fork of rust-embed with a focus on usage on web servers.
rust-embed
A self-contained, keyboard-driven file-browser widget for Ratatui
A fast minimalist directory tree viewer, written in Rust
FAT filesystem library (Starry-OS fork with no_std and embedded improvements)
Rust port of the official MCP filesystem server - fast, safe, protocol-compatible file operations
Highly parallelized, blazing fast directory tree analyzer
A modern git based age-encrypted secrets manager for teams
file accessibility checks
A fast, rule-based CLI tool for organizing your files
Parallel, atomic, and safe file/directory copying for Rust
Determines file content types using AI
loader::Handle for rust-analyzer
loader::Handle
A program for backup & restoration of btrfs subvolumes
Eww notification daemon in rust
A command-line tool for constructing, manipulating, and introspecting virtual file systems in Rust, based on OpenMW's VFS implementation
Instant CLI - command-line utilities
NFSv3 Server implementation
The user's home directory as per XDG Specification
Sequential, distributed, POSIX-style job queue processing
A lightweight ext4 file system
Fast file comparison tool - efficiently compares metadata across large filesets
Rename files to randomly generated strings
A small library abstracting over bytes owning types in an extensible way
A colorfull diff tool based on the patience diff algorithm
Rust bindings to WinFSP
CLI tool to synchronise a local folder with a Bunny CDN Storage Zone
Resolution primitives for Yarn PnP
pxs (Parallel X-Sync) - Integrity-first Rust sync/clone for large mutable datasets
Command-line interface for Fallout save parsing
On-disk field indexes (bool, number, string, string_filter, geopoint) for search engines
Operator CLI for aegis-boot — flash, add, list, verify
rspack fs
disk usage for IBM Storage Scale file systems
Macros for statically including assets in release mode, but dynamically loading them in debug mode. This is primarily intended for games, allowing you to both avoid file IO in release…
using pidfiles as resource locks
Anaconda Anonymous Usage token generation for the conda ecosystem
Developer desktop runner harness for Greentic packs
'at' functions for various platforms
bit rot checker
A flexible and idiomatic Fuse implementation for Rust
Jujutsu - an experimental version control system
A better rm command for your terminal
GitHub’s collection of gitignores, embedded, automatically updated
Very simple in configuring, but powerful backup tool
Watch command inputs and rerun commands when they change
Database-like Asset management on top of ECS storage
Extend tokio fs to be compatible with native and wasm
filesystem
Interactive disk usage treemap visualizer — scan directories and explore space usage with a native GUI or HTML export
An extremely fast and efficient duplicate file finder
Fast rm provides an alternative to rm that focuses on maximizing performance
package allows you to create a temporary directory for testing purposes. You can use it to perform tests related to file operations. After the tests are finished, the temporary directory will be deleted automatically
A lighter way to list files and directories
Trait and service definition of periodic hot reloader and notifier for config-file, KVS, etc
raising file descriptors limit for OSX and Linux
Create file paths relative to your executable for truly portable applications
lean, minimal cost abstraction and extensible Read / Write trait to multiple storage on multiple poll-based / completion-based async runtime
A multi-language TODO comment extractor for source code files
Command line interface and library for interacting with the File Hierarchy for the Verification of OS Artifacts (VOA)
System-wide Python package discovery, validation, vulnerability scanning, and allow-listing
Rust access to Python file-like objects
A shell-script-centric task scheduler; uses exit codes to determine control flow
A customizable workspace manager for tmux
TUI app for managing multiple AI bot sessions in a terminal
Cross-platform hidden file library and utility
Calculates the CRC-32 of a file and checks it against the filename
Pull in every source file in a directory as a module
Blazingly fast filesystem traverser and mass file hasher with diff support, powered by jwalk and xxh3!
Page cache diagnostics and control tool for Linux and macOS
gitoxide project dealing with directory walks
Rename files and directories to clean, URL and shell-friendly slugs — or pipe arbitrary text through for slugification
Keep track of all the git repositories on your machine
Similar to the Path structure provided by python's pathlib, it provides various async/sync versions of file manipulation methods in addition to some of the std::Path built-in methods
A TUI tool to find and delete heavy cache/dependency directories
Fast, parallel fuzzy file search library for VT Code
convenient API for File System access
Crossplatform Path - Rust library
Core library for the grit Git implementation
MBR Partition Management in Rust
Pure-Rust ext4 filesystem formatter and reader for container images
Capability-based primitives
Operating System tools designed for BlockProject3D
tui file manager with vim-like key mapping
A CLI tool to elegantly manage your shell's PATH variable
Create btrfs filesystems
I/O layer for OxiMedia
ArceOS user program library for C apps
S3 CLI client for S3-compatible object storage
temporary file with cleanup
Rename files based on their metadata with multi-language OCR, HEIC support, and video frame extraction
Adaptive file and directory IO for Rust — fast, hardware-aware, multi-strategy
Filesystem based on Google Drive
AI agent orchestrator - drives a Supervisor–Executor workflow for autonomous software development
A modern ls replacement with file notes, emoji icons, and git integration
interacting with the CAT-DEV hardware units distributed by Nintendo (i.e. a type of Wii-U DevKits).
Concatenates a directory full of files into a single prompt for use with LLMs
Sync files between two paths. Auto-detects drives by UUID/label.
The RAFS filesystem format for Nydus Image Service
Runner for jql - the JSON Query Language tool
Human-readable disk usage with colorized bars, physical disk grouping, and system volume annotations
A streamable, readable, writeable, randomly accessible file format
reading and writing Macos resource forks
Cross-platform configuration path discovery following XDG and platform conventions
Reference CLI for deterministic claim verification with triad
A fast CLI tool for recursively cleaning development build directories (Rust, Node.js, Python, Go, Java/Kotlin, C/C++, Swift, .NET) to reclaim disk space
File watcher and command executor
Reclaim disk space from build/cache directories across cargo and npm projects, in one pass
FUSE-based network filesystem for Tocco
An enum with a variant for each file type
A minimal content-addressed file store using BLAKE3. (CLI)
CLI: Moving File and Folder in Download Directory at Current Directory
A pure-Rust library for reading and writing raster GIS formats
HTTP server for Mangle query evaluation
j4rs stands for 'Java for Rust' and allows effortless calls to Java code, from Rust
A cargo registry allowing for quick publishing of crates when using crates.io is just not desired
Cross-platform Rust library for direct FAT32 partition manipulation with ESP support
Three‑pane terminal file viewer (TUI) with preview and Lua configuration
Command-line interface for HashJunkie multi-algorithm file hashing
A modern cp/mv/scp for humans and agents — inline BLAKE3 verify, crash-safe resume, one CLI for local and SSH
Stream and merge OCI image layers into squashfs, tar, or directory output
Rust framework for file recognition, aiming for high extensibility and customization
Wrappers for standard library functions and types to produce more elaborate error messages
Virtual file systems KIT
Scanner for various IoCs
CLI for reading and composing gibblox block pipelines
Write data on FS in a performance way
A tiny CLI tool that tries to gather project specific meta-data in different ways, to store them into key=value pairs in a file for later use by other tools. See --list for the keys set by this tool
A convenient splitting and concatenating filesystem
A convenient file sorting utility
Like npkill, but written in Rust
parses an $MFT file to bodyfile (stdout)
iced widget for file tree powered by swdir, supporting selection, lazy loading and filtering
Initialize standardized, reproducible project directories
NixOS deployment orchestration for consortium
out-of-the-box logging library for Rust
help interacting with cache directories and CACHEDIR.TAG files
Storage interfaces and abstractions for htsget-rs
Recreate directory and file structure from tree command output
tree
a custom file system
A blazing fast parallel copy tool for Unix
A cross-platform Rust library for resolving XDG and platform-specific directories with proper fallbacks
Filesystem path Trie with an API focused on filesystem operations
Reliable workspace-relative path resolution for Rust projects. Automatically finds your workspace root and provides consistent file path handling regardless of execution context. Features memory-safe secret management…
Disk usage visualizer for both AI and humans
Sync a directory's modified time to its newest contained item
Protobuf to Rust CLI tool
A cross-platform library for simple advisory file locking
a server using actix-web, markdown-ppp, and handlebars
Downloader with a pure http implementation support breakpoint continuations
Config for wireman
Type-safe memory-mapped file library with lock-free concurrent writes to non-overlapping ranges
Tailwind Merge and Variants
Mount the directory to which the ssh connection is made
Flexible thought management using filesystem mounts for git repositories
File hierarchy traversal functions (FTS)
loading Java classes
Cross-platform rust ext4
A minimal, safe, synchronous OverlayFS implementation using FUSE
File-system walking crate
A fast and space-efficient version control system for portable file backups
Terminal UI for navigating OpenAPI specs
Calculate disk space used by a folder
High-level wrapper for libgphoto2
safely removing files and directories; moving them to trash
A POSIX sh-compatible shell written in Rust
PAI-Kernel governance sidecar binary · runs daemon · policy · storage as integrated axum server with CLI for verify · export · version
Faithful Rust port of FreeBSD find(1)
Multipart support for ntex web framework
Pure Rust reader for Expert Witness Format (E01/EWF) forensic disk images
Extension traits for Dir, File, etc
Dir
File
Zero-config changelog generator with monorepo support
WebNative filesystem core implementation
Deduplicates files into content-addressed chunks with selectable hash algorithms and restores them via a persistent cache
A minimal, synchronous, in-memory virtual filesystem for no_std and wasm32-unknown-unknown
Put your app's data in the right place on every platform. Community-maintained project.
BIOS boot sector for the bootloader crate
bootloader
Core Heimdall sandbox runtime orchestration and execution types
Container runtime trait and Docker implementation for biov
Compact, mmap‑friendly on‑disk format for RDF 5‑tuples
A CLI tool to operate files or directories in 2 steps
Prometheus exporter for FreeBSD NFS stats
Read MFT and USN journal
Seccomp-unotify access tracer and namespace-based sandboxing library
syncing directories with change detection
Upload files to MinIO (S3-compatible) storage
A pre-submit for file changes
A smart, adaptive ls replacement with modern features
managing macOS Time Machine exclusions for developer's workspaces
A lightweight, user-friendly disk imaging tool
Cross platform glob matching with relative path components, against list of candidate paths determined by recursive iteration from a root directory
A fast, expressive, and language-aware file search tool
Pasta Lua - Lua integration for Pasta DSL
Create bootable ISO images with FAT32 and UEFI (El Torito) support in Rust
A client library for Warg component registries
A dotfiles manager as dear as a daughter
The local-files MCP server. Pure Rust. Exposes CSVs, Parquet, Excel, DOCX, PDF, and HTML on the user's machine to any MCP-aware LLM client (Claude Desktop, Cursor, Zed, …).
A lightweight shared filesystem tool
A super fast file-manager written in rust
Speeds up programs writing lots of files on Windows
A fast, intelligent directory navigation tool with frequency tracking
accessing virtual machine disk images
Herramienta CLI para organizar automáticamente archivos por extensión con Feature-Based Architecture
Comprehensive utility library for file operations, networking, data manipulation, JSON/YAML processing, and more
System-level helper functions for the dirs and directories crates
Write disk images to physical drive or vice versa
CLI for interfacing with the ringboard server
Duplicate filename counter - a program to count the number occurances of duplicate filenames within a directory structure
A single-command backup helper for Linux and POSIX systems
intercepting disk requests
🚚 Manipulate file names and locations
managed directory system for project-scoped caches with optional eviction policies
zfs sync tool, cli
A linter/formatter wrapper for jj fix
EmbrFS: FUSE filesystem backed by holographic engrams
Read and write ID3 tags in a machine-readable way
A CLI tool for organizing large media libraries into a canonical archive
Automatically deleted async I/O temporary files
Fast hard-linking tool - efficiently creates hard links for large filesets (inspired by pcp/dsync)
Fast and robust atproto CAR file processing
Yazi command-line interface
Check if a path is ignored
signing and verifying files and directories
show aging of directories
terminal mind mapper
A Git implementation in Rust
∞-way read-write git mirroring tool
IPFS node implementation
CernVM-FS client implementation in Rust
safe library for unix CLI tools and Systems programming. IOCore provides the [iocore::Path] abstraction of file-system paths designed to replace most [std::path] and [std::fs]…
iocore::Path
std::path
std::fs
generate XML files compatible with GrandPerspective
Gets the path of the currently executing process or dynamic library
A generic POSIX file system test suite
A collection of several xdg-desktop-portal implementations to serve more lightweight wayland compositors like Hyprland
.editorconfig parser
Command line interpreter with builtin, Unix-like commands, and WSL symbolic link support
A Prometheus exporter for Restic repositories, utilising Rustic
A replacement for the 'ls' command written in Rust
Little language inspired by Rust that compiles to Go
fren - file renamer that understands dates (library)
Manage multiple MoonBit installations
Interactive file picker
Homebrew-style wrapper for Nix using flake.nix
A plugin for Nushell that colorizes paths using LS_COLORS
Laravel Security Audit CLI - scans Laravel applications for security issues, insecure patterns, and risky configuration
Dead simple file data manipulation
Embeddable virtual machine runtime for secure, isolated code execution
A HTTP(S) syncing tool with lower overhead, for OSS mirrors
Security static analyzer for Rust. Analyzes MIR to detect vulnerabilities. (Requires nightly)
A proc-macro library for to create rust structs from file system entries and include content as a reference to a byte array
Embeddable NFSv4.1 server library
convenient way to create a tree of files
Determines the MIME type of a file using the Apache Tika mime database
copying photos from SD cards
High-performance file synchronization with intelligent concurrent processing
Rust data types for conda lock
A CLI tool for analyzing code statistics across different programming languages
maintain cross-references in your code
A fast duplicate file finder with glob/regex filtering, JSON export, and cross-platform delete scripts
No-std compatible Rust library for ext2/ext3/ext4 filesystems
You've subscribed to PATH FACTS: Tidy filesystem information to help debug unexpected errors
A flexible and convenient high-level mmap for zero-copy file I/O
A dotfiles manager
Configuration sources (file, env, memory) for cfgmatic framework
A higher-level FUSE filesystem library with multi-threading and inode->path translation
Mount remote SSH directories via SMB2-over-SFTP. No FUSE, no Docker, no sudo.
A client library for cooklang-sync
A system-level daemon that keeps AI coding sessions intact when your projects move
Extremely simple program for using template files
Android file system API for Tauri
Cross-platform command line tool for moving files to the trash
Boot-entry discovery from ISO installation media (Arch, Debian/Ubuntu, Fedora/RHEL, Alpine, NixOS, Mint)
Capability token system for Astrid secure agent runtime
Ziglang Version Manager and Project Starter
A flexible rule-based file and folder comparison tool and crate including nice html reporting. Compares CSVs, JSON, text files, pdf-texts and images.
rsync-style high-performance file synchronization over QUIC and Spargio
Smart Tree - An intelligent, AI-friendly directory visualization tool
VirtIO device implementations for ArcBox
Pure Rust parser for Windows Volume Shadow Copy (VSS) snapshots. Read-only access to VSS stores from forensic disk images without Windows APIs.
notify mini debouncer for events
local package manager for npm (JS/TS)
Create GEMDOS (Atari TOS) filesystem disk images
Fast cp provides an alternative to cp that focuses on maximizing performance
that allows you to copy files or flash block devices safely
String-friendly path type
C ABI for sandlock process sandbox
Partition table support for MBR, GPT, and Hybrid MBR
Index-powered file search for macOS. Queries Spotlight instead of walking the filesystem.
Speedily search and merge log messages by datetime. DateTime filters may be passed to narrow the search. s4 aims to be very fast.
release management CLI
Remove UTF-8 BOM from files
providing comprehensive utilities for file operations with both sync/async support. Includes operations for copy, delete, move, read and write files. Simplifies file handling in Rust…
Rust bindings for MaaFramework
Virtual filesystem for MCP code generation and organization
FUSE implementation of FreeBSD's UFSv2
A daemon for monitoring and reacting to the status of NFS mounts
A CLI for building, inspecting, extracting, and verifying MBR-backed disk images
A safe fork of the path-clean crate
path-clean
A light-weight Write Ahead Log (WAL) solution with garbage collection
rsync with cars!
High-performance directory indexer with content-aware diffing. Walks trees in parallel, stores metadata in SQLite, compares against a previous snapshot.
Get platform-specific config, data, and cache directories. Supports XDG-style on macOS. No dependencies.
A state-of-the-art file system analyzer with TUI
An API tools library for Rust
A copy-on-write directory library for Rust with fast reflink cloning
Safe Rust bindings for libarchive v3.8.1, providing cross-platform archive reading and writing capabilities
Sandboxed file system for the agent (Csv, Docx, Pdf, Md, Json, Jsonl, Html, Txt)
Welcome! Please see https://github.com/alexevanczuk/packs for more information!
My utils crate
A fully automated OpenAPI engine for Axum with zero-config route and schema discovery
A FUSE (Filesystem in Userspace) library for Rust
Dockerfile parsing and buildah-based container image building
DiskANN is a fast approximate nearest neighbor search library for high dimensional data
A Rust/C++ interoperability tool
deno permissions implementation
Read-only FUSE server implementing XFS
A terminal based task and TODO management software
easy-to-deploy NFSv3 server
A fast CLI tool to open files and directories in your default browser
create and edit single-file Rust scripts
Your Downloads folder cleans itself — safely, predictably, and reversibly
File fingerprinting engine and CLI for zccache
Move files to system trash — safe alternative to rm. Works with Claude Code deny policies.
CLI tool to concatenate file contents from directories, respecting Git context
Omnipotent dev tool
Recursively find markdown files and list them along with table of contents index
A CLI tool that combines contents of files with specific extensions from a directory
TUI for configuring Karabiner-Elements right_command key bindings
Find and interactively repair broken symlinks with fuzzy matching
CLI-based certificate store. Inspired by Password Store.
A smarter cd command with frecency and fallback search
generate STatic site from Index Listing of directory
A terminal-based automated file organizer inspired by Hazel
A log/backup rotation tool
A fast CLI tool to clean, normalize, and safely rename files in bulk
— in-memory code intelligence MCP server for Claude Code, Codex, and Gemini CLI
CLI for multi-component deployment and development workflow automation
Stack-based file management for the terminal
CLI frontend for fren - a fast, powerful command-line batch file renaming tool
A blazingly fast, terminal-based system cleaner written in Rust
Incremental, cross-platform and multithreaded backup tool written in Rust
xv6 for RISC-V in Rust
effective tool to batch clean all crate artifacts that haven't been used for a while
FUSE-based virtual filesystem with Antares overlay for monorepo builds
Linux fanotify FID (File Identifier) mode event parser and file handle utilities
humans and machines deal with the OSH directory standard: https://github.com/hoijui/osh-dir-std
Virtual device emulation for libkrun
path bookmarks for your shell
File-system router with trie-based matching for the Rex framework
fp (FilterPath) is the filter equivalent for the Unix test util
concatenate all code and text files in a github repo for LLM inference contexts
A better pwd
Standalone vector data I/O — read and write fvec, ivec, mvec, dvec, bvec, svec, npy, parquet, and slab formats
Shell-style filename generation aka globbing
See what's heavy — a modern, fast disk usage viewer
Mount remote HTTP files locally via FUSE, fetching only what you read
NTFS USN Journal parser with full path reconstruction via journal rewind
Core Nix store semantics - pure types and validation logic
ProkaFS
A local filesystem database with ID based file and directory management
Filesystem watcher. Works anywhere. Simple, efficient and friendly.
Kubernetes Custom Resource Bindings
A pure-Rust fail2ban replacement. Single static binary, fast two-phase matching, nftables/iptables firewall backends.
validating CODEOWNERS files
A minimal suckless-style file browser for the terminal with vim-like keybindings
— deterministic, split, checksummed, compressed archive system with faithful restore
Watch directory structure and file changes in real-time with a beautiful TUI
Origin Private File System browser API
Virtio device implementations for msb_krun microVMs
Common API for various icalendar/vcard storages
Collection of utils from the CylonCore project
Fast, powerful filesystem indexing with .gitignore support and iterator-based API
Cross-platform async FUSE abstraction (rfuse3 + winfsp-rs)
Print files with formatting
Clean your commands history by removing duplicate commands, commands between dates, etc
Core block reader traits, error types, and composition utilities
A Git-based backup library for Rust applications. Originally designed for the Obsidian Minecraft Server Panel, but generic enough to be used in any project requiring file backup management.
An extremely fast glob matcher
Native bindings to the HDF5 library
A minimal, flat file archive encoding/decoding library
Cross-platform and reliable tilde-expansion solution
a minimalist podcast server (type b) for serving media files on the web
Run 🍺
Sensitive data redaction utilities for REX
farm swc tranformer for vite-style import.meta.glob
Run AI coding agents inside systemd containers
Storage layer for LaminarDB - checkpoint persistence and object store integration
Pure Rust PFS3 (Amiga) filesystem library — read, write, format, and check
dotfile organization made easy
A PE (Portable Executable) library!
Fast, cross-platform GNU tree compatible directory listing
Constructs POSIX portable filenames (A-Za-z0-9._-)
Setup your local computer / user automatically
Fast directory & process scanner: scan large files/folders, list/kill processes, and print system info
A small Rust CLI for downloading all files from a public MEGA folder
rendering celeste maps, and overlaying recorded paths, lobby entrances etc
Discover git repositories and check if a directory is a git repository
Async FUSE library using io_uring (FUSE_OVER_IO_URING) and compio runtime for high-performance userspace filesystems on Linux 6.14+
S3-compatible distributed object store for self-hosted deployments
Switchy File-system package
Flatten subdirectories by moving all files to the root directory
Helper for a number of tasks unavailable in Synology Photos web interface
Generate SUMMARY.md files based on your book's file structure
Wayland clipboard manager with fast persistent history and multi-media support
Core runtime detection and execution planning for rx
Types that are common across CoreVM service, builder, monitor, tooling
Expanding tildes in paths
keep your legacy durable, detect changes to your directories over time
A CLI tool to create Bad-USB scripts from shell scripts for quick use
A copy-on-write abstraction for binary data backed by memory or files
Inspect, extract, create, and update Bethesda BSA and BA2 archives
Filesystems library using 9P2000.L protocol, an extended variant of 9P from Plan 9
rspack cache storage
The fastest multi-format file converter CLI tool
A no_std compatible crate for reading Amiga Fast File System (AFFS) disk images
Core library for MediaVault — scanning, sidecar I/O, TMDB integration, and metadata parsing
Pre-protocol payload tagging, similarity clustering, and packet/firmware triage CLI
A syncer to Canvas LMS with files among courses
A powerful CLI tool for analyzing files and directories with detailed metadata, permissions, and size information
CLI operations on a list (bunch) of given unix-style paths
The ultimate Rust library for parsing, modifying, and generating Dockerfiles
swiss army knife for chess file formats
Copy files and directories recursively, preserving mtime and permissions
Pipeline descriptor types and codec helpers for gibblox
A fast, safe CLI tool to organize files into categorized folders
System usage monitor inspired by glances
Minimal filesystem for the RuVix Cognition Kernel (ADR-087 Phase E)
Core logic for vde-tmux-manager
Regularly shock your ZFS pools to maintain good hygiene and prune stale snapshots
shock
Marker-based block editing CLI
Object storage contract types for Converge
logger library
Get the user home directory in a cross-platform way
get directory
no_std MIME ↔ extension lookup from embedded JSON, no OS files
Incremental remote backups made simple!
git lfs file pulling implementation in pure rust. Can only pull files / folders and only support token-auth for now.
A Tmux plugin to quickly create session for folders in configured paths
reading and writing MacOS bill-of-materials (BOM) files
Rust implementations of the moreutils tools
filesystem access control for Kubernetes secrets directory
A TUI tool to find and remove node_modules folders
Overlay Filesystem in Userspace
Encrypted filesystem core library with C ABI for cross-platform frontends
Rename bulk files with simple patterns
Terminal utility for finding unique (non-duplicated) files
Support for Linux-specific tempfile extensions
Desktop Linux file integrity monitor. One operator, one workstation. Kernel-level filesystem watching, BLAKE3 hashing, HMAC-chained audit trail. Silent by default, local by design, deeply paranoid.
Mount MTP devices as local filesystems via FUSE
Zero-config project type detection — identify any project's language, build system, and toolchain from directory contents
asynchronously creating a ZIP file on the fly
Inlines modules in Rust source code for source analysis
ActivityWatch watcher for code agent sessions — tracks session duration, models, token usage, and costs
A catalog of Linux apps and where they keep their data
CLI tool to sync directories using copy-on-write with include/exclude pattern support
Docbox core business logic and functionality
Cross-platform file locking library for Rust
Filesystem based hierarchical text/data format
Generic OTA supervisor for field devices
File sequence detector in Rust with Python interface for automation systems
Cross device backup manager, which manages backups on several storages mounted on multiple devices
A safe Rust wrapper for ext2/3/4 filesystem operations based on lwext4
A file system watcher that executes a command when a specified file changes
A cli tool for creating a seemless workflow with remote and local git repos
Shared code for IPFS HTTP API clients
A fuse-based filesystem to map ranges in file to individual files
LCP File System - A ZFS-inspired copy-on-write filesystem for Rust
Mount helper for fuseftp
A rustls certificate chain and private key file reader
Git remote helper for panproto:// URLs (enables git push/pull/clone via panproto)
Filesystem-based storage backend for Sedimentree
CLI tool for processing files and strings
Ergonomic paths and files in rust
aids in accessing file-like storage
Core library for Git Worktree Manager
Core SSH session management library — config, resolution, validation, and command building
Disk cleanup CLI for developers - clean node_modules, target, .venv, Docker, Xcode caches and 50+ cache types
Static hash table that scales via disk-backed expansion to trim memory usage while ensuring each lookup needs exactly one I/O
A Windows utility for NTFS/ReFS to search the MFT & monitoring the changes of USN Journal
path resolution framework
Copy directories recursively in a straightforward and predictable way
CLI tool for exploring NP-hard problem reductions
Smart cross-platform path shortening for CLIs, prompts, and tools
PNA(Portable-Network-Archive) decoding and encoding library
SIGBUS-safe memory-mapped file access for network filesystems (NFS/EFS)
Safe system information SDK for REX with Cedar authorization
Security primitives: injection scanning, secret redaction, command approval, URL safety
A modern CLI tool to analyze disk usage and find largest files/directories
Server implementation of the 9p file system protocol
Filesystem module for RongJS
Interactive S3 shell with Unix-like commands and archive navigation
Set of I/O-free coroutines to manage Vdir filesystems
FUSE filesystem that mounts enterprise REST APIs as agent-readable files
Terminal-based clipboard manager
A robust backup tool
A CLI for managing trawl resources
Path and PathBuf-like types for representing canonical filesystem paths
filesystem utility crate for the Flamberge mod manager stack
Get the path of a binary target's executable
A high-performance disk-persistent message queue. Optimized for low-latency scenarios.
Filesystem backend for the Save Our Secrets SDK
Core traits and types for the AnyFS pluggable virtual filesystem standard
A CLI tool to manage dotfiles with symbolic linking and staging capabilities
Core logic for taskmd — Markdown-native task management
Tool execution and integrations for the Bamboo agent framework
A curious file tracker - monitors and logs new files in a searchable TUI
WebNative Filesystem API (WebAssembly)
Async file watcher with glob-based include/exclude patterns and built-in debouncing
Rust RC file Management commands
CLI tool for visiting project directories
Common types for VFS S3 synchronization
A very basic library to read the ext4 filesystem
Non-blocking buffered line reader for Read objects
A modern disk usage analyzer with a terminal UI, inspired by ncdu
Mirror a local directory into an NFS shared service
Glob tool for AI agent harnesses — bash-style pattern matching with .gitignore enumeration, alias pushback, NOT_FOUND siblings, and auto-split absolute-path patterns
Fast and simple directory navigation in your terminal
Lints your Git commit history against a declarative ruleset
Read a directory and get back all files and errors from the read operation
(每分钟) 创建 btrfs 快照, 并自动清理. (Make btrfs snapshot (every minute), and auto clean)
A portable and efficient crate for reading a specific range of bytes from a file. Provides both sync/async APIs and uses concurrent-safe positional I/O.
validates agent skills according to the Agent Skills specification, informed by the OpenCode and Claude Code implementations
recursive directory traversal
Write/Edit/MultiEdit tool for AI agent harnesses — atomic write, read-before-edit ledger, OLD_STRING_NOT_UNIQUE with match locations, OLD_STRING_NOT_FOUND with fuzzy candidates, sequential multi-edit pipeline
MCP proxy for managing Codex agent sessions with ATM team integration
A complete solution for fetching symbol files and resolving code addresses to symbols and debuginfo
A powerful tool to validate directory(Files and folders) structures
blazing fast File System Tree command in Rust with smart file type icons
Safe, idiomatic Rust SDK for talu LLM inference
types for managing collections of large objects, using an in-memory LRU cache backed by persistent storage (typically the filesystem)
Filesystem traits, OSTree path wrapper, and shared test helpers
A Capsula hook that captures file content
Rust reference implementation of matrix256v1 — a SHA-256 fingerprint over the (path, size) records of a rooted filesystem tree
SkillLite FS: centralized file read/write/search_replace
A cross-platform caching library for Rust with configurable storage, lifecycle, and file formatting
a small Rust webserver built with axum that serves a seeded randomly generated virtual filesystem
OCI registry pull-through cache
Evaluate binary path stability and find stable PATH candidates
A storage backend for libunftp that provides read-only access to FAT filesystem images
Simplified file management
Yazi event proxy
that allows one to write cli tools quickly
handling file sizes, download speeds, and download acceleration with support for both SI and IEC standards
rate is a cross-platform tool that clears all installed Rust crates from the .cargo/registry folder, helping you free up disk space. It works on Windows, macOS, and Linux.
Type-safe structured paths with partitions, parsing, and schema associations
A command-line tool for cleaning code comments, supporting multiple programming languages
— Secure, encrypted reactive filesystem with hybrid post-quantum cryptography
SIMD optimized glob pattern matching library faster than glob crate
unfold is a small command line utility that replaces symbolic links with their targets
mirror and export GitHub discussions as JSON and static HTML
A CLI tool that analyses dependencies within a Cargo workspace
High-performance Rust library for DAOS (Distributed Asynchronous Object Storage)
CLI for installing agent skills
Vault management, file operations, and watching
Deduplicate data by creating reflinks between identical files
Filesystem-backed cache store with XDG-friendly defaults
customize Raspberry Pi OS images by patching the boot partition without mounting or rebuilding the system
System metric export through Opentelemetry
ZboxFS is a zero-details, privacy-focused in-app file system
Virtual filesystem layer for ArceOS
reading inode numbers (Linux, MacOS) and file IDs (Windows)
OCI image pulling, layer extraction, and caching for microsandbox
Watchexec's process supervisor component
hash functions with a straightforward interface for computing digests of bytes, files, directories, and more
A program to pack and install Factorio mods from source code quickly
Read file data directly from block device using extent information
Guard your sensitive configuration files
Testing framework for Cargo's testsuite
A terminal-based tool for quickly switching between directories and files
Block reader for MBR partitions
Fast parallel file copy command (pcp)
Combine files into a single output. Supports JSON, text, XML, YAML, and CSV formats.
Production-ready VCS and orchestration engine for DX tools with Git-like versioning, dual-watcher architecture, traffic branch system, and component injection
Pure Rust VM disk toolkit with beautiful output, Windows registry parsing, and VM migration support
Fast Rust implementation of Unix find with GNU-compatible syntax and parallel traversal
core functionality for Basalt TUI application
Shared core types and utilities for zccache
ext4 filesystem adapter and ext4 file-backed block reader
Filesystem abstraction layer for Rolldown
Content-addressable storage on top of apotheca. Bytes go in, BLAKE3 hash comes out; the underlying cella's compare-and-swap pinax namespace is surfaced as a pass-through.
powerful command-line tool written in Rust for managing your system's PATH environment variable
Filesystem-based key provider for trustless
finding and managing Cooklang recipes in the filesystem
creating AppImages
A CI-compatible CLI utility that can create root filesystem images (for use in virtual machines) from reproducible and readable TOML build scripts
A collection of crates for working with various file formats
Shared GeoTIFF / BigTIFF / COG read-write engine for Whitebox crates
A fast, keyboard-driven disk usage explorer built on ratatui
EROFS filesystem adapter for gibblox block readers
Rustty safe abstraction over hxcfe-sys. Unfinished work, contributions are welcomed.
Sleek Manifest File Handler
A comprehensive Model Context Protocol (MCP) server for filesystem operations
Safe interface to pwd.h
File Hash Renamer
Fast parallel directory deletion with cross-platform support
file manager
a neofectch style wrapper for pacman's Syu/Sy/Su
Abstractions for building read-only sans-io abstractions VFS
Fuzzy Directory Navigation Tool
Block reader backed by local files
Disk usage management for shared or staging filesystems with automatic cleanup policies
Bridge process lifecycle management for rust-camel (spawn, health, download)
TOML environment spec parser and dependency provider framework for hyperdocker
A pure Rust library for reading EROFS (Enhanced Read-Only File System) images
creates an empty file
Named write-once store with a compare-and-swap pinax namespace. Bytes go in by name, come out by name; deposita are never overwritten, pinakes update via compare-and-swap.
Terminal UI for PanEx file explorer
S3-backed container layer persistence with crash-tolerant uploads
Host-side SDK for loading and interacting with Drasi cdylib plugins
Utilities Library
ratatui-explorer is a small, but highly customizable, file explorer widget for ratatui
A compile-time map of LS_COLORS-style extension-to-colour mappings
Efficient function mapping over directory trees
Fast, parallel Rust CLI tool for analyzing directory sizes
Configuration library, with directory overlaying and fragments dropins
path crawler, that copies all SRC files into a singe output to send it to a ai (toai)
Safe, guarded memory-mapped file I/O for Rust
Self upgrade for standalone executables
Yazi bootstrapper
Core traversal, diff calculation, and reporting traits for semdiff
UnixFs tree support
CLI binary for ripsed
ublk device lifecycle management for swap-critical daemons
JDK version management tool
A sandbox to execute a program in an isolated environment and measure its resource usage
Configuration file discovery and reading with multiple format support
cli
A significantly faster alternative to the classic Unix cp(1) command
Fast Rust implementation of XYZ file fixing and trajectory conversion utilities
reduce code verbosity
A CLI tool to sync files between directories
Virtual file system abstraction for the Oak framework, supporting disk and memory-based storage
Cross-platform system directory paths for iOS, macOS, Android, Linux, Windows and other Unix
Fast Rust CLI for coverage and diagnostics gating
safely handle file system paths for container runtimes
Path utility library
Language Server Protocol implementation for Shape
Fast file type detection
Diganose your executable lookup problems with this rust library
Terminal based linux filesystem mount manager
CLI tool to extract chapters, metadata and cover for M4B Audiobook
A safe and idiomatic wrapper around the Windows Cloud Filter API
File storage
DAB file structure generator
Organise temporary files
JSON Query Language - is a fast and simple command-line tool to manipulate JSON data
a faster, simpler alternative to cp
Swiftly traverse and scan directories. Sway 🪭, swing 🎷 or swim 🪼 in directories.
application that handles the use of bmap crate
A powerful Rust library for game collection management with automatic scanning, intelligent metadata retrieval from multiple databases (DLsite, IGDB, TheGamesDB), and smart matching algorithms
A program that periodically removes desktop shortcuts
Sandboxed git workspaces for development
Slice and dice URLs on the command line
High-performance directory tree traversal and file content extraction library with configurable filtering, binary detection, and streaming support
Tmux Sessionizer is a cli tool to fuzzy find all git repositories in a list of specified folders and open them as a new tmux session. Also, for git worktrees, this tool opens all checked out worktrees as new windows.
Bulk find-and-replace engine — regex, literal, multi-file, atomic writes
Pure-Rust partition-table probe (GPT/MBR) and filesystem-magic sniffer
MessagePort transport bridge for BlockReader RPC
A CLI application and library for managing and mounting sshfs (SFTP) filesystems
Port of the Ruby Webmachine library to Rust
Yazi SFTP client
FUSE filesystem adapter for Hexz snapshots
Fast parallel find — a drop-in GNU find replacement for AI agents and large codebases
Easy rename for unix-like systems
Storage crate for feldera
Generate ESM Node.js bindings for UniFFI cdylibs using koffi
No-std compatible Rust library for reading ext2/ext3/ext4 filesystems
Kubernetes CRDs for longhorn
Force-remove Files and Directories on Linux Including Paths with 000 Permissions
Cross-platform system monitor TUI — CPU, memory, disk, GPU, ports, process management
A Capsula hook that captures the current working directory
allows you to clone repositories from a given URL or clipboard to configured base directory and mappings for cloning repositories. Useful for managing multiple repositories under a single directory related to host name.
Monitors a directory for file changes and delivers new UTF-8 content over a channel, with configurable read strategies
Write bootable OS images to USB drive (dd on steroids)
A lightweight Rust crate for managing temporary files and directories with automatic cleanup
Remove empty dirs
A speed-first local data deduplication engine using tiered BLAKE3 hashing
A software composition analysis (SCA) tool for generating Software Bills of Materials (SBOM) and scanning for known vulnerabilities
tokio adapter for foyer - Hybrid cache for Rust
basically a Rust implementation of Balena’s drivelist
Smart duplicate file finder with interactive TUI
Atomically exchange names of two files or directories with Rust and C APIs
Platform-optimized recursive directory walker with metadata
A TUI file explorer written in RUST with Ratatui
A journaling file system demonstrating crash consistency (Three Easy Pieces)
A fast command-line tool for scanning directories, analyzing file structures, and extracting file contents with gitignore support
Cross-platform XDG Base Directory Specification implementation
A virtual layer for WASI modules
Container environment manager for development
Safe Rust wrapper around the util-linux/libmount C library
util-linux/libmount
Include many files in your Rust code for self-contained binaries
Get your tools on the PATH — cross-shell, cross-platform, zero fuss
Cross-platform path construction macro supporting both slash (/) and comma (,) syntax with variable interpolation
Open a project from your workspace in a tmux session with a configurable layout, optionally in a fresh git worktree
Safe filesystem I/O SDK for REX with Cedar authorization
sorted string table abstraction
filesystem-based Markdown page loader
conveniently learn about the disk usage of directories, fast!
File System eXerciser
Sandbox any command with file, network, and credential controls
A fast and colorful Rust-based ls replacement CLI tool with JSON output and sorting options
Production-ready CLI tool for one-way file synchronization with Google Drive. Features: dependency injection, rate limiting, retry with backoff, parallel uploads, and comprehensive documentation.
system-level helper functions for the dirs and directories crates
CLI to convert .note files (and directories of them) into pdfs for archival and backup
high-performance, in-memory database for source code analysis, featuring distinct mutable and immutable states and transactional updates
Core library for DUX disk usage analyzer - tree data structures and parallel scanning
Finds and removes duplicate files
Rust-first file analysis, metadata, and storage operations for Windows-focused applications
A useful, async-first file renaming library
Filesystem tools and session-scoped filesystem policies for agentkit
Content-addressed, log-structured memory-mapped database
A burn-in tool for spinning rust HDDs
Cocoon TPM project - secure persistent storage
zfs sync tool, core library
Elementary zero config cross platform key-value persistence library
A port of QStandardPaths class which provides methods for accessing standard paths on the local filesystem (config, cache, user directories and etc.)
Fast Format drop-in replacement for cargo-fmt
CLI file manager. Very simple. By KAA
OpenDAL Command Line Interface
Model directory structures as plain Rust structs
.gitignore file format for quickly checking whether a path is ignored by git - without invoking the git cli
Fast file operations tools - rcp (copy) and rcpd (remote copy daemon)
A dynamic move command or simple file stash
constructing and manipulating virtual file systems in Rust, based on OpenMW's VFS implementation
Create Macintosh File System (MFS) disk images
S3 SDK adapter for rustfs-cli
Filesystem backends and guest filesystem support for microsandbox
offers a few utils for Rust development
Fast, lag-free terminal file browser
Convert path lists into compact brace expansion syntax
A lightweight indexing engine for filesystem entries
Background daemon for TLDR code analysis tool
A powerful bulk file renaming tool and library with regex support, Python scripting, and transactional safety
The bridge between xdg-desktop-portal-termfilechooser and your favorite terminal based filepicker
Cargo build with better caching
Workspace-bound path validation and traversal prevention for Perl tooling
A git-based virtual filesystem mounted with fuse. It allows mounting of multiple repositories, fetched from GitHub or Gitlab, independently as well as running automated builds and tests on them.
Bookmarks in your filesystem
A memory safe API for interacting with libmtp library
Public facade for the Archivist filesystem scanner (scan API and FileRecord types)
A blazingly fast, minimalist directory tree viewer, written in Rust
Lightweight High-Performance File System Change Tracking Tool
A wrapper around openat, symlinkat, and similar system calls
Deno resolution algorithm
Disk-usage explorer en CLI Rust : scanne un dossier et l'affiche en camembert ASCII Unicode interactif (drill-down souris/clavier)
Trivial path matching
Quality-of-life extensions for camino-tempfile
Expression-based file search combining name, content, metadata, and structured data predicates
File type detection from content (magic bytes), file extension, and MIME type mapping
Interactive CLI to explore and visualize file and directory sizes
Platform-native file locking with blocking and non-blocking support
Virtualization and container management for herolib (buildah, nerdctl, kubernetes)
Mount GitHub repositories as a local filesystem
Generate source-based code coverage for eBPF programs
clean up old Nix profile generations and left-over garbage collection roots
the dysk cli as a library
I/O utilities for dsq - handles reading and writing to disk, STDIN, STDOUT
A smart CLI tool to organize and clean up messy directories
Easy interfaces for file i/o
A fast CLI tool to organize your files automatically by category, date, or hybrid mode
command to quickly search a file/folder by name
PNA(Portable-Network-Archive) file system
Ergonomic facade for the Rivia Virtual FileSystem
CLI tool for discovering and invoking Proton installations on Linux systems
Generate quotes for remote attestation on confidential computing platforms using Linux's configfs-tsm filesystem interface
A file-level updater tool for (primarily) Windows applications
Virtual FileStore Abstraction for different Backends
A modern, fast file copying tool
embedding static assets in your Axum application at compile time
Capability-based version of async-std
Command line tool to find, filter, sort and list files
easy persistence
IO primitives for Deno extensions
CLI tool for managing technical documentation
An interactive, DaisyDisk-like terminal disk usage analyzer with rich TUI
obtaining platform dependant directory paths for application and user directories
CLI tool for converting OCI container images to ext4 root filesystems
A convenient high level library for reading SquashFS files
File identification library for Rust - detects file types based on extensions, shebangs, and content
AI-powered directory indexing with semantic search for MCP servers
Intelligent disk cleanup CLI for developers — scan, find, deduplicate, and clean
Core types for biov: manifests, lockfile, cache layout, and error types
Official Buf CLI binaries from bufbuild/buf releases — fetched and verified at build time (see README)
Read tool for AI agent harnesses — filesystem read with pagination, binary sniff, directory listing, attachment shape, NOT_FOUND fuzzy siblings
A lightweight library for managing application configurations with support for multiple file formats
Locates a Java installation in the host
Coding agent tools (CLI + MCP). First tool: ls.
A minimal, safe, and portable recursive copy library for Unix systems
A minimal C-style scripting language interpreter
interacting with the openmw config file and the virtual file system it defines
projection-safe feed for local coding-agent activity
Userspace transaction infrastructure for modifying btrfs filesystems
Embeddable SHell - a Rust library for building interactive, command-driven CLI applications
in Rust for parsing Minidump (.dmp) files generated in user mode on Windows
Translate canonical (symlink-resolved) filesystem paths back to their logical (symlink-preserving) equivalents
Opinionated issue tracker built for solo developers
Wrapper around a lockfile with unlock-on-drop semantics
Python standard library runtime for the Rython compiler ecosystem
CLI to explore Apple DMG disk images: DMG → HFS+/APFS → PKG → PBZX → files
ExFAT filesystem library with async support, mainly focusing on embedded system
A blazingly fast file finder, organizer, and pentesting tool for Linux/Unix systems with netcat-style combined flags
Source cache management for rattler-build
Proof-of-concept SPANN-style approximate nearest neighbor index in Rust
in-memory manifest of related files
macOS disk cleanup tool for developers
Filesystem adapter for triad claims, config, snapshots, and evidence
Fast disk usage analyzer with intelligent caching for incremental write workloads
S3 cli backup by file name prefix
Core library of Pijul, a distributed version control system based on a sound theory of collaborative work
A high-performance disk space analyzer with TUI interface
IPLD HAMT implementation for Webnative Filesystem
Unified directories for different use cases of an application, providing standard directories for local development, when run as service or when run by a user
Fast, secure & intelligent local backup tool with AES-256 encryption and Zstd compression
A very basic library to read QCOW files
A Tauri plugin for sharing content via the system's share dialog
Browse and extract files from ISO images without mounting them
Filesystem sync between local and microsandbox microVMs via S3-compatible storage
CLI tool to find and remove duplicate media files using SHA-256 and perceptual hashing
My TUI for generating different types of projects
Browse Claude Code history across working directories and resume sessions
Smart file organization
Shrink Raspberry Pi root filesystem and create additional partitions for swap, /var, and /home
Workspace - A tool suite for file operations, version management, and development workflow automation
Automatically install AppImages with desktop integration
Runtime stub for onelf packed binaries
File storage subsystem for Cloudillo: upload, download, image processing, and variant generation
smarter zsh autosuggestions — ranked by your current directory
Like canonicalize, but without performing I/O
Core library for the Kimün notes application
Linux CLI tool for running commands with ephemeral, namespace-private filesystems
Ensure paths are normalized without I/O
call ioctl FIEMAP on files with ease
Clean build artifacts from development projects to reclaim disk space
Core utilities and types for the Rew runtime system
A fast CLI to generate text that matches regex-like patterns
dupes finder
storage engine for foyer - Hybrid cache for Rust
Data structures for storing linker layout information
interacting with Ndless for the TI-Nspire
No-std I/O traits and utilities for the Hadris filesystem crates
A command-line tool to read file system metadata then return it in JSON format (output and errors)
An unusually flexible and efficient file name sanitiser
Fast file removal tool - efficiently removes large filesets (similar to rm -rf but much faster)
A set of tools for managing Xous ecosystem binaries
binary to securily delete files, overwriting and moving them before removal
OpenDAL File System
casync index/chunk source with integrated chunk cache store
Intelligent command suggestor for your typo or wrong commands
One screenshot, three pastes. Atomic multi-format clipboard (image + file + path) on Windows, macOS, and Linux.
A fast and convenient TUI file browser for remote servers
CLI utility for ISO 9660 image operations
S3-like website endpoint crate for the Garage object store
Blazing-fast parallel search engine — generic, embeddable, zero opinions
A high-performance, full-screen CLI file manager and metadata tagger using extended attributes (xattrs)
Shared code lib for kondo and kondo-ui
AgentFS SDK for Rust
A desktop GUI tool to scan, visualize, and clean up Rust project target directories
Trigger events when files or directories change
A CLI tool to analyze directory contents and report file statistics
Tiny Bevy wrapper for etcetera: An unopinionated library for obtaining configuration, data, cache, & other directories
Access to snapcraft environment
Wholesome collection of file hashing algorithms all bundled in a single tool. Like sha256sum, b3sum and others, but one: the whole-sum.
CLI for provable-contracts — validate, scaffold, verify, status, audit
Cross-platform mutual exclusion across processes on a file or path
A very small in-program database with cache, disk storage, etc
Background service that extracts documentation files from code repositories and links them for Ulysses external folder importing
Linux sandbox backend for Heimdall using bubblewrap and namespaces
Virtual disk image tool for creating, partitioning, formatting, and manipulating images
File management system for agent-diva with deduplication and reference counting
FUSE application binary interface for polyfuse
polyfuse
File storage abstraction for the Ferro framework
The ultimate system cleaner and optimizer for macOS and Linux
A code surfing library for Git repositories
working with the btrfs filesystem
Pure-Rust block-device framework — BlockRead/BlockDevice traits + FileDevice + CallbackDevice + LRU cache. Foundation crate for fs-* drivers and img-* containers.
manipulate Linux initrd files
Execute Python scripts from Rust with path traversal prevention and environment isolation
Test utilities for Harmonia (proptest strategies, macros)
A file splitting & merging solution
interacting with the Nix command
Userspace FUSE driver for btrfs, built on btrfs-disk
Persistent stores for Tauri
A no_std Rust crate for Linux-style dynamic debug based on per-callsite static keys
Common types and functions used by Hadris
Two-way file sync with conflict detection for local and SSH roots
Automatically save chats from Claude, Codex, and Gemini CLI to local Markdown files
Skill storage and filesystem management for skills.rs - Load and watch skill definitions
filesystem implementation for rCore tutorial OS
Create lockfiles that remove themselves when they are dropped
Verify backup integrity by comparing directory trees
Track Filesystem Integrity via 'Snapshots' which contain a HashMap of the files and their corresponding hash signature from a specified directory
fsspec-compatible backends with Rust accleration
Move files in the command line with ease
Get process icons in a cross-platform way
Git-like content-addressed filesystem store with metadata preservation
Sync Nix flake pins
Kellnr is a self-hosted registry for Rust crates with support for rustdocs and crates.io caching
Recursive search and replace CLI application
Safe disk information SDK for REX with Cedar authorization
implementing recursive digest for filesystem directories
Ascend directories by count
Extract and save agent chat logs (Claude, Codex, Gemini CLI) as local Markdown files
The first choice of fs library, inspired by node:fs
Xvc parallel file system walker with ignore features
Fast Rust-based disk usage analyzer with histogram visualization
Provide convenient methods for path operations
File synchronization engine — N-location, pluggable store & backend
A minimal, performant book-keeping, authoring and documentation tool
Generic log runtime paths and initialization
Zawgl Graph Core Library
Core types and pure logic for ambient-fs
a client for the Watchman file watching service
offers a rollback mechanism in Rust for fs common operations
A no_std fork of the path module from https://github.com/rust-lang/rust
A cli tool for applying project templates
A fast, interactive file finder with live preview built in Rust
ISO9660 reading library
C FFI bindings for the Tensogram N-tensor message format library
A file sync tool that refuses to waste your time
Read-only, low level, virtual file types for the RuneScape file system
i3wm cookbook for git
Interact with Apple SDKs
Shared file transfer domain/runtime for LingXia
Scripting environment using rhai
Wiki backend for OmniFuse
A wrapper for qBittorrent Web API
generated REST API bindings
CLI for darn - CRDT-backed filesystem management
Removes trailing whitespaces and trailing empty lines from text files
Parquet reader and writer implementations for Fusio
CLI utility for FAT filesystem analysis and management
cli and library for interacting with OCI registries
Make BTRFS easier
reading, creating, and modification of cpio file systems
providing access to systemd's userdb varlink interface
GIT CLI simplified
Shared app/product context for LingXia crates
Find installed and running applications on Linux
A high-performance, low-memory XML DOM parser for Rust — with namespace-aware parsing, order-preserving attributes, and round-trip safe serialization
Disassemble XML into smaller, manageable files and reassemble on demand
Minimal, extensible, no_std, no_alloc FAT32 file system driver for SD cards
Sandboxed AI agent sessions with remote access
Cross-machine directory sync tool — link, push, pull, resolve conflicts
Lightweight sandboxing for tests that write to the filesystem
configuration loader and API around restic
restic
Cleans rust build directories recursively
Application-level mount preparation for OmniFuse
Process sandbox runtime for Heimdall
Parallel, cross-platform version of du
comprehensive FHIR (Fast Healthcare Interoperability Resources) specification model implementation that contains strongly-typed Rust representations of all FHIR data types, and resourcess…
Parallelizes deleting directories which can significantly speed up deleting large deeply nested directories with a large number of files on Windows
Fast recursive directory jumper — like z, but instant and stateless
UNixize Filename -- replace annoying anti-unix characters in filenames
Generate a clean directory tree and copy it to the system clipboard
Cross-platform disk/volume resolver — given a path, tells you which disk it's on, its mount point, relative path, and disk usage
I/O port traits for host-abstracted file access, enabling WASM targets
Save and load structs from a local file. A convenience wrapper around the savefile crate.
quickly clean the target dir
A temporary file writer with an option to persist
A fast terminal file manager with dual panels, vim navigation, and SFTP/FTP/SCP support
Safe Rust wrapper around the util-linux/libblkid C library
util-linux/libblkid
Prevent path traversal attacks at type level
Content-addressed object storage and snapshot trees for syft
Shared test utilities for zccache crates
Application tools for working with file-system paths
DICOM anonymization
Create symlinks in a cross-platform manner
Find files within current directory that match given patterns, while respecting gitignore rules
Async fuse library to make fuse develop easier
The Tapis Files API provides for management of file resources on Tapis systems
A human-friendly file and directory path manipulation library for Rust
Orchestration layer for CoW-accelerated git worktree hydration
High resolution systems performance telemetry agent
Manually map PE to process memory
An Easy/Efficient Backup Solution for manual backup of syncing data in local storage devices
Migration tool: hermes-agent / OpenClaw → EdgeCrab config, sessions, skills
Runtime ISO discovery for rescue environments (loopback mount + GPT/ISO9660 + sha256/minisign sidecar verification)
Filesystem scanner for flix media
A command line utility to generate Steam 2FA codes and respond to confirmations
BTRFS disk format
CLI utility for Universal Disk Format image operations
Extraction Maestro
Common utilities used across several subcrates of Slumber. Not for external use.
working with the Origin Private File System (OPFS) in WebAssembly applications
parse cmake language
A cli to manage collections of images
interact with Conda repodata
Returns the path of the current user's home directory if known
Efficient data bundling system with indexed .spool files and SQLite vector database
Upgrade from file system to database storage for the Save Our Secrets SDK
Safe Rust bindings for macOS getattrlistbulk() system call for high-performance directory enumeration
Smart Move - An enhanced mv command with transformation capabilities
CLI + Library to add leading zeros to ascending numbered file names. NFLZ stands for Numbered Files Leading Zeros.
Core library for Arc Academy Terminal - command analysis and learning engine
Filename and path validation for security hardening
Core of Czkawka app
puniyu crate for common
Distinguishable sample PDF generator
Complete filesystem intelligence — index, analyse, organise
Batteries-included scripting utilities for Rust
Your small yet useful swiss army knife for the fcntl system call, specifically for acquiring and testing file locks, but not limited to those
fcntl
CLI utility for CPIO archive operations
DAG-PB serialization/deserialization library for IPFS CAR v1 archives
TUI application for monitoring antnode instances. Discovers nodes via log files, fetches metrics (resource usage, peers, bandwidth, etc.), calculates network speeds, and displays the…
Composable local artifact storage for Pulith
working with both compile-time embedded directories and runtime directories using an abstraction
ELF binary analysis and library dependency copying utilities using readelf
Rust-native MPQ archive toolkit
providing common functionality for file system operations and asynchronous file processing
A fast, feature-rich implementation of the Linux tree command
Read-only APFS (Apple File System) parser
A high-performance terminal directory comparison tool written in Rust - bringing Beyond Compare's intuitive interface to the command line
Debian Profile Sync — deploy a Proxmox LXC container and sync user profiles across Debian machines
A wapper for the borgbackup utility
Modal dual-pane file commander with helix-inspired interface
Cross-platform inspection of filesystem paths, including local and remote mounts
Magika-backed MIME detector integration for qubit-mime
Set and get Unix file owner and group
Tools for working with JSON via data paths
A fast CLI tool to build conda packages on Windows, macOS and Linux
Tar reading library, designed for using in embedded systems
decode and encode gcr bytes (4-to-5)
A command-line utility for reading and writing MacOS bill-of-materials (BOM) files
Disk-backed artifact storage for zccache
Native Rust API for libkrun microVMs
command line ID3v2 tag editor designed for scripting
merge config from multiple files / directories
Uses ViteJS to compile frontend assets and embeds the results into your Rust binary. (Serves from the ViteJS dev server in development.)
Content-addressed filesystem abstraction for S5
highly configurable TUI file manager, built for projects. You can handle all your project's file-based needs from a comfortable and smooth interface!
轻量级日志库
Transit data management
IPLD UnixFS File implementation for Webnative Filesystem
Bundles multiple repositories and copies to target directory
Cedar-based authorization engine for REX trusted remote execution
CLI tool to merge source files by extension while respecting .gitignore rules
An in-source vendoring alternative to Git submodules and subtrees
Filesystem watcher with debounce and attribution
Core library for Cuba
Linux system utils library
A small command-line utility to replace 'rm' and 'del' by a trash system
MicroVM runtime engine — VM lifecycle, OCI images, attestation, networking
A throw-catch style move and copy program
High-speed async file system traversal library with batteries-included file browser component
Binaries for the reading, creating, and modification of SquashFS file systems
Streaming shuffled JSONL: chunk pool, shuffle algorithms, I/O, sinks
Jetstream is a RPC framework for Rust, based on the 9P protocol and QUIC
Transaction-backed persistent state for Pulith resources
File-based agent registry for Common Agent Runtime — closes #111
Fork of dua-cli - A tool to conveniently learn about the disk usage of directories, fast! Now with token counting capabilities
User-space command-line tool for inspecting and managing Btrfs filesystems
API docs - The v3 API docs apply to both v3 and v4 versions of Sonarr. Some functionality may only be available in v4 of the Sonarr application.
gitoxide project dealing magical pathspecs
Snappy, batteries-included terminal file manager with rich previews, inline images, bulk actions, and trash support
Shared TOML config loader for hjkl-based apps — XDG path resolution, span-aware parse errors, optional validation hook
Append-only on-disk storage with integrity checks and indexing support
Pure-Rust VHD (Microsoft Virtual Hard Disk) reader. Fixed, dynamic, and differencing variants. Exposes a Rust API and a C ABI suitable for FFI from C/C++/Go/Swift.
Tail multiple files and glob patterns with live discovery and labeled output
Reliably open and lock a file
Policy document types and filesystem policy materialization for Heimdall
simplest to use API we could think of to persist prefs to disk. Basically wrap a macro around a struct (see syntax), then data is saved when you write to it. Performant, testable, thread safe…
Mark files or directories as excluded from backups (for Time Machine on macOS). Can be used to prevent caches and temporary files from bloating backups. Includes both a library interface…
libxcp is a high-level file-copy engine with support for multi-threading, fine-grained progress feedback, pluggable drivers, and .gitignore filters. libxcp provides the core functionality of xcp.
libxcp
.gitignore
xcp
Switchyard: safe, atomic, reversible filesystem swaps with policy and audit
Interactive TUI for batch file renaming using freneng
Developer-aware disk cleanup CLI
Opt-in disk persistence primitives for FakeCloud services
A command-line tool to organize PS (Problem Solving) source files by problem number
Astronomical Catalog operations
A fast and efficient file deduplication tool with support for media files
A high-performance file deletion library
A powerful symlink management tool designed as a modern alternative to GNU Stow
A CLI for OCFL repositories
Asset file manager
Pure-Rust QCOW2 reader. Exposes a Rust API and a C ABI suitable for FFI from C/C++/Go/Swift.
Fast multi-algorithm hashing library with file-sharing and cloud hash support
Virtual file system same as tokio::fs
A filesystem signal crate for monitoring, debouncing, and filtering events
A TUI log viewer with search, filtering, and real-time file monitoring
SQLite-based knowledge graph MCP server for persistent memory
Ops for interacting with the file system
A lean lib to manage files: open with default apps, reveal in managers or terminals, or trash files
Copy metadata from one file to another
Lune
Dev-only distributor source that serves packs and components from the local filesystem
Core runtime management for User-Space Capsules in Astrid OS
The way to interact and learn stuff
Async + Sync Filesystem in Userspace (FUSE) building library for Rust
IOCore is a safe library for unix CLI tools and Systems programming. IOCore provides the [iocore::Path] abstraction of file-system paths designed to replace most [std::path] and [std::fs]…
A command-line utility that queries files and directories using SQL-like syntax
A prefix guard (file lock) for rattler
Modern rsync alternative - Fast, parallel file synchronization
the object_store integration of Fusio
goup is an elegant Go version manager
CLI tool for file management, including compressing, extracting, renaming, and organizing files
SDK for the Eclipse KUKSA Databroker
Utils for working with SysFS in Garden OS
Tool framework foundation for OpenDev: traits, registry, policies, and sanitization
extension providing filesystem metadata for trussed
Failpoints implementation with automatic path exploration
Backend storage abstraction for the Save Our Secrets SDK
Scan for stale binaries in common bin folders and safely archive/restore them
Extract Extended Filesystem specific artefacts from a Partition
Parser for jql - the JSON Query Language tool
A Google APIs client library generated by tonic-build
Give me a path, I'll tell you the filesystem it's on
very simple search path file finder
Temporary test file/dir management for unit tests
Bookmark directories for easy directory-hopping in the terminal
fix wally package thunks with Luau types
Download and organize all your course materials from Canvas LMS 📚
Describe paths inside an S3 bucket like working with std's Path and PathBuf
Shared traversal-validation logic for zenops-safe-relative-path
zenops-safe-relative-path
Backend-agnostic, append-only manifest/WAL for Fusio (RFC-0001)
A fast file finder written in Rust with glob pattern matching
MPS — plain-text personal productivity CLI (Rust)
CPIO archive format (newc/SVR4)
parse and write Windows shortcut files (.lnk)
Retro disk image and language utility
A globset-compatible glob matcher – no_std, no regex, built on glob-matcher
no_std
Toolkit for farm
Contrail analysis UI and scoring service
Constants for the fabricatio
Skip ratchet
Controlling objects linked directly to a file
Parse Perl workspace folder declarations into filesystem paths
Symbolic Execution against Falcon IL
Reorganizes files into nested folders based on their filenames
native/wasm compatibility layer for window creation, input and filesystem
File locking for concurrent xchecker executions
Tauri plugin for raw path-based access to shared external storage on Android
CLI tool for dumap: scan directories and visualize disk usage as interactive treemaps
A no_std parser for Floreum messages
files and directories
(erd) is a cross-platform, multi-threaded, and general purpose filesystem and disk usage utility that is aware of .gitignore and hidden file rules
Shared helpers reused across aube crates (semantic hashing, async dedup, atomic filesystem ops, bincode sidecars)
macOS DMG disk image stage for anodizer release automation
Resume Codex sessions by git branch
A system information tool with better layouts
yEnc decoding, file assembly, and article cache for NZB download clients
Fuzzing Rust code with american-fuzzy-lop
moduforge 引擎规则
A luks header backup tool
internal component crate of uv
CLI tool for interacting with the freedesktop trashcan
Virtualization.framework VM primitives for the firkin Rust containerization library
Extended standard library modules and domain packs for Fusabi
Background daemon for Infolyt
Alonso's Node Package Manager - Fast, simple, and pretty
remove features from Electron that modify runtime behavior
That buddy that will get everything ready for you
Battery Health Tool for Linux
fjall repo for pict-rs
Shared Claude Code primitives: path topology and process utilities
This exhume module is proposing a standard abstraction layer of a FileSystem, File and Directory for any exhume filesystem modules (extfs, ...)
Small GUI tool to reorder/edit qBittorrent save path history (save_path_history)
getting desktop icons in linux
Comprehensive path validation and sanitization library with 85%+ attack vector coverage
Nightly tar.gz backups of a directory with SHA-256 verification and retention pruning
A cargo runner that ensures your workspace is available when run in wasmtime
Async Rust SDK for Shuru microVMs
Squarified treemap layout algorithm for dumap
Operation audit trail, snapshot storage, and rollback for TurboVault
A high-level, ergonomic Rust wrapper around the Everything SDK for fast Windows file search
Type-safe input sanitizer for shell arguments and file paths — rejects injection, traversal, and expansion attacks
convert between Linux and Windows UNC paths. Converts local Linux path to Windows/Linux UNC and vice versa.
Log temperatures from grainfather fermenters to brewfather
SSM Parameter Store model types for Rustack
discover, rank and inspect launchable Windows file entries
Copy-on-write workspace manager for parallel development
Rust client for FastDFS distributed file system
Normalization of file system paths
Works out if this is running from inside a shell, and if so, which one
S3 synchronization for Monaka VFS (native environment)
Git extension for navigating repos and worktrees — find files, directories, and branches across projects with frecency-ranked fuzzy selection
简单易用的路径处理库
local file backups with a bit of compression
Sync files between different sources
Cross-platform named-pipe API
Virtual filesystem with configurable backends
Terminal disk space visual navigator
Structured operators: differentiable DP relaxations (Soft-DTW, soft shortest path)
Core library for darn - CRDT-backed filesystem management
Advanced file manager plugin combining fs, dialog, and opener functionality for desktop platforms
file manager TUI
Nushell experimental options
Taskboard plugin for the room multi-user chat system
WARNING! UNDER ACTIVE DEVELOPMENT. An encrypted file system that is mounted with FUSE on Linux. It can be used to create encrypted directories.
just making files and directories
attempts to expand ~ and ~user while creating a filesystem path
Cross-platform shared types, domain traits, and protocol for the minibox container runtime
save code and other files
CLI tool for replacing x509 certificates and their private keys
reusable directory buffers
Small command-line utilities for working with sparse files
Rename or copy files based on EXIF data
A converter from proto files into quick-protobuf compatible Rust module
rs3gw storage backend for OxiGDAL - High-performance cloud storage access
Git-inspired context management for LLM agents -- COMMIT, BRANCH, MERGE, and CONTEXT over versioned memory (arXiv:2508.00031)
Loco generators
Static site generator pipeline with markdown, post feeds, and RSS
A zeek log analysis library implemented in Rust
API docs
A bare bones 9p implementation
Core library for winterbaume - AWS service mocking for Rust
Byte reader for selected tar entries
A complete, zero-dependency implementation of the XDG Base Directory Specification (v0.8) for Linux and Unix systems
Fork of clang-sys with preserver none support
WinFSP wrapper for rust
XDG Base Directory resolution — env-first, $HOME-fallback, uniform across platforms
A Model Context Protocol (MCP) server for advanced filesystem operations with file handling capabilities
protoc binary for linux-x86_64 compiled by Google and bundled in this crate
Core library for rustfs-cli S3 CLI client
UDF (Universal Disk Format) filesystem
Typed Filesystem integration for Leash
Read-only HFS+ / HFSX filesystem parser
Efficiently delete node_modules directories with nuclear precision
A fast, multi-threaded filesystem search tool
Built-in sanitization rules for shell-sanitize: shell metacharacters, path traversal, glob, env expansion, control chars
A waiting-queue for multi-pane Claude Code + tmux workflows
CLI utility for filesystem operations
A filesystem abstraction layer for Rust
Rhai bindings for safe disk information access in REX scripts
CLI for the wasi_virt_layer crate
Personal app and dotfile backup manager
Hierarchal file structure core
CLI tool for Content Addressable Archive (CAR) from IPLD
Finds duplicate files
Shared support helpers for komputation CLI tools
Client for the Cicada configuration system
A unified command-line tool for managing object storage with HDFS-like interface
Reverse USB Mass Storage
CLI for creating and managing symlink-based bonds
Filesystem abstraction for Inscenerator
mcp server for filesystem access
make diagram base on system folder size
Disk image and ROM image parser
File system watcher with debouncing and DAG invalidation for hyperdocker
Search for files in PATH
A basic mipmap generator for bevy
Filesystem storage backend for BoardDown
Official WIT interface definitions for VTX Project
Conky like app in Rust
Centralized filesystem path resolution for ZLayer
A blazingly fast file watcher that executes commands when files change
file and directory operations, including MD5 hashing and recursive copying
A CLI tool to list the 5 most recently accessed files in a directory tree, sorted by last access time
Not just gold builds anymore!
A fast TUI disk usage analyzer with treemap visualization, inspired by WinDirStat
A missing utime function for Rust
Walk + watch + filter directory trees. The shared scanner Tauri / Iced / native desktop apps reach for when they need to enumerate user files.
Heavily opinionated glob matching library
High-performance forensic disk imaging tool with verified NTP timestamping and binding hashes
Live Action Search and Replace
跨平台、高性能、兼容性好的文件大小分配库
CLI for OmniFuse — a universal VFS utility
Convert OCI container images to ext4 root filesystems
A recursive, canonicalizing file finding library for Unix
In-memory storage of Rerun entities
command line utility that identifies groups of identical files and displays them to the console
that creates and restores archives to and from S3 or S3-compatible storage. ssstar is specifically designed to stream both input and output data so memory usage is minimal, while aggressive…
File path autocompletion for cliclack prompts
Blazing-fast Vercel Skills CLI, reborn in Rust — full command parity, native performance
Extract exFAT Filesystem specific artefacts from a given Partition
image server that serves random images from a preconfigured list of paths and URLs
Get the filesystem path of a file
Parallel implementations of GNU coreutils (du, rm, cp) for high-performance file systems
manage projects, packages, releases and deployments
Windows file operations utility with shell integration for copy and move operations
A Nix profile manager for use with npins
protoc binary for linux-aarch_64 compiled by Google and bundled in this crate
High-performance S3 file copy tool — concurrent, async, built in Rust
cross-platform get/set extended file attributes
A comprehensive implementation of the exFAT filesystem
fren - file renamer that understands dates (CLI)
robust (recursive) file watcher
dispatcher for Fusio file system
Pure-Rust VMDK (VMware Virtual Machine Disk) reader. Monolithic sparse variant. Exposes a Rust API and a C ABI.
SHV-RPC protocol
Recursive Directory Tool
Sparse ternary VSA holographic computing substrate
Local-first protobuf-only link feed manager (linkleaf.v1) for the terminal
I/O buffering crate, supporting reservation-based reads and virtually-concatenated file handling
Mountpoint S3 main library
File Manager (FranCommanDer) - a text based file manager that combines the best features of Midnight Commander and Ranger
A web server to deliver basic File System informations
RDF data shapes implementation in Rust
A high-performance, latch-free log-structured storage layer built for modern flash storage and multi-core systems
File handling utility functions
µcad Standard Library
Perl module resolution, import analysis, and refactoring — unified facade
Fast comment mark searching tool
Basic file read operation. Returns string with file. The file is either a relative location or passes via an environment variable
create and manipulate excel,power point and word documents
protoc binary for linux-x86_32 compiled by Google and bundled in this crate
working with the NTFS USN change journal and enumerating the MFT
Generate localized XDG metadata for an application
Core library for Tendrils
A crash-safe write-ahead log library with multi-segment rotation and configurable durability
read/write qcow2 image in async/await
Command line tool for Yak
A high-performance checkpointing library for time-travel through directory states
Nydus Image Service Manager
Blazing-fast parallel directory walker with zero filtering baggage
Shell activation and path helpers for the vs runtime manager
— direct libkrun FFI control for macOS VMs
A shell framework for building custom shells
File I/O and serialization for the OxiPhysics engine
burn image models
The awesome supplement for your awesome CLI app
reading btrfs
filetree abstraction based on a sorted path list, supports key based navigation events, folding, scrolling and more
customizable file finder for Rust
FUSE filesystem mount for hashtree content-addressed trees
Staging workspace manager and change store for Trusted Autonomy
module that serves as the cornerstone for generating Rust code from official FHIR (Fast Healthcare Interoperability Resources) specifications. This tool transforms FHIR StructureDefinitions into Rust types…
Distributed filesystem built on an immutable data store with strong encryption and authentication
Filesystem IO for compio
List out block-devices, including disks and partitions
query for file permissions (read, write, execute, removal and creation)
A minimalist `df clone written in Rust - displays mounted filesystems & disk usage
Linter for filesystem consistency: names, metadata, permissions and sizes
Mason-style LSP and developer-tool installer
retrieve system, kernel, and process metrics from the pseudo-filesystems /proc and /sys
backups of files across your filesystem into one location
Local filesystem bundle storage backend for Hardy BPA
JSON to JSON transformation library using the JOLT spec
Lune standard library - Process
An advanced VFS layer for Arbhx
Copy files in the command line with ease
Filesystem-based content-addressed blob storage for hashtree
High-throughput transient container for read-like genomic records
A safe, fast, and modular symlink manager
Write to files atomically
Rust port of voidtools' Everything's IPC SDK. Can be used to search user files quickly.
A zettelkasten CLI that just works and gets out of your way
controlling encrypted ZFS pool datasets
Capability model, sandboxing, and audit for Torvyn
Visitor generator for stable rustc
An actor system exposed as filesystem
extracting hashes from bitmagnet and outputting them to the console
获取 Mac Finder、Windows Explore 窗口的路径
Make large Git repositories feel instant - a lightweight daemon that accelerates Git operations
Memory and context storage provider for Forja framework
Common below code
Rust bindings for liblightdm-gobject-1
Generic, disk-spilling external sort pipelines with pluggable keys, codecs, and deduplication
get workspace root
installing specific versions of clang-format and clang-tidy, used by cpp-linter
Find and create the ~/.dkdc home directory
Media archive verification and long-term preservation system
faster rm -rf
TUI for quickly navigating the file system and previewing audio files
Rika is a lightweight, local-first AI assistant platform
Driver-swappable file storage for the rok ecosystem
Rust macros for creating type-safe filesystem tree structures
Shell, process, and filesystem extension for the Do language
Headless utilities for static file serving: path jail, range parsing, MIME detection, directory listing
Path extension crate for GroveDB
extended cross-platform filesystem notifications
🐻❄️🧶 Official and maintained remi-rs crate for support of the local filesystem
Compress Cargo target artifacts with APFS compression on macOS
DragonOS Application Development Kit DragonOS应用开发工具
Rust client for go-license verification system
dart inspired high level abstraction to interact with io operations
Gamecube ISO unpacker and rebuilder
CLI crate for nils-git-lock in the nils-cli workspace
Defensive guardrails for AI coding agents — block destructive commands via hooks
Filesystem lattice types for KeyLeLuYa, extending propagators-chirho
The cli for managing the Code0-Definitions
The package provides means of managing temporary files and folders
A tactile terminal task app for fast capture and triage
supporting various backends in rustic-rs
FUSE filesystem with atomic branching for speculative execution
Various utility routines used in the rust programs I have written
files as locks, forked for use in Arti
gitoxide project dealing paths and their conversions
Convenient extensions to the standard library's path types
Interactive egui treemap viewer for dumap
Prevent cargo installs without --locked
Terminal UI for Arc Academy Terminal - interactive shell learning interface
macOS DMG disk image stage for anodize release automation
Filesystem source adapter for ECL pipeline runner
Interactive Search Tool
async, persistent key-value store for Rust, backed by SQLite and designed for extensibility with other storage backends
A temporary sandbox for testing file system and process operations, with fixtures support
concurrent disk-backed cache supporting efficient direct file I/O, transactions, and snapshots using file cloning and sparse files
No-std implementation of ISO9660 filesystem
Scan and list GitHub permanent links (blob/<sha40>) in your source code
Host CLI for serving smoo block exports over USB
working with image paths
Print the most recent Claude Code session for the current or selected workspace
The sync layer for Arbhx
A fast tree command with gitignore support and flexible filtering
A task tracker to help you and your agent write robust, reliable code
Type-safe serializable and parsable string keys and values for pict-rs
The FTP layer for Arbhx
Push Claude Code usage and disk stats to GeekMagic SmallTV displays
Find all owners (user and group) inside a directory tree
clean up your development environment
Read, write, and seek within a portion of a file as if it were itself a standalone file
converting documents using LibreOffice
allows you to create a BTree index backed by temporary files
Command-line tool to find build artifacts and thing occupying space on your computer. Shatters records not glass.
Filesystem-backed content-addressed blob storage adapter for the Cloudillo platform
Aliyun OSS SDK
Shared configuration library for all Vomit project tools
This exhume module is proposing Apple FileSystem Parsing
Access the illumos Doors API from Rust
Types used by the notify crate
Platform-aware path defaults for taskers
TeamDman's Master File Table CLI and library for NTFS
tools for IBM Storage Scale file systems
node_modules/ package manager and utility toolkit
node_modules/
ScriptFile bootstrap plugin for Drasi
Fast, cross-platform CLI for finding and removing duplicate files by content hash
cli application for copying text file contents to the clipboard on wayland based systems
Finds a file by walking up the directory tree
Prompts the user to pick a file interactively from the current directory
A lightweight background process manager
A beautiful CLI tool for analyzing disk space usage with rich terminal visualizations
Advisory cross-platform file locks using file descriptors with async support by spawning blocking tasks
Набор инструментов для работы с директориями
Quantum-resistant token system for KeyLeLuYa — balances as propagator cells, transfers as Forge gears, sigchain as ledger
Small utility to delete files older than a certain amount of days
libfs is a library of file and filesystem operations that is supplementary to std::fs
libfs
Session history management: persistence, indexing, locking, and snapshots for OpenDev
Platform-agnostic virtual filesystem logic for Hexz
Diff two directory trees based on their content
Allows you to quickly and easily calculate the size of all files even with deep nesting
A custom target runner for Rust-based operating system kernels
Nydus Image Service
Sanitise filenames for use on NTFS filesystems
Tauri 2 plugin for ambient-fs filesystem awareness daemon
Find the path to a Linux application icon by name and resolution
I/O abstraction layer for rustyhdf5
Signed attestation manifest format for aegis-boot USB sticks — serde types + JSON Schema
Assorted utilities for filesystem operations used in SpacetimeDB
Filesystem walking and filtering used by scanner-core
Lightweight, high-performance core types and utilities for coding tools - framework agnostic
A modern, high-performance alternative to the Unix tree command
Storage extensions for SIMD R Drive
humans and machines deal with the OSH directory standard: https://github.com/OSEGermany/osh-dir-std
Alpha-quality backup program
package manager built on static linking
Yazi TTY access layer
binding for LSPlt
pretty incredible shell
File System Operations
Manifest data model, YAML parsing, and import resolution for east
A 9P client library for Rust
Core domain logic for seal — events, storage, projection, SCM
Scan the destination folder and make a hash of all files to get the current state of the directory
Verification engine for supersigil spec documents
A secure filesystem sandbox. Restricts paths to a root directory, preventing traversal attacks.
creating temporary directories that are auto-cleaned
A pure-rust USTAR implementation for OS-dev
Modern, safe, and ergonomic memory-mapped file I/O library with zero unsafe in public API
Build utilities for oxidros ROS2 message generation and FFI bindings
Lune standard library - Stdio
file listing tool
MIME multipart parsing, construction, and streaming compatible with hyper v1.x (fork of mime_multipart crate)
A type-safe, user-friendly proc macro for embedding a file tree into your code
Extract GPT and (E/M)BR partitions from a Body of data
Pure-Rust VHDX (Microsoft VHD's modern successor) reader. Used by Hyper-V and WSL2. Exposes a Rust API and a C ABI suitable for FFI from C/C++/Go/Swift.
Format-agnostic data extraction from disk images and other potential data structures
reading BLP texture files (BLP0/BLP1/BLP2)
Professional archive and digital preservation system for OxiMedia
The filesystem of ProkaOS, which is light and simple
Wasm engine abstraction and ComponentInvoker for Torvyn
The project is a Rust library for indexing and retrieving file paths within a directory tree
wrapper around valida executable - zero-knowledge virtual machine
valida
Windows MFT-based disk usage scanner that produces .heft files
Extended with additional methods for files and directories
Vfs for reflexo
Force-remove a file/directory and all descendants
tiny low-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows and macOS by leveraging the mechanisms defined…
A FUSE filesystem providing variant symlinks that resolve based on process environment variables
Vfs for tinymist
Anthropic CMA-Memory drop-in compatibility shim — mount, mirror, export the Markdown-tree filesystem-of-memory beta announced 2026-04-23 (v0.4.1 P0-2)
A CLI tool for toggling code comments across multiple languages
File manager for the Noir compiler
Core library for synchronizing volumes in the background
implements the TrimmablePath trait on anything that implements AsRef<std::path::Path> so you can easily obtain the last *n* parts of a path
Core library for dirgrab: concatenates file contents from directories, respecting Git context
Variety of functions that std does not offer or std offers but are not satisfiable
std
Extract NT Filesystem specific artefacts from a given Partition
External dependency resolution for LevitateOS build - handles Linux kernel source, Rocky ISO, and installation tools
Built-in tools for agent-diva
Core storage library for All Our Things — shared across MCP server, iOS, and Android
Build complete Armature applications in Rhai scripts
CLI tool to upload and delete files to and from your Supabase project
Lune standard library - FS
OpenDAL Gateway
Filesystem common utilities
Mount FTP servers as local filesystems
This exhume module regroup all of the parsers maintained by the community to parse and extract artefact in a standardized way
A small rust library to copy files/folders from the project directory to the output directory
stable interface for programmatic administration of ZFS
execute commands through a web interface
Copy directory trees
FormCalc expression interpreter for XFA dynamic forms. Experimental — part of the PDFluent XFA stack, under active development.
Widgets for promkit
CLI: the viable system launcher and subcommand dispatcher
TUI for minidex
the fast and minimal dependency development tool for rust language
Checksum stage for the anodize release tool — generates SHA, SHA-3, BLAKE2, BLAKE3, CRC32, and MD5 checksums
Google Drive Client (Rocket) for api rest
low level blob-based I/O library
Storage backends and block management for IPFRS content-addressed system
Unified API for reading directory jumper databases (zoxide, z, autojump, fasd)
An ultra-lightweight, fully offline desktop client for Vortex Series mice
Capability-based temporary directories
Python 2.7 bytecode deobfuscator
Recursive directory walker
Shared Perl source file classification helpers
Platform-native sandboxing (macOS/Linux) and permission management for Uira
Secure workspace-relative path normalization
Student AI4OSE lab easy-fs crate for Chapter 6 hard-link support in rCore Tutorial
Low-level bindings to the libsqsh library
A small parser for meson.build files
Ambient filesystem awareness daemon
The Arbhx OpenDAL layer for Rust
Generic log watching, filtering, and optional TUI
Finds and annihilates duplicate directories
copy MumbleLink of Guild Wars 2 by running in wine and copying it to linux filesystem for native access by linux apps
MIME multipart parsing, construction, and streaming
protoc binary for linux-s390_64 compiled by Google and bundled in this crate
A fast, parallel, multi-algorithm directory hasher
Shared ignore rules for workspace traversal and filtering
monofs is an immutable distributed file system
monofs
A command-line tool to generate hash values for files. SHA256 and MD5. Output and Error messages in JSON format.
Versioned artifact storage for swink-agent sessions
CLI todo tracker written in Rust
Terminal UI for agent-team-mail: live streaming dashboard for AI agent teams
managing surrealdb migrations
A modern replacement for ls command with rich features and beautiful output
An OS and architecture independent implementation of some Unix filesystems in Rust
Betfair / Prediction Market Exchange
Project dependency management for multiple package ecosystems
S3-compatible object storage sync for the Harmonia agent
save project structure and contents to a text file
Abstraction for the std::fs stdlib
Infinity Engine Mod Installer is a tool designed to automate the installation of mods for Infinity Engine games such as Baldur's Gate, Icewind Dale, and Planescape: Torment. It uses a file called 'weidu…
download and install the latest Discord version to resolve update issues
Yazi shared library
A test-friendly single process file-based storage backend for apalis
storing and retrieving files according to XDG Base Directory specification
A fast and reliable alternative to rsync for synchronizing local files
Dump crate for below
Hybrid ISO+UDF optical disc image creation (UDF Bridge format)
ordered, atomic storage without durability guarantees
Stupidly simple crate for backing up files and directories
working with file trees
a cloud disk sync tool
asset bundler for Rust
Remote workspace client implementation for Steer
A wrapper around Rust API for getting file metadata
Configure your application in a friendlier and more consistent way!
JSON registry and HTTP fetcher adapters for rx
A caching mechanism for downloading and storing files from URLs
interacting with XISO/XDVDFS images
Rust Aliasing Directory
Command line application for managing and searching tags stored in filesystem extended attributes
A multirepo management tool
file processing
Low-level ioctl wrappers for composefs (fs-verity, loop devices)
integrity checker for backups and filesystems
processing .imf files
A UI toolkit for Leptos
Stable extension contracts and compatibility harness for Fierros
More ways to rename files
A kubectl version managing shim that invokes the correct version of kubectl or helm ☸
the best library for OS API's manipulation
react native or nodejs package manager
OpenHarmony's fileuri binding for rust
High level CCSDS File Delivery Protocol components
JSON-RPC framing and thread-backed transport helpers for corsa-bind
working with numbered file sequences
in creation of sandbox environment
Terraphim persistence layer
Automates moving files into a stow directory then using stow to create symlinks back to where the files came from
Core scanning engine powering scanner-core
A CLI for a file-system-based commit log
Generate a migration path to ruff from anywhere
Create original ext (pre-ext2) filesystem images
SecretEnv — local filesystem backend
A blazing fast, content-aware, and atomic file organization tool with undo support
tracking file accesses of processes
NFS3 client
Codec utilities for the Cell distributed computing framework
CLI for reading BackupPC pool files (contains a FUSE file system to mount the pool)
WAE Storage - 存储服务抽象层，支持腾讯云 COS、阿里云 OSS、AWS S3、Google Cloud Storage、本地存储
A versatile, cross-platform command line file size reporting executable with default recursive file system traversal
rspack watcher
Composable file existence requirements with nested AND/OR logic and duplicate-term protection
A custom themes system plugin for Tauri v2 apps
File system watcher with auto-reindexing for cartog
CLI tools for searching and managing git repositories
Declarative GUI structure language and CLI
Template-driven dotfiles bootstrapper for macOS
A basic tree-like representation of a specific directory
work with block devices. Formatting, getting device info, identifying type of device, etc.
interacting with FUSE with async Rust
libhdfs binding library and safe Rust APIs
Change Data Capture with per-shard ring buffers and subscriptions for Kōra
🧤 Alfred - A blazingly fast CLI tool to automatically organize your folders
Filesystem connector for Trusted Autonomy
CoW-accelerated git worktree hydration
Read files or directories from the filesystem at runtime on debug, embed on release
Canonical Rust Tigrbl spec IR and datatype model
Memory-mapped file I/O for rustpix
Ready-to-use tool implementations for the mixtape agent framework
Rust nom parser to read FAT file systems
Output record types and rendering helpers used by scanner-core
A super flexible library for parsing FAT file systems
An example generated using the simple template
OpenZFS replication tools
(WIP) Extremely flexible filesystem sandboxing
Tiny lib for disk space info of os file system (cross-platform)
API bindings, CLI client and FUSE filesystem for Wiki.js written in Rust
A fast, no-frills file archiving tool that copies files to remote servers via SFTP
A Rust-powered CLI tool to organize and curate files in macOS directories
A pretty ls-like command for listing files
Edgeless Package Tools
Filesystem adapter for entertainarr
More optimistic file utilities
A custom binary database
Resolve the underlying block device path from a file path or file descriptor
Code fact extraction and storage library
SDK for the Aerol.ai MicroVM sandbox API
A zero-dependency Dynamic Time Warping (DTW) library for Rust
A small lib that help to serialize and deserialize from/to rmp (RustMessagePack) with a file
Ergonomic blue noise (poisson disk sampling) for the masses
Query direct I/O alignment requirements for a filesystem path
IPFS repository management - datastore, keystore, and identity
Lightweight, high-performance Rig framework Tool implementations for coding tools
Perceptual hashing utilities used by scanner-core
Surfer waveform integration for kiln
Deterministic fitness checks for your codebase
Local API server for audiflow smart playlist editor
CLI for GraphGarden — crawl a site and generate its protocol file
Block device trait
Use Google Protocol Buffer compiler (protoc) with your closure code
protoc
[FORK]Apache OpenDAL™: Access data freely, painlessly, and efficiently
Test artifact changes locally from multiple projects that already use gitlab-art
Zsh interpreter and parser in Rust
The interpreter for the Stackathon language
Per-key lock manager for concurrent file access
Command-line utility for managing LUKS encrypted volumes using 2FA methods (for example Yubikeys)
Build SQLite virtual file systems (VFS) by implementing a simple Rust trait
A POSIX-compliant shell implemented in Rust
Rust logging client for Bugfixes with optional remote reporting
Calculate recursive blake2 digest for path or directory
High-performance Rust library for moving structs to/from disk using Parquet format. Abstracts complex Arrow/Parquet usage while providing batch writing and parallel reading capabilities for maximum performance.
file size plugin of farm
Rust bindings for libStorageMgmt
handling .srt subtitle files
Cross-platform xattr support
Ultra-fast Git change detection library with zero-cost abstractions
Virtual filesystem implementation for eryx sandbox
Gemfile support for deps-lsp
a system controller for linux disk space management
Rust bindings to the NBDKit framework for creating Network Block Device servers
Forked from official ceph-rust. Async pr from jcsp was merged. A rust-lang specific interface to Ceph librados and Admin Sockets. You can create a Ceph development environment with the…
Local-first protobuf-only link feed manager (linkleaf.v1) library
Core library for hard-sync: file sync engine, drive detection, config, and watch mode
AWS SDK for Rust - Amazon FSx @ 2018-03-01
Cryptographic accumulators for the Webnative Filesystem
A version manager for the BYOND environment
Safely turn Czkawka duplicate reports into space-saving symlinks
building a custom SQLite virtual file system (VFS)
File system scanning engine for gravityfile
A fast version of the rm command
通过文件扩展名猜测 MIME 类型，使用 PHF 实现 O(1) 查找
Local storage primitives: platform-agnostic paths, ACID file/dir storage, atomic IO, format dispatch
help working with the filesytem
Raw disk I/O for the disktest crate
Safe Rust wrapper around the util-linux/libfdisk C library
util-linux/libfdisk
Block reader for ISO9660 file contents
MCP server for cross-platform trash/recycle bin operations
XML navigator and interactive filter with XPath-like queries
Run clang-format and clang-tidy on a batch of files
Fully serializable on-disk datastore for time data
NFSv4.1 server daemon powered by embednfs
help with activation and deactivation of a conda environment
pre-commit implemeneted in Rust
enter a directory in one command
AWS S3 Inventory-based backup tool with efficient incremental & versionId support
Watchexec filterer component based on globset
platform agnostic path representation
AI-powered git commit message generator using OpenRouter API
captures hashes and metadata about a tree of files, and can later verify these hashes and metadata to determine if the files have changed. It supports incremental updates, and includes an standalone…
A package for writing and reading from/to JSON, Data Structures which implement serde's Serialize and or Deserialize
inotify bindings for the Rust programming language
PAVED documentation tool - structured docs optimized for AI agents
Yazi image adapter
mkdir -p
Zero-copy RFC 3986 URI parser with URN support built on oni-comb-parser
Filesystem discovery and hashing utilities used by the skrills MCP server
The spacetimedb directory structure, represented as a type hierarchy
A high-performance, cross-platform glob/pattern matching library for filesystem search with advanced pattern support and metadata filtering
conveniently watching and handling file changes
barebones Rust framework for creating and serving a 9p filesystem
Configuration facilities for Crankshaft
An encrypted file system that mounts with FUSE on Linux. It can be used to create encrypted directories.
Backup and restore tool for syncing files to AWS S3 with native zstd compression
Shared protocol types for KeyLeLuYa encrypted filesystem
Transforms one serialization format into another
Storage helper functions
generate a Johnny Decimal system for Obsidian and your Documents folder
Expanded options for interacting with files and directories. Creating/copying/moving etc. File manager, only inside Rust 🦀
A zellij session manager with zoxide integration, inspired by tmux sesh
Read input from stdin or file path, designed for clap CLI arguments
LSP-focused clients, overlays, and virtual documents for typescript-go
A Koto library for working with temporary files
Deterministic OLSRv2-class link-state routing engine for Jacquard
Git-based workspace synchronization library
Routing model for apimock: rule sets, request matching, and read-only views for GUI tooling
port of pydupes. Super fast.
An async virtual filesystem interface
Protocol messages for the zccache download daemon
sandboxed code execution
The type-safe wrapper around mount system call
Fast developer tools: fexplorer (file explorer) and px (project switcher with fuzzy search and frecency)
File system adapter for TT-Sync manifest scanning and atomic I/O
FFI bindings to the libicsneo icsneoc2 C library
Metadirectory repositories
loading and executing PE (Portable Executable) from memory without ever touching the disk
Organize your sway outputs
Common types for the Webnative Filesystem
Clean all build caches on your disk!
Shared filesystem operations for PanEx
A fast, cross-platform file system cleaner for removing recreatable folders and cache directories across different operating systems
digitronic protocol dwh
Blazingly fast file search library built in Rust
Helpers for denort
fast windirstat clone for macos
Serve encrypted files via local FTP
Filesystem operations for loq - enforce file size constraints
A CLI and library for generating structured YAML representations of directory contents, optimized for efficiently sharing codebases with LLMs
Terminal user interface for gravityfile
CLI for mounting FTP servers as local filesystems
MCP filesystem server with sandbox security based on cap-std
A modern replacement for cp command with progress bar and advanced features
SQLite + object storage backend for blob data
providing file system specific utilities to gitoxide
gitoxide
Node.js project support for changepacks (npm, pnpm, yarn)
File Aggregator is a utility for aggregating and distributing file contents. It allows you to combine file contents from a specified directory into a single text, which is copied to the clipboard…
An in-memory file system that can be used to compare different deduplication algorithms
File operations engine for gravityfile
Command line utility for renaming files in batch using regex with advanced control
Minimalist BTRFS periodic snapshot tool
A high-performance deduplication tool
Rust reimplementation of pidfile_* functions from libbsd/libutil
Rust wrapper for FEFF10 X-ray absorption spectroscopy calculations
Official Ceph-rust. A rust-lang specific interface to Ceph librados and Admin Sockets. You can create a Ceph development environment with the Chef automation tools: https://github.com/bloomberg/chef-bcs…
overlay filesystem that stores ownership and other file metadata in a text database and presents that view to processes running as root, while the actual files are user-owned and can be versioned in git
Filesystem prelude for entertainarr
FlashKraft — OS image writer terminal application (Ratatui TUI)
In-memory node profile and node state builders for Jacquard tests
Collection of utility functions to work with files
Built-in tools for the agnt agent runtime — filesystem, search, fetch, shell. Sandbox-aware.
Copy-On-Write Rust implementation
Content-addressable on-disk store for Git LFS objects
A powerful, cross-platform file organization tool
Convert bmap images to Android sparse
FUSE filesystem implementation for S5
File listing and asset discovery utilities for tokmd analysis
parsing mount points on Linux and other Unix systems
written in rust, terminal-based disk usage analyzer
Fast disk usage scanner with mtime tracking
In-memory link profile and carrier implementations for Jacquard tests
File tagging library for Linux targets
Cross platform md5 based file deduplication tool
embed images into mp3 files
Filesystem PCloud adapter for entertainarr
Tree command to generate file system tree structure snapshot in JSON
wrapper around the InsightFace library to perform face comparison
Virtual file system with fault injection for Vortex simulation
fuse3 integration for Apache OpenDAL
lwext4 in Rust
Catbox.moe's API
grep-like CLI tool
CLI for parsing, checking, and loading .env files with DotenvPP
Build scripts for building netCDF from source
netCDF
Create, manipulate, and transform Linux package formats!
tiny, nostd, ~50kb http server/library
Trait and envelope boundaries for Rust atoms, handlers, engines, and callbacks
FUSE for AliyunDrive
PLATO cognitive architecture component
Path utilities
Common utilities for toolcraft ecosystem
A shell🐚 by the beach🏖️!!
Thin wrapper around disklru for filesystem integration
The btrfs debugger
A unified async storage abstraction layer for Rust, supporting various storage backends and cloud platforms
Read and write on Ext2 partitions without mount
A flexible backup library with trait-based file handling, compression, and encryption
Simulated I/O implementations (network, storage, clock) for Vortex
A high-performance, cross-platform file search engine library with REST API
A CLI tool to switch between directories
Resolve project origins and kinds from a path
Experimental: Live, file-watching daemon for cast::*! annotations — maintains an incremental concept graph and exposes a query socket for LLMs and editor tooling. Peer to cast-extract;…
IF Filsystem-event Then
A universal installer for many languages so you don't have to remember any command
Suck the InTernet
Plow: A package manager for ontologies
The high-level/low-level implementation of Linux Fanotify
open and write dotThz files in rust
Local-first review terminal for deterministic, inspectable, constrained repository analysis
💾 A command line disk usage information tool: disk usage (foreground), inodes (background)
realpath() (with some extensions) for *nix systems
interface framework to build scalable, flexible and recoverable interfaces
IPC protocol types for Infolyt
bookmark tool
allows you to build your changelog from a collection of independent files. This helps prevent annoying and unnecessary merge conflicts when collaborating on shared codebases.
exploring container images without launching a container runtime
CASC (Content Addressable Storage Container) implementation for local game file storage
ostring base crate include some basic function
fast file organizer written in Rust
Additional functions wrapping Rust's standard library
WAL contracts and adapters for Photon
Quickwit's storage abstraction
Your crypto portfolio and terminal together at last
ckg — shared filesystem and process helpers (secure dir create, chmod, symlink, has_command)
A file abstraction system for Rust
" This crate provides utilities for reading and writing RIFF formatted files. A fork of the original library that provides an option to either eagerly or lazily read into the file
RFC 8966 Babel distance-vector routing engine for Jacquard
CLI todo app
Filesystem watching implementation for Rolldown
Relative path type that statically prevents .. traversal
..
Spec-faithful classic BATMAN next-hop routing engine for Jacquard
Set filesystem timestamps
Rew OPs
A high-level package for dealing with accessing the Noosphere
LD_PRELOAD library for onelf execve interception
Linux game saves and configurations backup manager for CLI enjoyers
Directories used by Sequoia
etcd precompiled binaries bundled into a crate
read and write VASP POSCAR files
Common testing shortcuts and utilities reused across projects
Filesystem catalog for the unofficial Iceberg table format implementation
Tiny async persistence helper: atomically store/load a single typed value using postcard + serde (cross-platform config paths)
A polite and user-friendly downloader for Common Crawl data
Filesystem++ : Access the filesystem in a cleaner, easier way
Core library for dodot dotfiles manager
store a file's metadata for caching purposes
bi-directional synchronization
Temporary trees of files
A small library to help find installed Rust components
Disk Mosaic is a disk utility helping you to identify biggest folders
Dbus implementation
inspired by libostree, but based on distribution repositories
PawKit's filesystem module
Miscellaneous I/O utilities
upgradeable ACID one-shot files
Asynchronously execute shell commands in filtered subdirectories
Metrics and data collection from LLM systems
Native desktop platform integration for Fret
Format detection helpers used by scanner-core
Template management and installation for Ito
by non-WASM Maelstrom libraries and binaries
A modern container file library, useful for quickly building your own binary file formats. A file system in a file, focused on performance and ease of use. C and Python bindings available.
Filter and write trees in Git's object database
with_paths! macro, for joining paths ergonomically and without allocation
XSLT Component for rust-camel (via xml-bridge)
Convenience library for rapidly processing string-type paths
P2P platform for publishing content, self-hosting, decentralized curation, and more
Tool implementations for bash and file operations
Lightweight vendoring of static assets. No node_modules, no runtime fetching.
Isolated symlink layout linker for Aube
A pipe reader and writer for the terminal. Made for use with the ipipe Rust library.
decoding Windows file system elements attributes constants
Two-panel file manager
Virtual File System and Capability sandbox for Astrid agent runtime
Convert Windows to WSL paths and vice-versa
A file deduplication utility
Semantic index pipeline for Synwire VFS providers
Shared C header types for the truce AU shim
if-it-compiles-it-works solution for safe Rust paths with abs/rel and file/dir variants for API safety and cross platform support
Generate a Rust project from a local Liquid template. A stripped-down version of cargo-generate.
Rust rewrite of the incredibly useful but abandoned incron software
XMPP console client written in Rust and inspired by Profanity
A comically fast way of indexing and querying your filesystem. Replaces locate / mlocate / updatedb.
Symlink-safe path extension for parent directory
Compare and contrast directories
Rew Permissions
File-centric, event-sourced version control system with implicit branching
File storage for Oxidite with local and S3 backends
fast and easy tmux workspace opener
A cross platform library for listing and manipulating holes in sparse files
A header based system for writing and reading binary files using its own format
HLG, or HI, Let's Go!, is a powerful bookmark manager to keep track of your favorites both on the filesystem and the web
The local FS layer for Arbhx
A high performance tool for summarizing large directories or drives
sshenv shim generation and bindings file I/O
Rust SDK for Sakura Internet API
The package allows for scanning directories in parallel
project provides a set of scanners that will use regular expressions to try and detect the presence of sensitive information such as API keys, passwords, and personal information. It…
Read information from EXT4 filesystem images
tensor file system format
A WebDAV server that enables direct access to IPFS MFS as a mounted drive
Rust build-script dependencies generator for data/IDL files
Reader for Human Readable Archive (.hrx) data
handling single-dimensional array data. It uses mmap and avltriee.
URI routing for dsq I/O plugins
sequential data file
Find a file or directory by walking up parent directories
Repo-based clustering and curated/suggested workstream file management for shiplog
CLI-first backup solution with content-addressable storage
Creates a temporary file which can then be committed to a final path
Tauri-based GUI for FileLuYa encrypted filesystem
WebAssembly fuse bus interface
Concurrent HDF5 and NetCDF4 reader (experimental)
Semantic analysis model for shell scripts with scopes, bindings, and dataflow
find font by file name
A LabView TDMS file parser written in Rust
File system layer for ripsed — discovery, reading, atomic writes
A command line tool to remove temporary files created during (La)TeX compilation
Append-only on-disk storage with integrity checks and radix tree indexing
MIME type lookup, detection and reverse lookup CLI tool
Rust API for OWFS (1-Wire file system)
Temp fork with Sys impl of which crate until a new version is published
Iron OS Packages Api
Pure file tree snapshot helpers for merge, flatten, reveal, and lookup
Pack codebases into Markdown bundles and expand them back into files
Rendezvous data staging and large payload transfer for velo
Fast, minimalist, and POSIX-compliant recursive directory traverser with zero external dependencies
Create Kubernetes SealedSecrets with a single secure command
Defines the goldboot image format
recursive readdir
A toolbox for the docufort crash fault-tolerant append only file format
Extension methods for the openat crate
Filesystem backend for objstore
write a stream to disk while adhering usage limits
homemaker. Slightly more than yet another dotfile manager.
Deduplicating, encrypting, fast, and tamper evident archive format
deduplicate backups. It builds a hash tree of all files and folders in the target directory. Optionally also traversing into archives like zip or tar files. The hash tree is then used to find duplicate files and folders.
Tools for easy cd
Split text into multiple files by line
Watchexec filterer component for ignore files
generating semi-random file names
Alternative to Pathname
Orbtk frontend of Czkawka
ISO 9660 / ECMA-119
bumv (bulk move) lets you use your favorite editor to rename files
Read S3 object like local files with byte offsets
Low-level system primitives for luff
Recursively walk a directory
A high-performance Rust-based disk cleanup tool that finds duplicates and storage outliers
VM Operations Job Protocol specification and types
managing and locating Java installations
Easily manage paths in rust. A straight-forward no bullshit crate to manage paths. Either you get what you want, or you dont.
Intelligently rename PDF files using local LLMs. Supports multiple languages, automatic translation, and meaningful name generation.
that resolves ELF dependencies without loading and executing them
Rust-native LLM agents & chains with resumable ReAct workflows
A WebDAV fuse file system daemon
👏 Auto-propagate Cargo.toml infos (name, version, author, repo) into app
Tools for calculating light paths in the atmosphere
Provide a uniform async interface for file loading between desktop and browser
File System Plus is a package that provide create, update and delete operation on file syteme
CLI tool that compares two directories by hashing all files. It reports which files are in the 'right' folder but not in 'left', regardless of how things were moved or renamed. Great for…
Views of cap-std's Dir
Raw bindings to WinFSP
MAVIS Differential Astrometric Calibrator
interacting with Silkroad Online's pk2 archive format
A command-line utility for data processing and delivery at the Single Cell Biology Lab at the Jackson Laboratory
Find and delete duplicate files
A fast, tiny system fetch utility
Shell VFS daemon for Do language integrations
A command-line utility that provides intuitive and efficient file management capabilities, mimicking the familiar “copy,” “cut,” and “paste” operations found in graphical user interfaces
Thin wrapper for common oneiros file system operations
Build, mount and extract PuzzleFS images
Work with nvlist and nvpair (using nvpair-sys, libnvpair.so)
a file system based router for rust
parse Apple HFS/HFS+/APFS FinderInfo attribute
Manipulate files en masse using patterns
Search your filesystem semantically
An ergonomic way to search for files
TUI frontend for diskard
Copy-on-write filesystem snapshots and rollback for OpenHawk agents
A fast POSIX ls that doesn't require a libc
A fuse-based read-only filesystem to provide a snapshot view (tar archives) of directories or files without actually creating the archives
Lua checker on mlua — undefined variable/global/field detection with LuaCats support
A plugin-based disk space cleaner for developers
An interactive Rust CLI tool for disk usage analysis
ProcessFork world layer: filesystem (overlayfs / APFS), env, in-flight processes (CRIU), browser DOM (CDP)
Single writer, multiple reader in-process file sharing
Asset and dependency-report enrichment for tokmd analysis
embed images into mp3 files (forked, updated and extended api)
A Django storage clone for Axum - unified storage backend abstraction
FSCC (File System Control Codes) implementations for smb-rs
smb-rs
Linux package tester
Tar-like archive utility that creates and restores tar-compatible archives to and from S3 or S3-compatible storage. ssstar is specifically designed to stream both input and output data so memory usage is minimal…
A read-only FUSE filesystem for mounting compressed archives, inspired by archivemount
(Incomplete) implementation of ISO9660 filesystem
Amazon EFS emulator for AWSim
Fast file counting on HDDs
AVL Storage - S3-compatible object storage optimized for Brazil and LATAM
A fast and lean replacement for the find command
Extension types for the ActivityStreams crate
rclone sync on ratatui
Wayland screenshot tool
Bindings to Ledger C SDK
A duplicate file finding utility library that supports directory recursion, multiple directories, and specific file duplicate searching
Extended standard library for SourceTrait Common
Create filesystem fixtures fluently
managing application data directories, including Windows, macOS, and Linux
A logger for Rust that's *actually* easy to use
A tiny utility that generates a file representing the structure and content of a directory. Made to easily give context to a LLM.
Core runtime adapters and settings for buildfix embeddings
A micro-library for downloading from a URL and streaming it directly to the disk
Rust wrapper around libzfs-sys
NFSv4.1 protocol types and XDR encoding/decoding
Host-agnostic file watcher event normalization and batch coalescing
A cross-platform mkdir command with enhanced features
Extended Attributes API bindings for Rust
A lightweight i3/sway status bar written in Rust
Policy-driven path relation and rename remap helpers for workspace runtimes
SQLite extension for the Do language
nvgt/fldrs/qckly
A natural API for handling OS-specific user or system directories, including iOS and Android
Traverse a directory recursively preserving compatbility with the standard library
A lint running tool and framework
Noir's package manager
A command-line tool to read and format file contents, with clipboard support
Rust client for WFS
Capability-based version of the Rust standard library
Language-agnostic plugin system for gravityfile
Reads fonts in passed directories and return objects of fonts for Figma Font Helper
Rjango staticfiles contrib application
Core font management library for fontlift
that implements pushd
Embed the nu engine in your rust application
Rust-friendly wrapper for Dokan (user mode file system library for Windows)
Serialize and expose data, one file per field
easy helper utilities for short command-line programs
Rust wrappers for libparted
A fast and feature-rich file manager written in Rust
error definitions for the ringest framework
A bounded multiprocess cache of files on disk
Blaze as a library
Filesystem I/O plugin for dsq
CLI tools for interacting with the Gitea API. Mainly for attaching files to releases.
Blazingly fast file search library built in Rust. Forked due to abandoned project.
Iterator adapters over a reader that yield fixed-size chunks at a time
csv and zip maker
A cross-platform Rust library for managing system shell icons
Utilites for working with the file system. Part of Bomboni library.
A content-addressed backup system with deduplication and compression
database of sectors
file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…
WebDAV protocol handlers for nzbdav
Recursive directory traversal file management tool
Macros for reading in the lines of a file at compile time
A top-like tool for bcachefs statistics
Wrapper around the crate 'ureq' to make downloading files easier
Convert tree-formatted text into filesystem structures
way to download and cache files
Set Git attributes via code, or from the command-line
A wrapper around openat, symlinkat, and similar system calls forked and improved from https://crates.io/crates/openat
A better youtube-dl/p CLI interface
version-release-test
Cross platform single glob and glob set matching. Glob set matching is the process of matching one or more glob patterns against a single candidate path simultaneously, and returning all of the globs that matched.
A disk cache for Wordchipper downloads
Ceph disk safety removal tool
compare two direcories or two files asynchronously
File rotation from standard input
A lightweight, single-binary conda bootstrapper — powered by rattler
Easily resolve tilde paths and relative paths
Capability-based standard directories for config, cache and other data
FUSE driver using MangaDex API
Versioning filesystem for sqlite database. This is a placeholder but the project is real
Operations on the filesystem
A professional, zero-dependency web-to-app engine for Rust
Create an excluded from cache directory atomically
Drop-in Docusaurus CLI with Rust-native config (docusaurus.config.rs)
A pleasant file system API
Thread Safe Current Working Directory
search files and folders based on the name pattern (regex, wildmatch, exact)
Fob bundler - Rolldown-based bundling on top of fob foundation
Paranoid filesystem monitor which reports malfunctioning mountpoints
easy file system
Filesystem operations for the Harmonia agent
The API for traversing sibling directories (find next/previous directory)
10x lower latency for cloud-native DataFusion
Automatically track how you are spending your time by watching the file system
A CLI system information tool written in Rust
overlaying directory trees on top of each other
Publishing pipeline for Diaryx workspaces — converts markdown to HTML
Core library for the skrills MCP server: discovery, filtering, manifest generation, and runtime control
A CLI tool to scan folders and catalog files by extension
A lightweight Windows utility for determining if two paths reside on the same storage volume. 轻量级 Windows 工具库，用于检测两个路径是否位于同一存储卷。
Sandbox orchestration for evalbox
Clean up files & folders
PackGuard Page Actions engine: generates prioritized remediation actions from the store + policy + intel, with dismiss/defer persistence
removing files in a secure and efficient manner
Bundle manifest and profile-scoped zip writer for shiplog run directories
A fast, lightweight TUI for interactive directory tree navigation with file preview and fuzzy search
FFI bindings to lwext4 - a lightweight ext2/3/4 filesystem implementation
The foundation tools to build Nushell commands
tiny low-level command line application that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows, macOS and Redox by leveraging…
Unified File System
Shared protocol and filesystem helpers for es-fluent runner crates
file-system forensics
A small path tool works for calculate absolutive or relative path
Core library of Pijul, a distributed version control system based on a sound theory of collaborative work. Fork maintained for the AT Protocol ecosystem.
Jack of All Trades Master of None
Terminal log navigator
An async implementation of which
which
TUI file tree for usage with terminal text editors
querying Algerian education dataset
Lightweight terminal file explorer and disk/storage manager for macOS
CLI utilities for N5 files
dynamic library (dylib) handling
Cli tool to copy photos with optimizations
Test utilities for claude-api: cassette-based replay of recorded HTTP exchanges
high performance directory walking using libc fts
Filesystem storage provider for LLM Kit
A CLI utility and rust crate to atomically swap the content of two paths
Strategy-based project root and name detection for oneiros
A lightning-fast, lightweight command-line tool for creating efficient directory snapshots
Some common utils
FFI bindings to libykpers
OpenDAL plugin for spring-rs
IPFS Mutable File System (MFS) - familiar filesystem interface over IPLD
A command line tool for working with Linux extended attributes (xattrs)
Fast, cross-platform disk cleanup tool with interactive UI
Metadata extraction helpers used by scanner-core
Implements a simple rotating file handler
Stream-based FSEvent API bindings
A small updater
Engine for the FUCing project
Safe wrappers for libbtrfsutil
Idiomatic nvpair API
Fast, parallelized duplicate file finder
High-level file-system API built on-top of Playdate API
Find duplicate file
A (disk) persistent queue library
Include a whole directory tree at compile time! - Runtime part
Demonstration of humanbyte usage for human readable byte functions
A smart CLI for removing thousands of duplicates on your disks
Base utilities of rdfoothills, mostly to be used by the other crates in the workspace
Aquila server file system file backend implementation
Ext4 filesystem image creation via libext2fs — static FFI bindings and safe Rust API
managing states using json with file persistence
Content-addressed block storage for IPFS, compatible with Kubo
rust application single process
Recursively cleans swim projects
gathering useful infos about Windows entities(archives, directories or reparse point/symlinks) with developer friendly way
Blob object file system for Nydus Image Service
Find files or directories upward in the directory tree
interface with SquashFS filesystems
Read partitions from block devices or files
Linux distribution rootfs extraction, caching, and lifecycle management
BitRouter blob storage backends
Framework for building custom CLIs around shell, scripts, and executables
inverts the action of tree. It allows you to create directory trees from a textual representation of the tree.
Import/export functionality for Chamber secrets manager
Command-line git repository manager
canonicalize, normalize urls
Back any folder/file to an S3 bucket periodically with a simple TUI
Bindings to HDFS Native C API
assesses whether one glob pattern matches a file path more closely than another glob pattern does
CLI for running FEFF10 calculations
hdd: instruments for querying ATA and SCSI disks
Parsing and interacting with cmake-file-api
puniyu 路径管理库，统一提供应用、插件与适配器目录路径
Logged is a small library that implements a file-system-based commit log
reducing a whole directory tree to a single hash digest
Fast rsync-like tool for incrementally copying files. Runs natively on both Windows and Linux and uses network for communication.
Functionality for interacting with a pijul repository
Core library for managing symlink-based bonds with SQLite persistence
XDG-compliant theme loader for TCA
Backup functionality for Chamber secrets manager
images
Real-time file watcher for Codemem with debouncing and .gitignore support
async filesystem facade for rust!
Log-Watcher utility - replacement for: tail -F /some/path/* - that uses Kqueue to watch for new files as well…
tail -F /some/path/*
Pattern based mv(1)
Content-addressed storage with erasure coding and chunking for Shadow Network
path library with quirks that is as platform-agnostic as possible
Filesystem-backed StateStore implementation for skelegent
Track Filesystem Integrity via Snapshots which contain a HashMap of the files and their corresponding hash signature from a specified directory
few basic types to reference IRIs and ontologies
part of gostd,gostd 是Go标准库的rust实现
File watcher geared towards automatic HTML generation and autoreload
Fast and lightweight tool to scan your disk space
That thin layer of data change management over the filesystem
testing helpers to make it easier to write test fixtures. Not for use outside of ssstar crate. Breaking changes may ocurr without warning.
Block reader for Android sparse images
OpenDAL plugin for summer-rs
Find the common root directory of a set of paths
short for compose, a tool used to create or fill files with a default content
Driver for GRASS
interface with Gluster's CLI. This is being leveraged by a Juju charm to manage a Gluster deployment
RawCopy crate provides the capability to use "Volume Shadow Copy technology" for file copying in Rust.Primarily aimed at replicating files that cannot be directly copied due to being in use
get disk serial numbers across different platforms
Type definitions and utilities for working with NFSv3
Agent Skills plugin for elizaOS - implement the Agent Skills specification with progressive disclosure
Rename files with RegEx patterns
A CLI tool to tidy your file system by finding and managing duplicate and unused files
Freeze your local git repositories for easy restoration
Copy coredumps for debugging on a different machine
shell written for my own learning
Dependency resolution for kiln. Wraps bender as a subprocess.
Pluggable virtual filesystem backends for Rust
really easy IO
Bindings for libhxcfe https://github.com/jfdelnero/HxCFloppyEmulator/. Unfinished work, contributions are welcomed.
OpenHarmony's fileuri sys for rust
Everything related to build.rs and runtime
build.rs
CLI interface for Chamber secrets manager
Dylint internals
A std::fs::remove_dir_all replacement using the Windows Shell and Property System APIs on Windows
A colletion of utils to build CLIs with an output style and a behaviour similar to cargo
cargo
A file archive format and virtual filesystem backed by a SQLite database
installer utilities
creating device backups using dd
FleetFS
A storage hybrid access layer
Filesystem-backed StateStore implementation for neuron
Various tools and extensions around Amazon S3
Patch application utilities for Hanzo
Low-level OCaml bindings for Rust
Cross-platform advisory file locking, taken from Cargo
MCP server for system information (CPU, memory, disk, etc.)
Application filesystem to simplify reading files from both the native filesystem and file archives (tar, tar.gz & zip)
extending Path and PathBuf in order to get an absolute path and remove the containing dots
Path
PathBuf
Wormhole is a data decentralisation solution. It aims to create one single virtual storage space between many computers.
fully encrypted and optionally authenticated Oblivious RAM filesystem
FUSE filesystem where existing folder with files compressed by zstd is mapped to folder with uncompressed files
port of GNU Midnight Commander — a dual-panel terminal file manager
High-performance filesystem service for ArcBox (VirtioFS)
A Vector swapping to disk after exceeding a given length
.env file management CLI
VFS layer for Rust
building and querying Directed Acyclic Word Graphs (DAWGs) and Compacted DAWGs (CDAWGs) for efficient string indexing and searching
A distributed file system with a cuddly API
organize files into folders by date
IPFS UnixFS - file and directory representation with chunking and DAG building
Modern file manager for Winux OS with cross-platform file format support
Rust interface to libzfs_core (lzc)
DAG used for source control
fast, secure, and easy-to-use Rust-based tool to monitor filesystem events across platforms. Effortlessly automate tasks and log changes.
Kardo Gate — Documentation quality gate for GitHub PRs
Useful to create temp directories and copy their contents on completion of some action. Tmp dirs will be created using [env::temp_dir] with some random characters prefixed to prevent a name clash
env::temp_dir
scan your disk space
Finds the common prefix between a set of paths
Extremely fast file deduplication app written in rust using parrellism with a rust gui
An adaptive machine-learning-based cache tracker/replacement policy
Some Default paths which are not in dirs next
Search for file hashes
reading PlayStation 4 PFS (PlayStation File System) images
object storage written by Rust
append-only log based filesystem with encryption and compression
Per-registry package fetch and unpack adapters for OpenVet audit authoring
disk cache for bunsen
used by the globcmp crate. Provides methods to assess whether one glob pattern matches a file path more closely than another glob pattern does
📦 A Rust library for detecting various system environments, including virtualization, containers, OS types, and more
Command-line tool that recursively renames all files and folders within a specified directory to snake_case
A command-line utility to display a ascii tree of files and directories
Hyper-optimized Windows directory deletion tool
A lightning fast disk based queue, meta data is stored in lmdb
Force delete file/folder on Windows, kill occupying processes
Compare folders and return a diff for assertion
MCP server for opening files/URLs with system default applications
Distribution Installer Backend
Common traits and types for handling block devices, partitions, file systems, etc
versioned cloud file system with git-like branching, transaction support
Linux kernel objects
Allows to convert between different RDF serialization formats and to HTML
An app that displays the path of planes through the country of United States
zoxide integration for Wisp
A CLI tool to display the file tree of a directory
Just run it! A simple init system
Filter filenames on stdin to exclude filenames for dates which should be kept, and filenames not containing dates
generating and caching thumbnails using the GNOME thumbnailer approach
building configuration management tools
🧵 A command line memory usage information tool
Advisory cross-platform lock on a file using a file descriptor to it
A system monitor for RISC-V SBCs on Linux
Show a preview of the directory contents
finds and deletes old build dirs, and saves you disk space
A dead simple file system watcher
File caching library with lazy creation, automatic refresh, and callback-based initialization
that provides a Transaction-like interface that are traditionally used in databases on FileIO operations
quickly create and manage temporary folders from the commandline
A cli tool for copying file/s contents to your clipboard
multi parts download, disconnect to continue connection, redundant download
storing and restoring files metadata (mode, owner, group) in a git repository. It's designed especially for versioning /etc.
CargoLifter
Bloom filter for the Webnative Filesystem
File system operations and management utilities
Recursive find files in folders with filtering
Tools to view directories and files
IPFS content pinning - prevent blocks from garbage collection
Btrfs INCremental BackUP - backup subvolumes incrementally
A tui program that displays information about your system in a gauge format
ignore file generator
Nydus Image Builder
Hadoop WebHDFS client library
Cache AnyThing filesystem
source code formatter
Local filesystem blob storage backend for S5
vhost scsi backend device
Platform-independent path manipulation
Glob fork with bug fixes! Support for matching file paths against Unix shell style patterns
Calloop adapter for Notify
Cross-platform I/O redirection
Query system for default apps using XDG MIME databases. Rust implementations of some common functions in the freedesktop project xdg-utils.
xdg-utils
fast and efficient key-value storage engine, based on Bitcask
finding the absolute path to a folder with a given name
A tiny tool to download multiple images from Unsplash API in parallel
An EXPERIMENTAL file manager inspired by ranger
FFI bindings to the libcryptsetup library
CLI tool that tries to convert simple OWL ontologies into SHACL shapes. OWL ontologies define logical relationships. SHACL shapes define a data scheme, and allow to validate data against them…
backup with copy-on-change model
FUSE filesystem for use with Maelstrom
Replace user home directory in a path with another string (Rust alternative to npm replace-homedir)
a Virtual File System with local storage
All your favourite utilities in one place
A virtual file system for sandboxing
Indexed binary file. It uses mmap , various_data_file and avltiree.
Method for quickly running programs inside of Redox from a KVM capable OS
*.D88 file dump tool
Safe and secure backup library
HTTP book storage service with built-in conversion support
Flexible project creation for minimalists
Abstraction for the browser file system APIs
trash file dumper
Convert Windows to WSL Path and vice-versa
Iterator that recursively scans and filters files from a directory
that makes dealing with Rust file system a breeze
Cross-platform TUI filesystem browser with Vi-like keybinds
File system watcher capability for UniStore
Manage rolling backups
Command line tool for calculating the size of files and directories
🐸 Simple file system implementation using the 9P protocol
Lexically normalize paths in Rust without touching the filesystem
experimental boot manager with live-loading ISO support and more cool things
list and extract RAR archives
bindings allow you to create nfs mounts in memory/userspace
Parse a Neotron ROM-FS image
Minimal Rust library that provides functionality for managing PID files and file locks
Parsing and reading of SquashFS archives, on top of any implementor of the tokio::io::AsyncRead and tokio::io::AsyncSeek traits
Helper functions for path operations
Local filesystem importer for S5
VFS for TAR files
CLI for interacting with EROFS
filesystems in userspace (FUSE)
Combines filesystem images into a disk image with MBR
Cross platform library for finding and pathing through proton prefixes
Cross-platform implementation of path swap
Declarative specification of HTTP endpoints
working with floppy disk images for the IBM PC and compatibles
wrapper around the legendary pass - Foo Pass!
A helper library for precious - not for external use
Fuse layer exposing Crypt4GH-encrypted files, as if they were decrypted
handle input directory inputs on linux
Compile Typst documents
Confirms all files are copied somewhere
Deterministic directory hashing with glob ignores and optional metadata
File loading and (future) filesystem abstraction for Polished OS, supporting UEFI and no_std environments
working with Nintendo Switch filesystems and archives
Shared core logic for FlashKraft — domain models, flash pipeline, drive detection
Internal shared utilities for the Auths workspace
A high-performance file watcher with beautiful TUI showing real-time diffs
Actix implementation of IPFS HTTP API
Featherweight FDAP client library
Platform-independent parsing and writing of btrfs on-disk structures
Zero overhead static initializer for Path
executable to unfold a file into a folder and fold a previously unfolded folder into a file
Rust bindings to C *FILE stream
Everyday filesystem, string, random, and terminal utilities built on emixcore
ergonomic use of extended attributes of filesystem objects
An opinionated, fast ebook organiser
A fast directory scanner
Yazi virtual file system
Rust bindings for name_to_handle_at() and open_by_handle_at() system calls in Linux
Easy queueing system
file-system-based mutex
(A forked version of ignore used internally by tree-sitter-grep) A fast library for efficiently matching ignore files such as .gitignore against file paths
ignore
tree-sitter-grep
Rust convenience structs that facilitate automatic switching between buffered reading and writing from a single underlying IO instance. BufReaderWriterRand for random IO and BufReaderWriterSeq for sequential IO.
a cli/lib wrapper of opendal to download/upload and manage remote files on buckets
reports if something has changed in the file tree
ratatui-file-picker allows you to select multiple files from a tree and add their content or paths to clipboard. It also returns the absolute paths of selected files on exit.
A command-line note-taking app written in Rust
Blazingly fast file renamer
Remote Server Management tools
Find Files (ff) utility recursively searches the files whose names match the specified RegExp pattern in the provided directory (defaults to the current directory if not provided)
high-performance block device I/O
rspack fs node
bindings
Pure Rust library for creating ext2/ext3/ext4 filesystems
List contents of directories in a vine-like format
command-line tool designed to download and Verify Proxmox Virtual Environment ISO images automatically
Dead Project, Rewriting everything in C
Mounting qcow2 virtual disk images
dependency parser and loader for swamp script
Bridge between your file manager and thumbnail daemon
Core save parsing/query library for Fallout 1 & 2
Functionality to interact with Pijul identities
Low level bindings to sigar
comparing files/directories
interacting with EROFS
a linux horror game
Core library for dnx, a fast Rust-based package manager for Node.js
A macro to join path components using /
/
Create xiafs filesystem images
Resolves paths according to the XDG Base Directory Specification
Define and build CI for Nix projects anywhere
Filesystem and artifact tools for Distri agents
FUSE filesystem that bolts aggressive caching and readahead onto another filesystem
Fast tar archive creation for HDDs
intended for reading and generating files in the ELF binary format
High-level Rust wrapper for squashfs-tools-ng
A small crate used for reading and decoding FIT files generated by sports devices that works without a file system
Collection of algorithms and structures to handle paths properly
Parser for the VirtualBox VDI disk image format
Interactive duplicate file remover
Rust Path trait to get the permission
walking down the directory tree
Helper program to manage a changelog
eat node_modules
Rust wrapper around the Yubikey-personalization library, allowing interaction with Yubikey hardware
A command-line file integrity verification tool
TUI interface for Chamber secrets manager
Core library for the Humanize plugin workflows
Sets environment variables permanently across all major platforms
give information on mounted disks
High Throughout, NonBlocking Disk-based logger
Bittorrent Infrastructure Project Disk Module
Glob-matched recursive file system walking. Fork of 'globwalk'
new implementation of apk
Converts a terminusdb v10 store to a v11 store
A high-performance Rust implementation of picomatch/micromatch pattern matching
Call non-blocking async Rust from non-async Rust
Tools for working with the IrisOS-nano File System (INFS)
Special single-file FUSE filesystem that maps the file depending on requestor's process's Linux network namespace
Rust File System
handling gnu install directories in rust
Wrapper of nix shell that reads a lockfiles to get the nixpkgs revision to use when sourcing packages to install in transient shell
nix shell
Command-line interface for running YAML-defined AI agents
A read-only FUSE filesystem to transform the content of files with Lua
memmap file interface library
Scoped current working directory
file information for PE and ELF files
cli tool for batch renaming files and folders, written in Rust
command line bulk copying tool
that can list the 10 biggest directories of the path you support, like df on linux
A collection of utilities for working with paths
Package manager and dispatcher for zr — install, manage, and run modular CLI packages
that summarizes file folders. Useful for passing context to LLMs
List directory tree, sorted by size
A type-safe Rust interface to the Nix CLI
casync index parsing and reconstruction core
Imagine ls, but you can 'key' into the file or dir instead of just starring at it
accessing common user file directories according to xdg-user-dirs
xdg-user-dirs
A collection of path matchers
Update an index of the hashes of all files
deal with filename, remove illegal strings and emojis when file renaming
A respectful, XDG-first user directories implementation for obtaining the home, cache, config, data, runtime, and state directories
A replacement for incron written in Rust
Direct file operations for CAI - no storage layer
handling tags stored in extended attributes of supporting file systems
RDF serialization format types (plus HTML), and code to identify them
An open standard and implementation for monitoring Internet content
A system for organizing project-based learning paths
Interact with zfs via the supported cmd line tools
interact with dd tool
dd
An internal crate to share file-locking logic between Pavex’s CLIs, pavex and pavexc
pavex
pavexc
App that creates the script with shebang
A CLI tool that recursively collects files (excluding hidden & certain folders/files) and outputs them into a markdown file
customizable file dialog for egui
Include a whole directory tree at compile time! - Compile time part
Track which files have changed
Create microVMs from OCI images
A set of trivial utilities for command line tools
A filesystem-engine that handles creating/reading/deleting/write/... files. Also includes an network-manager (dev): Download files.
CLI for working with GCM/ISO files (raw bit-for-bit disk images) for the Nintendo GameCube
Утилита для разработчиков 1С Enterprise
Dead simple in-memory filesystem for packaging assets
module system
Reader and writer that splits IO across volumes (files) of a specified maximum size
A command line utility to compare modification times between file globs
Grouped Repository Assistant - Manage your repositories throught the CLI
VIL Phase 3 — Filesystem / directory watcher trigger source
Content-addressable global package store for Aube
Kafka-compatible message broker written in Rust
.scratch directory to keep random scribbles in
A file-system backed blob storage abstraction
log searching utility
file synchronization tool. It enables fast, local reads with a remote filesystem
Windows filesystem notification library
Load files on web and desktop asynchronously
Shared primitives for all crates of Klirr
Immutable archive manipulation library
component of Diskplan for applying schemas to disk
interact with GPT / MBR partition tables
command-line tool written in Rust that displays the folder structure of a specified directory in a tree-like format
Access the file system
The endpoint of Project Polya
A very simple file rotator
Cross platform file locator by file ID. Keep track of files even after they're renamed or moved.
FUSE filesystem and tools to emulate and test behaviors on power outage
A small tool for linking compile commands from catkin builds
A CLI tool for finding duplicate files from directory tree and de-duplicating them
A container for inodes implemented as a Hyperfile
lets you create temporary environment and be automatically restored/cleaned when not needed
A modern, colorful directory tree viewer with glob pattern support
A minimal content-addressed file store using BLAKE3. (library)
writing objects to binairy buffers
Installer Backend
Two-phase commit for file creation
Backlight control is a re-written version of backlight_control with a few key improvements
Keybind customization with conflict detection and profile management
*at syscall abstractions
Upyun sdk for rust
Potpourri functions to work w/ clipboard, dialog, glob, git, copying files, image resizing, HTML, sound, etc
Work with flexible file paths
Directory tree traversal optimized for HDDs
File system mapper and search tool
Atomically write a file with retries
thread-safe disk-backed key-value store
This crates provides FFI bindings for Gluster's API
Wildland Local Filesystem Backend
Context and vector storage for Erio
lightweigth and blazingly fast folder scanner with a tree-like visualization that can be used to find space hogs
Ceph Rados Block Device Bindings
Concatenate Amazon S3 files remotely using flexible patterns
A Userspace filesystem based on OpenDAL
A thin wrapper around libc's mkstemps and mkdtemp
The ReadUTF8 crate allows to easily read a file with efficiency. It allows to read all UTF-8 files encoded, by giving the content between delimiters, or by giving the content character by character.
interact with the Juju system. For an example charm see: https://github.com/cholcombe973/gluster-charm
Rust Utilities
Core application logic for pict-rs
InnoFile
sophisticated, yet simple to use file listing utility. Use Fe to list files in a directory or to recursively find files by their names using a fuzzy pattern. Fe's speeds are comparable to find, and often times faster.
Core vault functionality for Chamber secrets manager
Small wrapper methods for loading files
Core library for Claude Code filesystem storage access (zero dependencies)
companinon crate to bintest/testcall, augments Paths for testing
Core types for the littlefs2 crate
Store large, unmanageable yaml files as multiple, manageable ones across your file system
Embed files from a directory as a hashmap in the rust binary
parser and modifier
RDUP Disk Usage
The context-engineer's toolkit
daemon
comparing two directories using BLAKE3 hashing
allows to create a signature (index) of a directory with files
Core library for scrat
A file-like interface abstraction layer provides random read and write capabilities for S3
Append-only, on-disk key-value index
Additional functions for application paths, based on the dirs-next crate
Filesystem Trustfall adapter
CLI tool that replicates the Unix 'tree' command with enhanced features
dynamically linking to cdylib projects from test code
A Rust-based system daemon with FUSE, HTTP, and async orchestration for advanced identity logic
Run path-specific (shell) scripts without the need to modify PATH
PATH
🧐 A simple file watcher, based on notify, designed to be fast, easy-to-use and async friendly
notify
lua shiori implement
editing file fast and memory efficient
Core library for page cache diagnostics and control on Linux and macOS
Common service utils for the Retrom video game library service
A commandline tool for generating semi-random file names
Synchronous, content-addressable, key-value, high-performance, on-disk cache
A fast fetch program written in rust
Cross-platform helpers for system info, network probing, and filesystem utilities (hashing, dedup, JSON I/O, text/binary detection)
Misc utilities used by Sapling
A fast library for efficiently matching ignore files such as .gitignore against file paths
Watch configured git repos, check if all are clean with one command
Deduplicated, compressed and encrypted content pile manager
that allows you to quickly save a picture from the clipboard to a file
Cross-platform path management for vx tool installations
Block device adapters for managing byte level access and partitions
Embedded time-series database
Data lake management for dkdc (don't know, don't care)
Show files in the local file manager
Runkins makes it easy to manage command execution
Converts multiple alignment format (MAF) files to a BED format for tabixing. Used with jbrowse-plugin-mafviewer
Replacement for the `dir’ windows command
A no-nonsense cli pomodoro timer
quick shell scripting in Rust
Compare two folders and get a list of changed and new files
rust posix crate
FAT32 filesystem adapter for gibblox block readers
A safe file writing utility
CLI for identifying the platform path
Search for local text files with a simple tagging system
kafka inspired rumqtt's mqtt commitlog
The low level syscall interface for RASI system
shortcuts for common RDF ontologies/vocabularies, as an extension to what can be found in oxrdf::vocab
oxrdf::vocab
Implementations of a tag-based filesystem
Password generation utilities for Chamber secrets manager
parse the file permission into a unix-like text representation
A collection of macros to simplify testing involving filesystems
Investigate where your diskspace has gone
A remake of ls for the 21st century
ls
X-OS IPFS Storage
Core library for the Sleek Manifest File Handler
Small download tool to automate AppDynamics downloads
A fancy diagnostics & reporting crate
reading and writing filesystem tables
Node.js compatible module resolver used by the Parcel bundler
An IPC TCP client for tev
A plugin for accessing the filesystem on ios
A program to count your warnings inside log files and comparing them against defined limits
Multi-process communication utility library
Breadth first search of directories
A knowledge graph and meta file system for object stores
Walk directories on Windows
Static build of MFEM for use as a Rust dependency
High-level interface for the libmtp C library
Fully featured rust reader for the squashfs archive format
Core library for nameback - intelligent file renaming based on metadata
manage the caching of data in rattler
dot files manager for syncing dot files across machines
FFI interface for POSIX Access Control Lists
walk path
Cross-platform file system watcher for gity
FIFO queue backed by disk
cat and ls combined into one command
bloom filter implementation in Rust
ffs---the File FileSystem---lets you mount semi-structured data (like JSON) as a filesystem, letting you work with modern formats using your familiar shell tools
generator
Rust bindings for GPT4All
A cache library for the Oldschool Runescape JS5 file system
Force a file to use CRLF line breaks
determining whether two file paths point to the same file
Macro consuming JSON like data structures to create directories and files at runtime
A CLI tool with TUI for automating machine configuration and setup tasks
cross-platform file backup tool written in Rust, designed to simplify the backup process. It supports Windows, Linux, and macOS, and is open source under the GPL license.
Calculate checksums on directories
Core library for DiskForge: scanning, detection, rules engine, and cleanup for developer disk management
A easier read_dir and recursive directory walker, useful for reading directory of config files
File rotation made simple
Next page?