Queryable: Offline Natural-Language Photo Search for iOS Using Apple's MobileCLIP

What Queryable does and who it is for

The iOS Photos app organizes images by date, album and a category-based AI search that recognizes objects and scenes. That approach works well for finding all photos containing dogs or beaches but struggles with more specific or compositional descriptions. Queryable replaces the category model with a CLIP-style embedding search that understands natural language at the sentence level.

A user with ten years of photos spread across a library of thousands of images can type a brown dog sitting on a bench or a sunset over the ocean with a sailboat and get relevant results without manually tagging or organizing anything. The README states the use case directly: unlike the category-based search model built into the iOS Photos app, Queryable allows natural language statements.

The privacy motivation is equally explicit. The README notes that because Queryable is offline, album privacy is not compromised by any company, including Apple or Google. All model inference runs on the device without sending images to a server.

The primary audience is iOS users with large photo libraries who find the built-in search limiting and are willing to build or install a third-party app for better search quality. The source code is available for developers who want to understand how CLIP-style models are deployed to iOS hardware.

How MobileCLIP runs on-device for photo search

CLIP (Contrastive Language-Image Pretraining) works by encoding both images and text into a shared vector space. Images that match a text description end up close together in that space. Queryable implements this as a two-encoder system on iOS.

At setup time, the app runs the ImageEncoder over every photo in the library, computes a vector for each image and saves those vectors to local storage. This is the index-building step. When a user types a query, the app runs the TextEncoder on the query text to get a text vector, then compares it to every saved image vector using cosine similarity. The top K most similar images are returned as results.

The README describes the process in four steps: encode all photos with the image encoder, save the vectors, encode each new query with the text encoder, compare and rank. The models are exported to CoreML format, which runs on Apple's Neural Engine for hardware-accelerated inference.

The default model is Apple's MobileCLIP s2, which replaced the original OpenAI ViT-B/32 CLIP model in the September 2024 update. The README describes s2 as balancing efficiency and precision. The exported CoreML files are TextEncoder_mobileCLIP_s2.mlmodelc and ImageEncoder_mobileCLIP_s2.mlmodelc, available from a Google Drive link in the README.

Precision limitations are documented. The README notes that the CoreML export of the ImageEncoder has a certain level of precision error compared to the PyTorch model, and that more appropriate normalization parameters may be needed. A community contributor provided a HuggingFace conversion script that significantly reduced the precision error for the older CLIP model.

Building Queryable from source in Xcode

Building Queryable requires Xcode and the two CoreML model files. The README instructs:

1. Download TextEncoder_mobileCLIP_s2.mlmodelc and ImageEncoder_mobileCLIP_s2.mlmodelc from the Google Drive link. 2. Place both files under the CoreMLModels/ path in the cloned repository. 3. Open the project in Xcode and run it.

If you only want to run the app rather than modify it, the README suggests downloading the pre-exported models from Google Drive and skipping the CoreML export step entirely. For developers who want to export the models themselves, or adapt Queryable to support a different language or apply model quantization, the repository includes a Jupyter notebook (PyTorch2CoreML.ipynb) that demonstrates how to separate the TextEncoder and ImageEncoder, load the model weights individually, and export to CoreML.

A second notebook (PyTorch2CoreML-HuggingFace.ipynb) was contributed by a community member and converts the HuggingFace version of clip-vit-base-patch32. The README notes that this script significantly reduced the precision error in the image encoder compared to the original approach.

The repository structure is the Queryable/ Xcode project, the two Jupyter notebooks, a README and a LICENSE file. The project is intentionally minimal.

Limitations and platform constraints

Queryable requires iOS and Xcode for the source build. There is no Android version in this repository, though the README acknowledges an independent Android port named PicQuery by a community contributor (greyovo) that supports both English and Chinese. PicQuery is a separate repository.

For devices below iPhone 11, the app originally could not run due to Neural Engine limitations. A community contributor fixed this issue, and the fix is described in a linked pull request. The README does not detail the fix's mechanism but confirms it is resolved.

The ImageEncoder must process every photo in the library before search is usable. On a library of thousands of photos, this initial encoding step takes time. The README does not provide timing estimates. On slow hardware or with a very large library, this one-time setup cost may be noticeable.

The README notes an open issue about Queryable's performance on large libraries. Issue 6 and issue 10 in the repository discuss retrieval quality and performance at scale. These are not described as resolved in the README text.

The developer's disclaimer is candid: the README states explicitly that Queryable was written by someone who is not a professional iOS engineer and invites focus on the model loading, computation, storage and sorting logic rather than the Swift code quality. This is relevant for developers who want to use the codebase as a production reference.

CoreML export process for custom models or languages

The default models cover English queries. The README states that developers who want to support their own native language or do quantization or acceleration work can use the export process described in the notebooks.

The key architectural insight is that CLIP's TextEncoder and ImageEncoder must be separated at the architecture level before export. Standard CLIP checkpoints combine both in a single model. Queryable's PyTorch2CoreML.ipynb shows how to separate them, load each set of weights individually and export them as separate CoreML models.

For the MobileCLIP s2 model, the README points to a community comment in issue 45 for the specific export script, since the notebook covers the original OpenAI CLIP export.

The export produces CoreML models (.mlmodelc) that are consumed directly by the Xcode project. No further compilation step is needed. The precision error in the ImageEncoder export is a known issue, and the HuggingFace-based script in PyTorch2CoreML-HuggingFace.ipynb is the current recommended approach for reducing it.

Maintenance, licence and related projects

The last push to the repository was on 2026-03-29, which is exactly at the six-month boundary. The repository is not archived. There are no GitHub releases and no versioned changelog. The MobileCLIP support was added in a September 2024 update, and no further updates to the core encoding logic are documented in the README since then.

The project is licensed under MIT. The copyright is held by Ke Fang.

The README mentions three derivative or related projects: PicQuery, the Android port by greyovo available on Google Play; Searchable, a closed-source macOS version by yujinqiu that supports full-disk search; and a community contribution that fixed iPhone 11 and below compatibility. The README notes that the PicQuery source would be released in the future, citing the linked pull request.

A Discord server and a Reddit community (r/Queryable) are listed as contact channels for questions and suggestions.

Editorial conclusion

Queryable is a focused tool for a specific problem: searching a large iOS photo library with plain English phrases rather than categories or date filters. The privacy argument is concrete: the README states that all processing is offline and photos are never sent to any company, including Apple or Google. The current default model is MobileCLIP s2, which the README describes as balancing efficiency and precision. Building from source requires downloading the CoreML model files from Google Drive and placing them under CoreMLModels/. The App Store version removes that friction. The last push was on 2026-03-29, which is six months before today, so the repository is at the boundary of the maintenance threshold. There are no GitHub releases and no changelog.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. mazzzystar/Queryable on GitHub
4. Project website
5. README