Local Lens is a powerful, AI-driven photo organization application that intelligently sorts and categorizes your photo collection using advanced facial recognition, location data, and metadata analysis. Built with modern technologies, it provides a seamless desktop experience.
Take a look at Local Lens in action:
Different Modes of Local Lens:
Screenshots are for illustration. UI may evolve with updates.
Local Lens revolutionizes photo management with intelligent, privacy-first automation. Designed for photographers, families, and anyone with thousands of digital memories, it transforms overwhelming photo organization into an effortless, secure experience.
Manual photo sorting is tedious, and cloud solutions risk your privacy. Local Lens brings enterprise-grade AI directly to your desktop—no subscriptions, no data leaving your device.
- 🔒 100% Local Processing: All AI and analysis run on your machine
- 🛡️ Zero Data Transmission: Photos never leave your device
- ⚡ Lightning-Fast Search: Dynamic, real-time filters
- 🔍 Multi-Dimensional Discovery: Search by faces, dates, locations, or combinations
- 📅 Smart Date Sorting: Chronological organization via metadata
- 🗺️ Location Intelligence: GPS clustering and reverse geocoding
- 👤 Face Recognition: Train AI to recognize people
- 🔄 Dynamic Filtering: Real-time, responsive search
- 📊 Analytics: Insights into your photo collection
- 💾 Data Integrity: Multiple validation layers for safety
- 🔄 Non-Destructive: Originals untouched, smart duplicate management
- 📋 Logging: Complete audit trail
⚠️ Robust Error Handling: Graceful recovery from interruptions- 🎯 Precision Accuracy: Advanced algorithms minimize false positives
- 👥 Face Enrollment: Teach AI to recognize specific people
- 🌍 Cross-Platform: Native on Windows, macOS, Linux
- 💾 Persistent Config: Save/load sorting presets
- 🔍 Real-Time Preview: Live analytics and progress
- 🎨 Modern UI: Clean interface with React & Tauri
Local Lens uses an adaptive, two-pass face recognition strategy for maximum accuracy and stability:
- Conservative Start: Begins with minimal parallel processing for stability on all hardware.
- Best-Model First: Tries the high-accuracy 'cnn' model for each image.
- Intelligent Fallback: If 'cnn' fails (e.g., due to memory limits), it logs a warning and instantly retries with the lighter 'hog' model—ensuring no image is skipped.
- Accurate Model Approach:
- First Pass: Runs the fast 'hog' model for initial detection.
- Confidence Check: If a high-confidence match is found, it's accepted.
- Second Pass: If not, escalates to the more accurate 'cnn' model for tough cases.
This guarantees the best possible result for every photo, adapting to your hardware and image complexity—never crashing or missing faces.
Local Lens supports a wide range of image formats for both professional and casual users:
.jpg, .jpeg, .png, .gif, .bmp, .tiff, .tif, .webp, .heic, .heif, .dng, .cr2, .cr3, .nef, .arw, .raf, .avif, .psd, .hdr
Whether you shoot on a phone or a pro camera, your images are covered.
Local Lens uses a hybrid architecture combining the best of web and desktop technologies:
┌───────────────────────────────────────────────────┐
│ Tauri Desktop App │
│ ┌─────────────────────────────────────────────┐ │
│ │ React Frontend (UI) │ |
│ │ • Modern React with Hooks │ |
│ │ • Vite for fast development │ |
│ │ • Real-time communication with backend │ |
│ └─────────────────────────────────────────────┘ │
│ | | |
│ ┌─────────────────────────────────────────────┐ │
│ │ Python Backend (Sidecar) │ |
│ │ • FastAPI REST server │ |
│ │ • AI face recognition engine │ |
│ │ • Image processing pipeline │ |
│ │ • Metadata extraction & analysis │ |
│ └─────────────────────────────────────────────┘ │
└───────────────────────────────────────────────────┘
- Framework: React.js with modern hooks
- Build Tool: Vite for fast development and building
- Desktop Framework: Tauri (Rust-based) for native desktop integration
- UI Components: Custom components with CSS modules
- State Management: React hooks with localStorage persistence
- Language: Python 3.11+
- API Framework: FastAPI for high-performance REST API
- AI/ML Libraries:
face_recognition- Facial detection and recognitiondlib- Computer vision and machine learning toolkitnumpy- Numerical computing
- Image Processing:
Pillow- Python Imaging LibraryPillow-HEIF- HEIF/HEIC format supportrawpy- RAW image format support
- Geolocation:
reverse_geocoderfor location data - Server:
uvicornASGI server
- Python Bundling: PyInstaller for creating standalone executables
- Desktop Packaging: Tauri for cross-platform application packaging
- Installer Generation: Platform-specific installers (.msi, .dmg, .deb, .AppImage)
- No prerequisites - The distributed application includes all dependencies
- Visit the Releases page
- Download the installer for your platform:
- Windows:
Local_Lens_x.x.x_x64_en-US.msi - macOS: Releasing soon
- Linux: Releasing soon
- Windows:
- Run the installer and follow the setup wizard
- Launch Local Lens from your applications menu
- Node.js (v18 or higher) - Download
- Rust (latest stable) - Install via rustup
- Python (3.11 or higher) - Download
- Git - Download
- Visual Studio Build Tools or Visual Studio Community
- Install "C++ CMake tools for Visual Studio" workload
- Or install standalone: Microsoft C++ Build Tools
- CMake - Download
- Xcode Command Line Tools - Install
- CMake - Install via Homebrew
brew install cmake- Build essentials and development tools
sudo apt update
sudo apt install build-essential cmake libopenblas-dev liblapack-dev
sudo apt install python3-dev python3-venv pkg-config- Development tools and dependencies
# CentOS/RHEL
sudo yum groupinstall "Development Tools"
sudo yum install cmake openblas-devel lapack-devel python3-devel
# Fedora
sudo dnf groupinstall "Development Tools"
sudo dnf install cmake openblas-devel lapack-devel python3-devellocal-lens/
├── backend/ # Python FastAPI backend
│ ├── main.py # Main FastAPI application
│ ├── organizer_logic.py # Core photo organization logic
│ ├── enrollment_logic.py # Face recognition training
│ ├── exceptions.py # Custom exception classes
│ ├── requirements.txt # Python dependencies
│ ├── long_path_manifest.xml # Windows long path support
│ └── venv/ # Python virtual environment
├── frontend/ # React + Tauri frontend
│ ├── src/ # React source code
│ │ ├── App.jsx # Main application component
│ │ ├── components/ # React components
│ │ └── assets/ # Static assets
│ ├── src-tauri/ # Tauri configuration
│ │ ├── src/ # Rust source code
│ │ │ └── lib.rs # Main Rust application
│ │ ├── tauri.conf.json # Tauri configuration
│ │ ├── Cargo.toml # Rust dependencies
│ │ └── icons/ # Application icons
│ ├── package.json # Node.js dependencies
│ └── vite.config.js # Vite configuration
├── docs/ # Documentation
├── LICENSE # MIT License
└── README.md # This file
We welcome contributions! Please see our Contributing Guidelines for details.
- Fork the repository
- Create a feature branch (
git checkout -b feature/amazing-feature) - Make your changes
- Test thoroughly on your target platform(s)
- Commit your changes (
git commit -m 'Add amazing feature') - Push to the branch (
git push origin feature/amazing-feature) - Open a Pull Request
This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0). See the LICENSE file for details.
- face_recognition - Facial recognition library
- Tauri - Desktop application framework
- FastAPI - Modern Python web framework
- React - Frontend framework
- Vite - Build tool and development server
- 📧 Email: [email protected]
- 🐛 Bug Reports: GitHub Issues
- 📖 Documentation: Project Wiki
⛓️💥 Engineered with purpose by Mayank Pandey
If you found my project useful, please consider supporting me so I can build more projects like this, cuz I'm broke af:
Alternatively, you can scan this UPI ID: Scan QR