diff --git a/cull/CullApp.swift b/cull/CullApp.swift
index 7e1324b..e911e8e 100644
--- a/cull/CullApp.swift
+++ b/cull/CullApp.swift
@@ -6,7 +6,7 @@ struct CullApp: App {
     @State private var thumbnailCache = ThumbnailCache()
 
     var body: some Scene {
-        WindowGroup {
+        WindowGroup("Cull") {
             ContentView()
                 .environment(session)
                 .environment(thumbnailCache)
diff --git a/cull/Models/Photo.swift b/cull/Models/Photo.swift
index 7907ef2..ae28246 100644
--- a/cull/Models/Photo.swift
+++ b/cull/Models/Photo.swift
@@ -38,6 +38,9 @@ final class Photo: Identifiable {
     // Populated by ShotGrouper
     var captureDate: Date?
 
+    /// URL to use for image loading (thumbnails, previews) — prefers JPEG for decode speed
+    var imageURL: URL { pairedURL ?? url }
+
     var isRAW: Bool {
         guard let utType = UTType(filenameExtension: url.pathExtension) else { return false }
         return utType.conforms(to: .rawImage)
diff --git a/cull/Services/PhotoImporter.swift b/cull/Services/PhotoImporter.swift
index a50be4c..bd562dc 100644
--- a/cull/Services/PhotoImporter.swift
+++ b/cull/Services/PhotoImporter.swift
@@ -69,14 +69,35 @@ struct PhotoImporter {
 
         // Read EXIF dates + image metadata in parallel batches
         let formatter = exifDateFormatter
-        for batchStart in stride(from: 0, to: photos.count, by: 16) {
-            let batch = Array(photos[batchStart..<min(batchStart + 16, photos.count)])
-            await withTaskGroup(of: Void.self) { group in
-                for photo in batch {
+        let metadataInputs: [(Int, URL, URL?)] = photos.enumerated().map { (i, photo) in
+            (i, photo.url, photo.pairedURL)
+        }
+
+        for batchStart in stride(from: 0, to: metadataInputs.count, by: 16) {
+            let batch = Array(metadataInputs[batchStart..<min(batchStart + 16, metadataInputs.count)])
+            let results = await withTaskGroup(of: (Int, PhotoMetadata).self, returning: [(Int, PhotoMetadata)].self) { group in
+                for (index, url, pairedURL) in batch {
                     group.addTask {
-                        readAllMetadata(photo: photo, formatter: formatter)
+                        let meta = readAllMetadata(url: url, pairedURL: pairedURL, formatter: formatter)
+                        return (index, meta)
                     }
                 }
+                var collected: [(Int, PhotoMetadata)] = []
+                for await result in group {
+                    collected.append(result)
+                }
+                return collected
+            }
+            // Apply on main actor
+            for (index, meta) in results {
+                let photo = photos[index]
+                photo.captureDate = meta.captureDate
+                photo.pixelWidth = meta.pixelWidth
+                photo.pixelHeight = meta.pixelHeight
+                photo.fileSize = meta.fileSize
+                photo.pairedPixelWidth = meta.pairedPixelWidth
+                photo.pairedPixelHeight = meta.pairedPixelHeight
+                photo.pairedFileSize = meta.pairedFileSize
             }
         }
 
@@ -85,46 +106,56 @@ struct PhotoImporter {
         return ImportResult(photos: photos, paired: pairedCount)
     }
 
+    struct PhotoMetadata: Sendable {
+        var captureDate: Date?
+        var pixelWidth: Int = 0
+        var pixelHeight: Int = 0
+        var fileSize: Int64 = 0
+        var pairedPixelWidth: Int = 0
+        var pairedPixelHeight: Int = 0
+        var pairedFileSize: Int64 = 0
+    }
+
     /// Read all metadata from a single CGImageSource open — date, dimensions, file size, paired metadata
-    nonisolated private static func readAllMetadata(photo: Photo, formatter: DateFormatter) {
-        let url = photo.url
+    nonisolated private static func readAllMetadata(url: URL, pairedURL: URL?, formatter: DateFormatter) -> PhotoMetadata {
+        var meta = PhotoMetadata()
 
         // File size from filesystem
         if let attrs = try? FileManager.default.attributesOfItem(atPath: url.path),
            let size = attrs[.size] as? Int64 {
-            photo.fileSize = size
+            meta.fileSize = size
         }
 
         // Open image source once for date + dimensions
         if let source = CGImageSourceCreateWithURL(url as CFURL, nil),
            let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any] {
-            // Dimensions
             if let width = properties[kCGImagePropertyPixelWidth as String] as? Int,
                let height = properties[kCGImagePropertyPixelHeight as String] as? Int {
-                photo.pixelWidth = width
-                photo.pixelHeight = height
+                meta.pixelWidth = width
+                meta.pixelHeight = height
             }
-            // EXIF date
             if let exif = properties[kCGImagePropertyExifDictionary as String] as? [String: Any],
                let dateString = exif[kCGImagePropertyExifDateTimeOriginal as String] as? String {
-                photo.captureDate = formatter.date(from: dateString)
+                meta.captureDate = formatter.date(from: dateString)
             }
         }
 
         // Paired file metadata
-        if let pairedURL = photo.pairedURL {
+        if let pairedURL {
             if let attrs = try? FileManager.default.attributesOfItem(atPath: pairedURL.path),
                let size = attrs[.size] as? Int64 {
-                photo.pairedFileSize = size
+                meta.pairedFileSize = size
             }
             if let source = CGImageSourceCreateWithURL(pairedURL as CFURL, nil),
                let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any],
                let width = properties[kCGImagePropertyPixelWidth as String] as? Int,
                let height = properties[kCGImagePropertyPixelHeight as String] as? Int {
-                photo.pairedPixelWidth = width
-                photo.pairedPixelHeight = height
+                meta.pairedPixelWidth = width
+                meta.pairedPixelHeight = height
             }
         }
+
+        return meta
     }
 
     static func isRAWExtension(_ ext: String) -> Bool {
diff --git a/cull/Services/QualityAnalyzer.swift b/cull/Services/QualityAnalyzer.swift
index cec2da0..99ae4e4 100644
--- a/cull/Services/QualityAnalyzer.swift
+++ b/cull/Services/QualityAnalyzer.swift
@@ -184,7 +184,7 @@ struct QualityAnalyzer {
     }
 
     static func analyze(photo: Photo) async {
-        let url = photo.url
+        let url = photo.imageURL
         async let blur = analyzeBlur(imageURL: url)
         async let faces = analyzeFaces(imageURL: url)
 
diff --git a/cull/Services/ShotGrouper.swift b/cull/Services/ShotGrouper.swift
index b8e9bc5..f8993be 100644
--- a/cull/Services/ShotGrouper.swift
+++ b/cull/Services/ShotGrouper.swift
@@ -10,7 +10,8 @@ struct ShotGrouper {
     static let mergeTimeThreshold: TimeInterval = 5
 
     /// Feature print distance threshold for visual similarity (Revision 2, macOS 14+)
-    static let similarityThreshold: Float = 0.35
+    /// Higher = more lenient grouping (different framings of same scene)
+    static let similarityThreshold: Float = 0.6
 
     /// Full grouping: temporal + visual similarity + merge close shots
     static func group(photos: [Photo], progress: (@Sendable (Double) async -> Void)? = nil) async -> [PhotoGroup] {
@@ -22,7 +23,7 @@ struct ShotGrouper {
         var completed = 0.0
 
         // Step 2: Generate feature prints for all photos (batched to report smooth progress)
-        let fpWork: [(UUID, URL)] = photos.map { ($0.id, $0.url) }
+        let fpWork: [(UUID, URL)] = photos.map { ($0.id, $0.imageURL) }
         var featurePrintMap: [UUID: VNFeaturePrintObservation] = [:]
         let batchSize = 8
         for batchStart in stride(from: 0, to: fpWork.count, by: batchSize) {
diff --git a/cull/Services/ThumbnailCache.swift b/cull/Services/ThumbnailCache.swift
index ed31b69..0a2f8ca 100644
--- a/cull/Services/ThumbnailCache.swift
+++ b/cull/Services/ThumbnailCache.swift
@@ -38,20 +38,20 @@ final class ThumbnailCache {
 
     func thumbnail(for photo: Photo) async -> NSImage? {
         let key = photo.url.absoluteString
-        let url = photo.url
+        let loadURL = photo.imageURL
 
         if let cached = memoryCache.object(forKey: key as NSString) {
             return cached
         }
 
-        let diskPath = diskCacheURL.appendingPathComponent(stableDiskKey(for: url))
+        let diskPath = diskCacheURL.appendingPathComponent(stableDiskKey(for: photo.url))
         let pixelSize = maxPixelSize
 
         let image: NSImage? = await Task.detached(priority: .userInitiated) { () -> NSImage? in
             if let diskImage = NSImage(contentsOf: diskPath) {
                 return diskImage
             }
-            guard let extracted = Self.extractThumbnailSync(from: url, maxPixelSize: pixelSize) else { return nil }
+            guard let extracted = Self.extractThumbnailSync(from: loadURL, maxPixelSize: pixelSize) else { return nil }
             Self.saveToDisk(extracted, at: diskPath)
             return extracted
         }.value
@@ -69,10 +69,10 @@ final class ThumbnailCache {
             return cached
         }
 
-        let url = photo.url
+        let loadURL = photo.imageURL
 
         let image: NSImage? = await Task.detached(priority: .userInitiated) { () -> NSImage? in
-            Self.loadFullPreviewSync(from: url)
+            Self.loadFullPreviewSync(from: loadURL)
         }.value
 
         if let image {
@@ -89,8 +89,9 @@ final class ThumbnailCache {
         photos: [Photo],
         progress: (@Sendable (Double) async -> Void)? = nil
     ) async {
-        let thumbWork: [(String, URL)] = photos.map { photo in
-            (photo.url.absoluteString, photo.url)
+        // key = RAW url for cache identity, loadURL = JPEG when available for fast decode
+        let thumbWork: [(String, URL, URL)] = photos.map { photo in
+            (photo.url.absoluteString, photo.imageURL, photo.url)
         }
 
         let totalItems = Double(thumbWork.count)
@@ -104,13 +105,13 @@ final class ThumbnailCache {
             let batchEnd = min(batchStart + batchSize, thumbWork.count)
             let batch = Array(thumbWork[batchStart..<batchEnd])
             await withTaskGroup(of: (String, NSImage?).self) { group in
-                for (key, url) in batch {
-                    let diskPath = diskCache.appendingPathComponent(Self.stableDiskKey(for: url))
+                for (key, loadURL, cacheKeyURL) in batch {
+                    let diskPath = diskCache.appendingPathComponent(Self.stableDiskKey(for: cacheKeyURL))
                     group.addTask {
                         if let diskImage = NSImage(contentsOf: diskPath) {
                             return (key, diskImage)
                         }
-                        guard let extracted = Self.extractThumbnailSync(from: url, maxPixelSize: pixelSize) else {
+                        guard let extracted = Self.extractThumbnailSync(from: loadURL, maxPixelSize: pixelSize) else {
                             return (key, nil)
                         }
                         Self.saveToDisk(extracted, at: diskPath)
@@ -131,10 +132,10 @@ final class ThumbnailCache {
     }
 
     func preload(photos: [Photo]) {
-        let work: [(String, URL)] = photos.compactMap { photo in
+        let work: [(String, URL, URL)] = photos.compactMap { photo in
             let key = photo.url.absoluteString
             guard memoryCache.object(forKey: key as NSString) == nil else { return nil }
-            return (key, photo.url)
+            return (key, photo.imageURL, photo.url)
         }
         guard !work.isEmpty else { return }
 
@@ -146,13 +147,13 @@ final class ThumbnailCache {
             for batchStart in stride(from: 0, to: work.count, by: 8) {
                 let batch = Array(work[batchStart..<min(batchStart + 8, work.count)])
                 await withTaskGroup(of: (String, NSImage?).self) { group in
-                    for (key, url) in batch {
-                        let diskPath = diskCache.appendingPathComponent(Self.stableDiskKey(for: url))
+                    for (key, loadURL, cacheKeyURL) in batch {
+                        let diskPath = diskCache.appendingPathComponent(Self.stableDiskKey(for: cacheKeyURL))
                         group.addTask {
                             if let diskImage = NSImage(contentsOf: diskPath) {
                                 return (key, diskImage)
                             }
-                            guard let extracted = Self.extractThumbnailSync(from: url, maxPixelSize: pixelSize) else {
+                            guard let extracted = Self.extractThumbnailSync(from: loadURL, maxPixelSize: pixelSize) else {
                                 return (key, nil)
                             }
                             Self.saveToDisk(extracted, at: diskPath)
@@ -175,7 +176,7 @@ final class ThumbnailCache {
         progress: (@Sendable (Double) async -> Void)? = nil
     ) async {
         let work: [(String, URL)] = photos.map { photo in
-            (photo.url.absoluteString, photo.url)
+            (photo.url.absoluteString, photo.imageURL)
         }
 
         let totalItems = Double(work.count)
@@ -186,9 +187,9 @@ final class ThumbnailCache {
         for batchStart in stride(from: 0, to: work.count, by: batchSize) {
             let batch = Array(work[batchStart..<min(batchStart + batchSize, work.count)])
             await withTaskGroup(of: (String, NSImage?).self) { group in
-                for (key, url) in batch {
+                for (key, loadURL) in batch {
                     group.addTask {
-                        (key, Self.loadFullPreviewSync(from: url))
+                        (key, Self.loadFullPreviewSync(from: loadURL))
                     }
                 }
                 for await (key, image) in group {
@@ -213,7 +214,7 @@ final class ThumbnailCache {
         let work: [(String, URL)] = photos.compactMap { photo in
             let key = photo.url.absoluteString
             guard previewCache.object(forKey: key as NSString) == nil else { return nil }
-            return (key, photo.url)
+            return (key, photo.imageURL)
         }
         guard !work.isEmpty else { return }
 
@@ -224,10 +225,10 @@ final class ThumbnailCache {
                 guard !Task.isCancelled else { return }
                 let batch = Array(work[batchStart..<min(batchStart + 4, work.count)])
                 await withTaskGroup(of: (String, NSImage?).self) { group in
-                    for (key, url) in batch {
+                    for (key, loadURL) in batch {
                         group.addTask {
                             guard !Task.isCancelled else { return (key, nil) }
-                            return (key, Self.loadFullPreviewSync(from: url))
+                            return (key, Self.loadFullPreviewSync(from: loadURL))
                         }
                     }
                     for await (key, image) in group {
diff --git a/cull/Views/PhotoViewer.swift b/cull/Views/PhotoViewer.swift
index fcadc9c..413c7bb 100644
--- a/cull/Views/PhotoViewer.swift
+++ b/cull/Views/PhotoViewer.swift
@@ -137,9 +137,14 @@ struct PhotoViewer: View {
 
                         Spacer()
 
-                        Text(photo.url.lastPathComponent)
-                            .foregroundStyle(.white.opacity(0.6))
-                            .font(.caption)
+                        HStack(spacing: 6) {
+                            Text(photo.url.lastPathComponent)
+                            if let date = photo.captureDate {
+                                Text(date, format: .dateTime.month().day().year().hour().minute().second())
+                            }
+                        }
+                        .foregroundStyle(.white.opacity(0.6))
+                        .font(.caption)
                     }
                     .padding(.horizontal, 16)
                     .padding(.vertical, 10)