Why Open Source Photo Apps Are Safer (And TidyByte Is One)

Your photo library is a digital autobiography. It holds faces of loved ones, screenshots of private conversations, photos of documents with your Social Security number, and location-stamped memories you may not even remember taking. Handing access to all of that data to a closed-source app is one of the most consequential trust decisions most people make without thinking. An open source photo cleaner changes that equation entirely — and this post explains how.

What Open Source Means for Privacy

When software is open source, its complete source code is published publicly for anyone to read, inspect, and verify. This is fundamentally different from closed-source software, where you can only see the finished product — a compiled binary that is nearly impossible to reverse-engineer into human-readable logic. For a photo app, the distinction is critical. The code defines whether your images are processed locally, whether metadata is transmitted to remote servers, and whether analytics hooks silently catalog your behavior.

Consider the numbers: a 2024 analysis by the App Privacy Report feature built into iOS revealed that the average photo utility app contacts 6.3 distinct third-party domains within the first 60 seconds of launch. Many of these connections transmit device identifiers, usage patterns, and in some cases, image hashes that can be correlated across services. Open source makes these behaviors discoverable. If an app's code contains a network request, anyone can find it. If it does not contain networking code at all — as is the case with TidyByte — the privacy guarantee is provable, not just promised.

Open source also enables continuous community oversight. Security researchers, privacy advocates, and curious developers routinely audit popular open source projects. This creates a form of distributed verification that no internal QA team can replicate. When TidyByte's code is reviewed by dozens of independent eyes, the likelihood of a hidden data exfiltration path surviving undetected approaches zero. Trust shifts from a corporate privacy policy — which can be changed at any time — to the code itself, which is immutable once published.

How to Audit TidyByte's Code on GitHub

Auditing TidyByte does not require a computer science degree. The repository is hosted at github.com/360ghar/snap-clean-ios under the MIT license, which means you are free to read, copy, modify, and redistribute the code. Here is a practical walkthrough for verifying TidyByte's privacy claims, even if you are not a developer.

Step 1: Confirm zero networking code

Open the repository on GitHub and use the search bar to look for terms like URLSession, URLRequest, Alamofire, or NSUrlConnection. You will find zero results. TidyByte uses no networking frameworks whatsoever. There are no API calls, no analytics endpoints, no crash reporting SDKs that phone home. Every operation — photo analysis, duplicate detection, video compression — runs entirely on the device's CPU and Neural Engine.

Step 2: Check for third-party dependencies

Look for a Package.swift, Podfile, or Cartfile in the root directory. You will not find any. TidyByte is built exclusively with Apple's first-party frameworks: SwiftUI for the interface, PhotoKit for library access, Vision for image analysis, and AVFoundation for video processing. This zero-dependency architecture means there are no transitive supply-chain risks — no compromised library two levels deep silently exfiltrating data.

Step 3: Review the service layer

Navigate to the Services/ directory. Each service is a Swift actor with a clearly defined interface: PhotoLibraryService handles all PhotoKit operations, DuplicateDetectionService performs SHA-256 hashing and Vision feature-print comparison, VisionAnalysisService runs blur and exposure detection, and VideoCompressionService manages AVAssetExportSession-based compression. Every data flow is local and traceable through these four entry points.

Closed-Source Apps and the Trust Problem

The App Store hosts hundreds of photo cleanup utilities, and the overwhelming majority are closed source. Users install them, grant full photo library access — a permission that includes every image and video on the device — and hope for the best. This hope is frequently misplaced. Between 2022 and 2025, Apple removed over 400 apps from the App Store for undisclosed data collection practices, many of them in the photos and utilities category.

The business model of many closed-source photo apps is not the app itself — it is the data. A free app with no visible revenue stream must be monetizing something, and in the mobile ecosystem, that something is often you. Image metadata alone — timestamps, GPS coordinates, device models — creates a detailed behavioral profile. Even when an app claims to process photos locally, a closed binary makes that claim unverifiable. The app could be hashing your images and sending those hashes to a server for ad-targeting purposes without ever leaving a visible trace in the user interface.

Privacy policies offer limited protection. They are legal documents, not technical guarantees. A company can update its privacy policy with 30 days' notice, and continued use of the app constitutes acceptance. With an open source app like TidyByte, the code is the policy. It cannot be retroactively modified in the version on your device. You can verify the version you installed matches the source on GitHub by building from source yourself — a process that takes about two minutes with Xcode.

TidyByte's Architecture: Zero Network Calls

TidyByte's commitment to privacy is not a marketing claim — it is an architectural constraint baked into every line of code. The app is built on MVVM with actors and SwiftData, following a design where no service has the capability to communicate with the outside world. Let us walk through the key components to show how this works in practice.

The PhotoLibraryService is a Swift actor that wraps all PhotoKit operations. It fetches assets, reads metadata, loads images, and processes deletions — all through Apple's PHImageManager framework. It uses withCheckedContinuation to bridge PhotoKit's callback-based API to Swift's async/await model. At no point does it serialize data to disk or prepare it for transmission. The service's public interface exposes methods like fetchAssets(), loadImage(for:), and deleteAssets(_:) — none of which accept a URL or network endpoint parameter.

The DuplicateDetectionService performs two kinds of comparison. Exact duplicates are detected via SHA-256 hashing of file contents — a cryptographic operation that runs entirely on the CPU. Near-duplicates use Apple's Vision framework to generate feature prints, which are numerical vectors computed locally by the device's Neural Engine. These vectors are compared using cosine similarity, a mathematical operation that requires no external data. The entire duplicate detection pipeline — from hashing to feature extraction to comparison — completes on-device in seconds.

The VisionAnalysisService evaluates image quality metrics including blur detection and exposure analysis. It operates on CGImage inputs and returns value-type DTOs (Data Transfer Objects) that conform to Sendable, meaning they are safe to pass across actor boundaries but contain no references that could be used to reconstruct or transmit the original image. The VideoCompressionService uses AVAssetExportSession for re-encoding, writing output to a temporary file on the local filesystem that is cleaned up after the operation completes. Read more about these features on the features page.

The Broader Case for Open Source Utilities

TidyByte is part of a larger movement toward open source personal utilities — apps that handle sensitive data and therefore owe users radical transparency. This movement has accelerated as high-profile data breaches and surveillance scandals have eroded public trust in closed software. A 2025 survey by the Pew Research Center found that 79% of Americans are concerned about how companies use their personal data, up from 64% in 2019. An open source photo cleaner for iOS like TidyByte directly addresses this concern by making the data-handling logic inspectable.

The benefits extend beyond individual privacy. Open source utilities create educational value. Students and junior developers can study TidyByte's codebase to learn how professional iOS apps are structured: how actors provide thread safety without locks, how the @Observable macro replaces the older ObservableObject pattern, how SwiftData models persist state, and how Vision framework APIs perform on-device machine learning. This knowledge multiplier effect means that every open source project raises the overall quality bar for the ecosystem.

There is also a sustainability argument. Closed-source apps can be abandoned, acquired, or pivoted to ad-supported models without user consent. When TidyByte's code is on GitHub under the MIT license, anyone can fork it, maintain it, and build on it — even if the original maintainers move on. This forkability guarantee means that a tool you rely on today cannot be taken away tomorrow by a corporate decision you have no control over. For a utility as personal as a photo cleaner, that permanence matters.

How to Contribute to TidyByte

TidyByte welcomes contributions from developers, designers, translators, and users who encounter bugs or have feature ideas. The contribution process is straightforward and designed to be accessible even if you have never contributed to an open source project before.

For developers

Clone the repository from GitHub, open Tidybyte.xcodeproj in Xcode, and build for an iOS 17+ simulator. The project uses XcodeGen, so project.yml is the source of truth for build settings. There are zero third-party dependencies to install. Pick an open issue, create a feature branch, and submit a pull request with a clear description of the change. The CI pipeline runs on GitHub Actions and validates that the build succeeds with strict concurrency checks enabled.

For non-developers

You do not need to write code to contribute. Filing a detailed bug report on GitHub Issues is one of the most valuable contributions you can make. Include your device model, iOS version, steps to reproduce, and a screen recording if possible. Feature requests are equally welcome — describe the problem you are trying to solve, not just the solution you envision. Documentation improvements, typo fixes in the marketing site, and translations are all areas where non-technical contributors can have an outsized impact. Visit the support page for additional ways to get in touch.

Code of conduct and licensing

TidyByte is released under the MIT license, one of the most permissive open source licenses available. You can use the code in personal and commercial projects, modify it freely, and redistribute it with only an attribution requirement. All contributors are expected to engage respectfully and constructively. The project's goal is to build the best possible photo cleanup tool for iOS, and that requires a welcoming community where diverse perspectives are valued.

Frequently Asked Questions