SnapSort Lite: My Screenshots Had Timestamps, Not Names

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

My screenshots folder was becoming a timeline instead of a library.

A filename like Screenshot 2026-10-25 184500.png tells me when I captured something, but not why I saved it. Finding a useful code snippet, document, or webpage meant opening screenshots one by one.

I wanted to automate that repetitive first pass without uploading my screenshots to a cloud service.

So I built SnapSort Lite, a local-first Python CLI that uses open-source Tesseract OCR to extract visible text from screenshots, suggest meaningful filenames, and organize copies into five categories: Code, Documents, Conversations, Web, and Other.

The workflow is intentionally simple:

1. Select a folder containing screenshots.
2. Let Tesseract OCR read the visible text.
3. Generate descriptive filenames and classify the images using keyword rules.
4. Review the proposed operations.
5. Apply the changes when satisfied.

The important part: nothing is copied by default.

SnapSort Lite starts in dry-run mode. Only --apply creates organized copies. Original screenshots remain untouched, filename collisions receive numeric suffixes, and a JSON manifest records the operations.

This isn't a magical screenshot-understanding AI. It's a small tool designed to eliminate a boring task while keeping the user in control.

Demo

The video is an edited walkthrough assembled from genuine application outputs, command executions, and filesystem results. It uses synthetic screenshots rather than private user data.

For the demonstration, I generated three screenshots using Pillow: a fictional invoice, a Python code snippet, and a fictional webpage.

Here are the results:

fictional-invoice.png
  → Documents/fictional-data-for-demo.png

fictional-web.png
  → Web/welcome-to-the-fictional-demo-site.png

python-code.png
  → Code/return-f-hello-name.png

The suggested filenames are more informative than timestamps, although they're not always perfect. A filename extracted from a code line, for example, might not be the title a developer would choose manually.

That's one reason I kept the preview step.

Run a dry-run preview:

python snapsort.py ./screenshots --output ./organized

Then apply the plan:

python snapsort.py ./screenshots --output ./organized --apply

The first command previews the operations without copying files. The second creates organized copies and a manifest while preserving the originals.

The local verification run processed all three demonstration screenshots successfully.

You can also explore the demo walkthrough and verification notes.

Code

adarsh-singh106 / snapsort-lite

SnapSort Lite

SnapSort Lite is a privacy-first Python CLI for making small, safe improvements to a screenshot collection. It reads visible text with the local Tesseract OCR engine, proposes a short filename, and copies each image into a transparent category.

Problem

Windows screenshots often accumulate under timestamp-based names. SnapSort Lite turns that timeline into a reviewable first pass without deleting or uploading originals.

Features

• PNG, JPG, JPEG, and WebP support
• Local OCR with Pillow and pytesseract
• Deterministic, filesystem-safe filenames
• Rule-based Code, Documents, Conversations, Web, and Other categories
• Dry-run preview by default; --apply is required to copy
• Never overwrites an existing destination; uses -2, -3, etc.
• SHA-256 and OCR details in a JSON manifest
• Originals are always retained

Installation on Windows

Install Python 3.10 or newer, then from this folder:

python -m pip install -r requirements.txt

Install Tesseract OCR separately, for example from…

View on GitHub

Repository: https://github.com/adarsh-singh106/snapsort-lite

The project is open-source under the MIT license.

The repository includes the Python CLI, automated tests, synthetic demonstration inputs, documentation, and video production materials.

To get started, clone the repository, install the Python dependencies, and install Tesseract OCR separately.

No API key or hosted inference service is required for the OCR workflow.

How I Built It

The architecture is deliberately straightforward:

Screenshot → Pillow → Tesseract OCR → Filename Generation → Keyword Classification → Dry Run / Apply → Organized Copies

Here's what happens internally:

1. Image discovery: The CLI identifies supported PNG, JPG, JPEG, and WebP images in the selected directory.
2. OCR: Pillow loads each image, and pytesseract passes it to the locally installed Tesseract engine.
3. Filename generation: A promising recognized text line is converted into a short, filesystem-safe filename.
4. Classification: Deterministic keyword rules select one of five destination categories.
5. Safe execution: The application prepares a collision-safe copy plan and displays it before writing anything.
6. Audit trail: When applied, it creates copies using shutil.copy2 and records operations in a JSON manifest with file hashes.

Where the open-source AI fits

The core recognition capability comes from Tesseract OCR, an open-source optical character recognition engine.

Tesseract recognizes text inside images. It isn't a large language model or a vision-language model, and SnapSort Lite's category selection is ordinary Python logic.

I wanted to make that distinction clear rather than market simple keyword matching as sophisticated AI reasoning.

The current version works best when screenshots contain readable text. It cannot reliably understand text-free diagrams, recognize application interfaces visually, or infer the full meaning of an image.

Testing and safety

I separated planning from applying so the tool could show what it intends to do before touching the destination folder.

I also designed the OCR dependency to be replaceable during testing, added collision handling, and made missing Tesseract installations produce explicit errors.

In the latest local verification reported during development, 12 automated tests passed, and the three synthetic demonstration screenshots were processed successfully.

There are still improvements worth exploring: content-based deduplication, better filename selection, and an optional local open-weight vision-language model for screenshots without useful text.

Those are future ideas, not features I'm claiming to have implemented.

Why Does Open Innovation Matter?

Screenshots can contain private conversations, source code, invoices, or account information.

For a tool that processes those images, local execution matters.

Using Tesseract OCR means the recognition step can run on the user's machine without sending screenshots to a third-party inference API.

Open-source components also make the pipeline inspectable and adaptable. Developers can change the naming heuristics, improve the classifier, add OCR language packs, or replace the recognition engine entirely.

The tool doesn't depend on a proprietary API key or a remote model whose behavior might change without notice.

That doesn't mean local processing automatically guarantees security. Users still need to protect their files, review proposed operations, and account for OCR errors.

But it provides a useful foundation: the images and the processing workflow remain under the user's control.

My Agent Session

I used an AI coding assistant to help develop the implementation, automated tests, documentation, and demonstration materials.

The demo video was assembled from actual application outputs and synthetic screenshots, rather than a simulated interactive recording.

I haven't published a DevRelay session, so I'm not including an invented session link.

One thing this project reinforced for me: the most important part of automation isn't always the cleverest algorithm. Sometimes it's making sure the automation behaves predictably and gives users a chance to review its decisions.

The Lazy Payoff

Before SnapSort Lite, organizing screenshots meant opening each image, deciding what it contained, renaming it, and moving it into the right folder.

Now I can generate a first-pass organization proposal with one command, review it, and apply it with another.

In the three-image synthetic demonstration, the application produced categorized copies while keeping the original screenshots intact.

I haven't measured time savings across a large personal screenshot collection, so I won't invent a percentage.

For me, the payoff is simple: fewer repetitive decisions, more useful filenames, and a folder that's easier to navigate.

Slow and steady means giving automation a small, reviewable job before trusting it with something bigger.