Allsee

Fast, cross-platform, fully customizable file & web search for the desktop.
Find any file instantly. Customize everything.

---

allsee is a desktop file & web search application that indexes whatever you want and lets you find files in milliseconds. It combines a Rust-powered search engine with a lightweight Tauri + Svelte interface that runs natively on Windows, macOS, and Linux.

allsee runs entirely on your machine. Your file index never leaves your disk.

Table of Contents

• Quick Start
• How Search Works
• Templates and Theming
• Indexing and Persistence
• Exclusion Patterns
• Keyboard Shortcuts
• Web Search
• Architecture
• Development
• License

Quick Start

Prerequisites

• Rust 1.70+
• Node.js 18+ and pnpm
• System dependencies for desktop build (see Development)

Build and Run

# Install frontend dependencies
cd allsee-desktop/ui && pnpm install && cd ../..

# Development mode (with hot reload)
cargo tauri dev

# Production build
cargo tauri build

---

How Search Works

When you point allsee at a directory, it scans every file and folder and builds an in-memory index. After that, searches return results in milliseconds -- even across hundreds of thousands of files.

The basics

Type any text and allsee finds files whose name or path contains it. Results where the filename itself matches are ranked above path-only matches.

config       -->  finds config.yaml, myconfig.json, /src/config/db.rs

Add a * to search by prefix (files whose name starts with your query):

mod*         -->  finds mod.rs, module.ts, models.py
                  won't match "demod.wav" (doesn't start with "mod")

Add a ~ for fuzzy search -- finds files even if you mistype a character:

confg~       -->  finds config.yaml, config.json (1 character off)
confg~2      -->  allows up to 2 typos

Wrap in /slashes/ for full regex:

/main\d+/    -->  finds main1.rs, main42.cpp

Filters

Narrow results by extension or type. Filters combine with any search mode.

mod* ext:rs          -->  Rust files starting with "mod"
config ext:rs,toml   -->  config files that are .rs or .toml
build -ext:log       -->  "build" results, excluding .log files
src type:dir         -->  only directories named "src"
test -type:dir       -->  "test" results, excluding directories

Sort modes

Results default to relevance (name matches first, then shortest path). The UI also supports sorting by name, size, date modified, and full path -- each ascending or descending.

Under the hood

For those interested in the internals: allsee doesn't scan the full index on every keystroke. It uses three data structures to narrow candidates before checking for exact matches:

• Trigram index -- Filenames are split into overlapping 3-character sequences. A search for config only checks files whose trigrams (con, onf, nfi, fig) all match, skipping the vast majority of entries.
• FST sets -- Compact sorted sets of all filenames and stems. Prefix and fuzzy searches run automata directly against these sets, so lookup time depends on query length rather than index size.
• Bitmap indexes -- Extensions and file types are tracked as compressed bitmaps. Filtering by ext:rs or type:dir is a single bitwise AND operation.

---

App Overview

The application features a comprehensive settings panel where you can configure search behavior, manage the index, and customize every aspect of the appearance.

---

Templates and Theming

allsee believes software should adapt to you, not the other way around. It doesn't enforce its own branding, logo, or styles. You have full control to customize the interface, swap out the logo, and tweak colors to make the application truly your own.

To facilitate this, allsee ships with a template system that lets you save, share, and switch between complete visual configurations.

Whether you are a football fan who wants to show off your team colors

 

a minimalist who prefers a clean, distraction-free interface

 

or just someone who wants to match their terminal theme

 

allsee's theming system has you covered. Create your own template or import one from the community -- the choice is yours.

What a Template Contains

A template bundles:

• Colors -- Primary background, accent highlight, text color, and opacity
• Logo -- Custom image (PNG, JPG, or SVG) with adjustable scale
• Icon colors -- Per-file-type colors for folders, code files, images, documents, archives, and more
• Cursor style -- Choose from vintage block, bar, underscore, double-underscore, filled box, or empty box
• UI toggles -- Show/hide logo, show/hide search icon, custom search bar and status bar backgrounds

Built-in Templates

Six templates are included out of the box: Allsee Original, Allsee Dark, Allsee White, Midnight, Forest, and Terminal. Each serves as a starting point you can customize further.

Creating and Sharing Templates

Templates are created through the app:

1. Customize your theme in Settings > Appearance (colors, logo, icon colors, cursor, etc.)
2. Click Save as Template to save it to your local library
3. Click Export on any template to generate a .allsee file you can share

To install a template someone else made, click Import in Settings and select their .allsee file. The .allsee format is a portable archive that bundles the theme configuration and any custom logo into a single file.

Community Templates

The community-templates/ directory contains user-submitted .allsee files. Download one and import it through Settings. Contributions welcome -- see the community templates README for how to submit yours.

How Theming Works

Under the hood, the theme engine applies CSS custom properties to the document root. Every color, opacity, and scale value maps to a CSS variable (--bg-primary, --accent, --text-primary, --logo-scale, etc.). Changes take effect immediately without a page reload. Theme settings persist to ~/.allsee/theme.json and are restored on launch.

---

Indexing and Persistence

How indexing works

The first time you open a directory, allsee walks the entire tree and records every file and folder (name, path, size, modification time). This builds the in-memory index that powers all searches.

After the initial scan, allsee watches for filesystem changes in the background. Create, rename, or delete a file and the index updates automatically -- no manual rescan needed.

Fast startup

allsee saves a snapshot of the index to disk (~/.local/share/allsee/) so it doesn't have to re-scan on every launch. The next time you open the same directory, the snapshot loads in under a second via memory-mapped I/O.

Between snapshots, any changes are logged to a write-ahead log (WAL). If allsee shuts down unexpectedly, the WAL is replayed on startup so nothing is lost.

---

Exclusion Patterns

Built-in Exclusions

allsee automatically skips common build artifacts and dependency directories during scanning:

.git, node_modules, target, __pycache__, .cache, .gradle, build, dist, .idea, .vscode, vendor, .DS_Store

Custom Exclusions

Create a .allseeignore file in your indexed root directory. It uses gitignore syntax:

# Skip log files
*.log

# Skip temporary directories
tmp/
.tmp/

# Skip large data files
*.iso
*.vmdk

Patterns take effect on the next rescan. Excluded directories are skipped entirely during the walk (not just filtered from results), so exclusions also improve scan performance.

Exclusion patterns can also be managed through the Settings panel in the desktop application.

---

Keyboard Shortcuts

All shortcuts are customizable through the Settings panel.

Action	Default Shortcut
Focus search bar	Global hotkey (configurable)
Navigate results up	Up Arrow
Navigate results down	Down Arrow
Open selected file	Enter
Reveal in folder	Ctrl+Enter
Copy path	Ctrl+C (when result selected)
Hide window	Escape
Open settings	Gear icon

The global hotkey lets you summon allsee from any application. It can be changed in Settings and is registered as a system-wide shortcut through the Tauri runtime.

---

Web Search

allsee includes an integrated web search panel for quick lookups without leaving the application. Type web: followed by your query to search the web via DuckDuckGo's HTML endpoint.

Results display inline with title, domain, and snippet. Use arrow keys to navigate and Enter to open in your default browser. Pagination loads additional results without leaving the panel.

---

Architecture

allsee is structured as a Cargo workspace with three crates:

allsee-core/            Rust library -- the search engine
  scanner/              Directory walker with exclusion support
  index/                In-memory file index (trigrams, bitmaps, FSTs)
  query/                Search engine (substring, prefix, fuzzy, regex)
  persistence/          Snapshot + WAL persistence (memmap2)
  watcher/              Filesystem watching (notify crate)

allsee-desktop/         Tauri v2 desktop application
  src/                  Rust commands, state management, web search
  ui/                   Svelte 5 frontend
    src/
      App.svelte        Application shell
      lib/components/   UI components (search bar, results, preview, settings)
      lib/stores/       Reactive state (theme, search, settings, toasts)
      styles/           Global CSS

Data Flow

1. User selects a root directory
2. Scanner walks the filesystem, respecting exclusion patterns
3. FileIndex is built with all auxiliary data structures
4. Watcher begins monitoring for filesystem changes
5. User types a query in the search bar
6. Query is parsed into mode, text, and filters
7. Search pipeline runs: filter bitmap -> trigram intersection -> exact verification
8. Results are partitioned, sorted, and displayed with infinite scroll

Key Dependencies

Crate	Purpose
walkdir	Recursive directory traversal
notify	Cross-platform filesystem event watching
roaring	Compressed bitmap indexes (RoaringBitmap)
fst	Finite state transducers for prefix and fuzzy search
memmap2	Memory-mapped file I/O for snapshot loading
bincode	Fast binary serialization for persistence
regex	Regular expression search mode
tauri	Native desktop application framework

---

Development

Build Automation

A justfile is provided for common workflows:

just              # List all recipes
just build        # Build core + CLI
just test         # Run tests
just lint         # Clippy + fmt check
just bench        # Criterion benchmarks
just audit        # cargo-deny security audit
just dev          # Launch Tauri dev mode
just release      # Release build

Code Standards

• Zero clippy warnings at pedantic level
• Iterators over manual loops
• ? for error handling, no .unwrap() in library code
• Dead code is deleted, not commented out

Testing

cargo test -p allsee-core                    # All tests
cargo test -p allsee-core --lib              # Unit tests only
cargo clippy -p allsee-core -- -W clippy::pedantic
cargo fmt --check

Desktop Development

Linux requires additional system dependencies:

sudo apt-get install libgtk-3-dev libwebkit2gtk-4.1-dev \
  libayatana-appindicator3-dev librsvg2-dev \
  libjavascriptcoregtk-4.1-dev libsoup-3.0-dev

cd allsee-desktop/ui
pnpm install
pnpm run dev         # Vite dev server
pnpm run check       # Svelte type check

---

License

MIT