Reference app thumbnails freeze after editing files

You are using a reference image while designing. You realize the lighting is not quite right, so you open it in Photoshop, tweak the contrast, and save it back. The file on disk is updated. You switch back to your reference app expecting to see the new version and instead you see the old thumbnail, unchanged, frozen.

Most reference apps cache thumbnails for performance. Loading and decoding hundreds of images on every launch would be slow, so they generate thumbnails once and store them. The problem is that the cache has no way to know when the source file has changed. You edit the file in another app, but the reference app does not re-render the thumbnail. It still shows what the file looked like last time it indexed it.

At small scales this is an annoyance. At large scales — a working library where you are constantly adjusting references — it becomes a real workflow tax. You either spend time manually refreshing the cache or learn to work with stale thumbnails.

Why thumbnails get cached in the first place

Thumbnails need to be fast. A reference library with thousands of images cannot decode the full image every time you scroll. The app would be unusably slow. So reference managers generate a thumbnail when they first import or index an image, store it in a cache, and use that cached version for browsing and display.

This is a good optimization for the common case: you add an image to your reference library and never edit it. The thumbnail is fast, the reference manager is responsive, and everyone is happy.

The problem appears when you use your reference library as a working library — not just a place to collect reference images, but a place to organize and refine them. You open an image, make adjustments, save it back, and expect to see the result in the reference app. But the reference app is still showing the old cached version.

What happens when you rebuild the cache

When you realize the thumbnail is stale, your options are limited. Some reference apps have a "rebuild cache" or "refresh" button. Running it causes the app to scan all images, regenerate thumbnails, and update its index.

But rebuilding the cache is expensive. For a library with ten thousand images, it can take many minutes. For a library with one hundred thousand images, it can take hours.

Even worse, rebuilding does not solve the underlying problem. Once you rebuild the cache and go back to editing images, the cache becomes stale again. If you edit frequently, you end up in a cycle: edit, switch to the reference app, notice the thumbnail is old, rebuild the cache, wait for it to finish, try again.

Many people solve this by choosing not to edit their references. You gather your reference images, organize them, and then you stop. This works for a library where references are static, but it does not work for a working library where images get refined as the project evolves.

The difference between monitoring and caching

The fundamental difference comes down to two approaches:

Caching: The app generates thumbnails once, stores them, and assumes the files never change. If a file does change, the cache becomes stale. You must manually refresh to see the new version.

Monitoring: The app watches the file system for changes. If a file's modification time changes, the app re-renders the thumbnail in the background. You always see the current state of the file without any manual action.

Monitoring requires more work from the app. It has to watch thousands of files and respond instantly when any of them changes. But for a working library, it is the only approach that feels natural. You edit a file, save it, and switch to the reference app expecting to see the change already reflected.

Setting up a workflow with live thumbnails

If you are using a reference app that caches thumbnails, you have two options:

Accept the cache lag and schedule rebuilds. Rebuild the cache at the end of your work day or before you review your library. This keeps thumbnails reasonably current without constant manual refresh. But there is always a gap between when you edit a file and when the reference app knows about it.

Use a reference app that monitors file changes. Coii Ref watches the files you point it at. When a file's modification time changes, Coii Ref immediately knows the file has changed and re-renders the thumbnail in the background. You never have to think about it.

Many designers keep both tools running: the reference app with cached thumbnails stays fast for pure browsing, and a secondary monitoring system or folder view shows the current state of the files. This works but requires discipline. It is easy to forget which view is current.

When stale thumbnails become a real cost

Stale thumbnails are a minor annoyance if:

• You rarely edit your references. You gather them, organize them, and are done.
• Your reference library is small. Rebuilding the cache for a hundred images takes seconds.
• You edit references in batches. Edit many files, rebuild once, then browse for a while.

Stale thumbnails become a real workflow problem if:

• You frequently edit or refine references. A designer iterating on color references or cropping lighting studies edits dozens of times a day.
• Your library is large. Rebuilding the cache for fifty thousand images can take fifteen minutes.
• You need to see the effects of your edits immediately. Comparing before-and-after in the reference app requires thumbnails to be current.

At scale, the choice between a reference app that caches and one that monitors becomes the difference between a tool that supports your workflow and one that gets in your way.

Why Coii Ref does not have stale thumbnails

Coii Ref does not rebuild the entire cache. Instead, it watches the file system directly. When you edit an image file and save it, Coii Ref detects that the file has changed. It re-renders the thumbnail in the background, so when you switch back to the app, you see the updated image immediately.

This approach has a cost: the app has to stay awake and watch files. But that cost is paid once, for the entire library, rather than paid repeatedly every time you want to see a current thumbnail.

The benefit is that your reference library stays synchronized with your working files. Edit a reference, save it, switch to the app, and you see the result. No rebuild, no refresh, no manual action. The thumbnails are always current.

This becomes especially powerful with video references. If you are reviewing footage and making notes on clips, you want thumbnails to update as you trim or adjust the files. A system that would require rebuilding the cache after each trim is not practical for video work. A system that watches files automatically handles it.

Choosing a reference app based on thumbnail handling

When evaluating a reference manager, ask:

1. Does the app rebuild thumbnails automatically when files change, or do you have to manually refresh? If manual refresh, accept that you will spend time rebuilding caches and factor that into your choice.
2. How long does a full rebuild take for your library size? Test it with your actual library or ask the vendor for benchmarks. A thousand-image library that rebuilds in seconds is acceptable. A ten-thousand-image library that rebuilds in minutes becomes tedious.
3. Can you edit files in other apps while the reference app is running, and see updates immediately? This is the gold standard. If the answer is no, expect to do manual refreshes.

For a working library where images are actively refined, immediate thumbnail updates are not optional. They are the difference between a tool that supports your process and one that requires you to work around its limitations.

The time cost of manual refresh

Let's quantify what manual refresh costs over time. If you have a library of five thousand images and rebuilding the cache takes five minutes, and you rebuild it daily out of habit, that is twenty-five minutes a day, or more than two hours a week. Over a year, that is more than one hundred hours spent waiting for the cache to rebuild.

For a designer or photographer working with video, the cost is even higher. Video files are larger and slower to thumbnail. A library with thousands of video clips might take ten or fifteen minutes to rebuild. Do that once a day, every day, and you have lost a significant portion of your working time.

The cost calculation changes when you use an app that monitors files. The same rebinding that cost five minutes in the cache-based app costs zero minutes. The app handles it in the background while you work. Over a year, that is one hundred plus hours you got back to actually do work rather than wait for caches.

How file monitoring works in practice

When Coii Ref watches a folder, it uses the file system to detect changes. Each file has a modification timestamp. When you save an edited file, that timestamp changes. Coii Ref notices the change and regenerates the thumbnail for that one file in the background.

This happens instantly. You edit a file, save it, switch to Coii Ref, and the new thumbnail is already showing. There is no rebuild step, no manual refresh, no waiting. The app is simply responsive to the file system state.

For large libraries, this is dramatically faster than rebuilding because Coii Ref only regenerates thumbnails for files that changed. With a five-thousand-image library where you edited five files, only those five thumbnails regenerate. The app does not touch the other forty-nine hundred ninety-five.

Batch editing scenarios

The difference becomes most obvious when you batch-edit many files. In Photoshop, you might run a batch action that adjusts levels on a hundred reference images. With a cache-based reference app:

1. Run the batch action (takes a few minutes).
2. Switch to the reference app and see a hundred stale thumbnails.
3. Manually refresh or rebuild the cache (takes several minutes).
4. Wait for it to finish (more waiting).
5. The hundred thumbnails are now current.

With a file-monitoring app like Coii Ref:

1. Run the batch action (takes a few minutes).
2. Switch to the reference app and see a hundred thumbnails updating in real-time as Photoshop saves each edited file.
3. By the time the batch finishes, all thumbnails are current.
4. No rebuild, no refresh, no extra steps.

The second workflow is not just faster; it is more natural. You watch the updates happen and know the reference library is synchronized with your working files.

Choosing based on your editing frequency

If you rarely edit reference images — you gather them, organize them, and they remain static — a cache-based app is fine. The cost of rebuild is low and you encounter it rarely.

If you frequently edit or refine images — color adjustments, cropping, annotations — file monitoring is not optional. It is the difference between a tool that supports your workflow and one that becomes a bottleneck. A designer iterating on lighting references might edit dozens of times an hour. Rebuilding the cache each time is not practical.

The line is roughly around "how often do you expect to edit a reference after adding it to the library." Once a week? Cache-based is fine. Once a day? Start thinking about file monitoring. Multiple times an hour? You need file monitoring or you will lose time to cache rebuilds.

Migration and setting up for success

If you are moving from a reference app with cached thumbnails to one that monitors files:

1. Your existing reference library works immediately. No rebuild, no import needed. Point Coii Ref at your reference folder and it indexes everything in a first pass.
2. From that point on, edit your files in any app you prefer. When you save, Coii Ref notices and updates thumbnails automatically.
3. You may see a small lag the first time you edit a file — the thumbnail regeneration happens in the background — but you never have to rebuild the entire cache.
4. For batch operations, you watch the thumbnails update as Photoshop or your editor saves files. The reference library stays synchronized with your working files.

This removes an entire category of workflow friction. The time you save by not rebuilding caches accumulates to hours over months of work. More importantly, your reference library becomes a living, synchronized view of your current reference collection rather than a snapshot that gradually becomes stale.

Read how to organize reference images on Mac for strategies that work with live editing and constantly changing files. The use case for character designers shows how visual development benefits from immediate thumbnail updates. For comprehensive comparison, see Coii Ref vs Eagle, which covers both the cache behavior and the broader difference between how the apps handle working libraries. And how to write notes on reference images pairs well with live editing — take notes that stay synchronized with constantly evolving reference images. For a broader perspective on choosing reference tools, see best reference apps that don't copy your files, which avoids the entire import-and-cache problem. If you work with video, how to organize video references shows how file monitoring matters even more for video than for still images.

The 30-day trial comes with every feature, so you can test file editing and thumbnail updates with your own reference library at no cost. You will quickly see whether the difference matters to your workflow and whether you are someone who benefits from live thumbnail synchronization across your entire working process.