Why Affinity Photo crashed when opening large RAW files with EXIF parse errors and the metadata strip + reimport that preserved edits 

Editing photos in high-resolution RAW format is essential for professional photographers and hobbyists who demand maximum quality and editing flexibility. But encountering unexpected errors or crashes while working in apps like Affinity Photo can be frustrating. One particular issue that some users have faced is Affinity Photo crashing when attempting to open large RAW files—especially those with corrupted or non-standard EXIF data. This article dives deep into the technical reasons behind this problem and how a smart workaround involving metadata stripping and reimporting can not only solve the issue but also preserve your edits.

TL;DR (Too Long; Didn’t Read)

Affinity Photo tends to crash when opening large RAW files that contain improperly formatted or corrupted EXIF metadata. This often occurs due to malformed entries delivered by camera firmware or external edits. A solution involves stripping the problematic metadata and reimporting the file after cleanup—a process that, when done carefully, can retain your existing editing layers and adjustments. It’s a rare but impactful issue with a surprisingly manageable fix.

Why RAW Files Matter—and Why They Break Things

RAW files hold the unprocessed image data straight from your camera sensor. This means you’re working with the highest fidelity available—but also increases the size and complexity of the file structure. Here’s why this complexity matters:

• RAW files can range from 25MB to over 150MB, depending on your camera model and bit depth.
• They contain not only image data but also embedded information like camera settings, timestamps, lens details, and 3D color profiles, stored in metadata blocks.
• Metadata formats like EXIF, IPTC, and XMP are standards, but manufacturers may implement them differently or incompletely.

All this embedded information makes RAW great for detailed work but also prime territory for software hiccups—especially when that metadata isn’t formatted correctly.

EXIF Parse Errors: The Unexpected Villains

EXIF (Exchangeable Image File Format) metadata is crucial for editing programs to understand how a photo was originally shot. However, when this data is malformed—be it due to a hardware bug, rushed firmware update, or software that didn’t correctly update the metadata—a “parse error” can occur.

So what exactly is a parse error? Simply put, it’s a failure that occurs when Affinity Photo (or any application) tries to interpret the metadata values and encounters unexpected tokens, missing fields, or corrupted binary data. This isn’t just an error message—it’s a memory risk that can crash the app.

According to user reports and developer logs:

• Affinity Photo sometimes uses aggressive pre-parsing to speed up rendering for RAW previews.
• Malformed EXIF entries—especially GPS coordinates or custom tags—can trigger unrecoverable exceptions in memory allocation.
• Large RAW files exacerbate this, as higher memory usage leaves less room for fault tolerance.

Example: A RAW image taken on a drone might contain GPS metadata injected by third-party flying software. If that metadata field isn’t terminated correctly or contains a non-standard character, it could crash Affinity Photo on load.

The Crash Scenario

Let’s walk through what typically happens when this crash occurs:

1. You attempt to open a high-megapixel RAW file (e.g., 50MP .CR2 or .ARW) in Affinity Photo.
2. The app begins reading the image and attempts to parse metadata for the Develop persona.
3. Upon encountering malformed EXIF data, it throws a memory error—sometimes with no error message at all.
4. The application suddenly closes or locks up, occasionally affecting already open files.

Importantly, this crash happens before any UI controls are loaded, meaning you don’t even get the chance to reach the Develop panel or adjust the damage manually. That’s what makes a proactive metadata strip and reimport workaround so valuable.

The Workaround: Metadata Strip + Reimport

It might sound scary to remove metadata, especially when you’re concerned about preserving your soul-sweated edits. But here’s the secret: Affinity stores edits in its .afphoto file structure, which is separate from the RAW itself. Therefore, it’s quite possible to solve the crashing issue and bring the cleaned-up file back into your workflow—retaining your non-destructive edits and adjustment layers.

Step-by-Step Guide to Implement the Fix

1. Duplicate the Original File
   Never work directly on your only copy. Always duplicate your RAW file first.
2. Use Metadata Cleaning Tools
   Utilities like ExifTool or ImageMagick can remove only the problematic metadata types.
   • To strip EXIF using ExifTool, run: exiftool -all= yourfile.CR2
   • This removes all embedded metadata while preserving image data itself.
3. Reimport into Affinity Photo
   Open the now-cleaned RAW file. You should no longer see a crash.
4. Apply or Sync Edits (Optional)
   If you previously started editing, you can load the new file as a new layer into the old .afphoto project and align them. Most edits can then be applied selectively or globally via layer masks.

Alternative: Edit Metadata Manually

Instead of wiping all metadata, advanced users might opt to isolate only the corrupt tags. Using ExifTool again:

exiftool -gps:all= -xmp:creator= yourfile.CR2

This removes only the GPS and specific XMP data elements, often the culprits in bad EXIF generation.

Preserving Edits: The Good News

Affinity Photo’s strength lies in its non-destructive editing model housed inside the .afphoto document. If the original file was embedded or linked carefully, stripping metadata doesn’t have to mean losing your work.

In fact, if you re-import the cleaned-up file into your existing .afphoto project, you can do the following:

• Use the new file as a replacement background and keep all original adjustment layers.
• Apply blend modes to merge old edits with the corrected raw data.
• Retain masks, curves, gradients, and layer visibility—as these are project-level, not image-level data.

This is key to why this workaround isn’t a desperate hack—it’s a real method for fixing edge-case compatibility issues while keeping your workflow intact.

Are There Any Alternatives?

If Affinity Photo persistently crashes despite cleanup, consider converting your RAW files to the DNG format using Adobe’s free DNG Converter. The conversion process rebuilds metadata tables from scratch, offering a clean slate that Affinity is much more likely to tolerate.

Another option is importing the file into a different raw processor (like Lightroom or Capture One), exporting as TIFF, and then moving to Affinity. While this avoids the EXIF problem entirely, it will flatten your adjustments and remove the benefit of non-destructive editing in Affinity’s raw persona.

Conclusion

When powerful tools encounter unpredictable data formats, crashes can and do happen. The large size and complexity of RAW files combined with inconsistent EXIF metadata create a perfect storm for bugs in complex photo editors like Affinity Photo. Fortunately, with a little technical know-how, users can strip out the problematic data and reintroduce the cleaned files into their projects—without losing all the creativity and hard work they’ve already put in.

This solution highlights a broader theme in digital creativity: understanding your tools deeply enables smarter problem-solving. And for those who work with RAW daily, having tools like ExifTool and knowing when and how to use them can be the difference between a crashed app and a completed masterpiece.