QuickFiles — Intelligent File Management Powered by Local AI

Inspiration

We’ve all experienced the frustration of having hundreds or thousands of files scattered across our computers. Downloads pile up, desktops become cluttered, and finding or organizing files becomes increasingly time-consuming.

Traditional file managers still leave most of the work to the user. Even when they are good at browsing folders, they usually are not good at understanding what a file is, where it belongs, or how to find it when the user only remembers a description instead of the exact filename.

We wanted to change that by building QuickFiles, a desktop file manager that combines fast native file scanning with locally running AI.

Our goal was simple: make file organization and search faster, smarter, and more private—without depending on cloud APIs or requiring users to send their files anywhere.

What It Does

QuickFiles is a desktop application that helps users organize and search their files using local AI.

Its main features include:

AI-Powered File Organization: Uses a local LLM to analyze filenames, metadata, and supported file contents to propose clean folder structures.
AI Semantic Search: Lets users search using natural language instead of exact filenames. For example, a user can search for something like “my machine learning notes” and retrieve relevant files.
Native High-Speed Scanning: Uses a custom multithreaded C++ scanner to quickly traverse directories and collect file metadata.
Before-and-After Preview: Shows the user the proposed organization plan before any files are moved.
Editable Results: Users can review and adjust proposed destinations before applying changes.
Undo Support: The most recent organization batch can be reversed.
Local AI Processing: Runs locally through llama.cpp, so files stay on the user's device.
Smart Search Caching: Caches embeddings and file excerpts in SQLite so unchanged files do not need to be reprocessed every time.
Cross-Platform Support: Supports Windows and Linux.
Safety Validation: Blocks unsafe operations, validates paths, and prevents invalid AI-generated actions from being applied directly.

How We Built It

QuickFiles was built using a hybrid Python + C++ architecture.

Python handles the desktop application logic and AI integration.
PySide6 (Qt) powers the GUI.
C++17 powers the high-performance native file scanner.
SQLite stores persistent app data such as undo history and search caches.

For local AI organization, QuickFiles uses Qwen3.5-4B Q6_K through llama.cpp. The app supports CPU inference and optional GPU acceleration, with a CPU fallback if GPU startup fails.

File Organization Pipeline

Our organization pipeline works in several stages:

Scan the selected directory using the native C++ scanner.
Extract context from supported files, including text, PDFs, Office files, and ZIP entry names.
Plan a folder structure and file assignments using the local LLM.
Validate the model output for safety, path correctness, and collisions.
Preview and edit the proposed changes in the UI.
Apply the approved operations and log them for undo.

An important design choice is that the LLM never directly manipulates files. It only proposes plans. Those plans must pass validation before anything is shown or executed.

AI Search

QuickFiles also includes a separate AI Search mode.

For search, the app uses:

Qwen3.5 to interpret the user’s natural-language request and produce a concise search query with filters.
All-MiniLM-L6-v2 embeddings to retrieve files by meaning.
NumPy + SQLite for local vector comparisons and persistent caching.

This means users can search semantically without needing a cloud API or a dedicated external vector database.

Embeddings and short excerpts are cached locally in search.sqlite3, and unchanged files reuse their existing vectors on future searches.

Performance Optimization

One of our biggest technical improvements was replacing Python-based scanning with a native multithreaded C++ scanner.

This scanner is implemented separately for Windows and Linux and streams metadata back into the Python application.

The result is a much faster inventory step, which is critical because every organization or search workflow begins by understanding the filesystem efficiently.

Challenges We Faced

One of our biggest challenges was balancing AI usefulness, runtime safety, and hardware constraints.

Running a local LLM is very different from calling a cloud API. We had to carefully consider model size, RAM and VRAM usage, CPU versus GPU execution, context limitations, and how to make the application accessible on ordinary consumer hardware.

One of the most difficult challenges was designing the AI-powered file organization system itself. File organization is surprisingly subjective and ambiguous. There is no single correct way to organize thousands of files, especially when filenames are unclear, documents belong to multiple categories, and different users have different organizational preferences. We had to determine how much context to provide the LLM, how to structure its prompts, how to prevent unnecessary folders, and how to maintain consistency across multiple batches of files. Getting the model to produce a logical, unified folder structure rather than making isolated decisions for individual files required significant experimentation and prompt engineering.

Another major challenge was ensuring the reliability and safety of AI-generated decisions. The LLM could suggest invalid destinations, create inconsistent folder assignments, or produce incomplete responses. To address this, we implemented structured output handling, protected directories, collision detection, constrained file assignments, and user confirmation before executing changes.

We also had to make semantic search practical. Re-embedding every file for every search would be inefficient, so we implemented persistent caching and mechanisms to refresh indexed information when files change.

Finally, cross-platform native scanning presented its own challenges. Windows and Linux expose different filesystem APIs and behaviors, requiring platform-specific C++ implementations while maintaining consistent results, performance, and safe cancellation across both operating systems.

What We Learned

Building QuickFiles taught us a lot about combining systems programming, desktop development, and local AI into one real application.

We learned how to:

integrate a local LLM into a desktop workflow,
optimize filesystem scanning with C++,
structure safe AI-assisted file operations,
cache embeddings for practical semantic search,
and design for privacy-first AI from the start.

One of our biggest takeaways was that AI is only one part of the system. The surrounding architecture, validation, indexing, caching, UI flow, and safety checks, is what makes the experience actually usable.

We also learned that local AI is not just possible, it can be genuinely useful when paired with the right engineering decisions.

What’s Next

We plan to continue improving QuickFiles in several ways:

add even faster indexed filename search,
improve semantic retrieval quality,
further optimize native filesystem indexing,
benchmark additional lightweight local models,
improve support for lower-end hardware,
and expand support for more file types and richer file understanding.

Our long-term vision is to build a fast, privacy-first, AI-native file manager that gives users a better way to organize and find their files without giving up control of their data.

QuickFiles: Your files, organized intelligently, entirely on your device.

GitHub: https://github.com/DJMike2/QuickFiles