diff --git a/.gitignore b/.gitignore
index eb9f77c..a40c297 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,3 +24,6 @@ Thumbs.db
 
 prompt.md
 WARP.md
+faststack/.mypy_cache/
+.mypy_cache/
+
diff --git a/faststack/ChangeLog.md b/faststack/ChangeLog.md
index 0207d97..8a0a896 100644
--- a/faststack/ChangeLog.md
+++ b/faststack/ChangeLog.md
@@ -1,5 +1,21 @@
 # ChangeLog
 
+## [0.9.0] - 2025-11-20
+
+### Performance Improvements
+- **Zero-Copy JPEG Read:** Eliminated memory copy by passing mmap directly to decoders, reducing I/O time by 25-60% for large JPEGs.
+- **Filter Performance:** Cached image list in memory to eliminate disk scans on every filter keystroke (100-1000x faster for large directories).
+- **Smart Cache Management:** Removed unnecessary cache clearing on resize/zoom - LRU naturally evicts old entries while allowing instant reuse.
+- **Generation Thrashing Fix:** Navigation no longer increments generation counter, preventing cache invalidation on every keystroke.
+- **Directional Prefetching:** Asymmetric prefetch now biases 70% ahead and 30% behind in travel direction for faster sequential browsing.
+- **ICC Transform Caching:** Cached ICC color transforms to eliminate repeated transform builds during color-managed viewing.
+- **TurboJPEG for ICC:** ICC color path now uses TurboJPEG for decode+resize, then Pillow only for color conversion.
+
+### Features
+- **JPG Fallback for Helicon:** Helicon Focus stacking now works with JPG-only workflows when RAW files absent.
+- **Comprehensive Timing Instrumentation:** Added detailed decode timing logs in debug mode for performance analysis.
+- **Added a Jump to Photo feature that can be activated by pressing the G key
+
 ## [0.8.0] - 2025-11-20
 
 ### Added
diff --git a/faststack/README.md b/faststack/README.md
index 71f2391..1cfc8e4 100644
--- a/faststack/README.md
+++ b/faststack/README.md
@@ -1,6 +1,6 @@
 # FastStack
 
-# Version 0.8 - November 20, 2025
+# Version 0.9 - November 20, 2025
 # By Alan Rockefeller
 
 Ultra-fast, caching JPG viewer designed for culling and selecting RAW files for focus stacking.
diff --git a/faststack/faststack/app.py b/faststack/faststack/app.py
index 38eba69..3945c46 100644
--- a/faststack/faststack/app.py
+++ b/faststack/faststack/app.py
@@ -39,7 +39,7 @@
 from faststack.io.helicon import launch_helicon_focus
 from faststack.io.executable_validator import validate_executable_path
 from faststack.imaging.cache import ByteLRUCache, get_decoded_image_size
-from faststack.imaging.prefetch import Prefetcher
+from faststack.imaging.prefetch import Prefetcher, clear_icc_caches
 from faststack.ui.provider import ImageProvider
 from faststack.ui.keystrokes import Keybinder
 
@@ -74,7 +74,8 @@ class ProgressReporter(QObject):
     def __init__(self, image_dir: Path, engine: QQmlApplicationEngine):
         super().__init__()
         self.image_dir = image_dir
-        self.image_files: List[ImageFile] = []
+        self.image_files: List[ImageFile] = []  # Filtered list for display
+        self._all_images: List[ImageFile] = []  # Cached full list from disk
         self.current_index: int = 0
         self.ui_refresh_generation = 0
         self.main_window: Optional[QObject] = None
@@ -89,7 +90,7 @@ def __init__(self, image_dir: Path, engine: QQmlApplicationEngine):
 
         # -- Backend Components --
         self.watcher = Watcher(self.image_dir, self.refresh_image_list)
-        self.sidecar = SidecarManager(self.image_dir, self.watcher)
+        self.sidecar = SidecarManager(self.image_dir, self.watcher, debug=_debug_mode)
         
         # -- Caching & Prefetching --
         cache_size_gb = config.getfloat('core', 'cache_size_gb', 1.5)
@@ -99,9 +100,11 @@ def __init__(self, image_dir: Path, engine: QQmlApplicationEngine):
             image_files=self.image_files,
             cache_put=self.image_cache.__setitem__,
             prefetch_radius=config.getint('core', 'prefetch_radius', 4),
-            get_display_info=self.get_display_info
+            get_display_info=self.get_display_info,
+            debug=_debug_mode
         )
         self.last_displayed_image: Optional[DecodedImage] = None  # Cache last image to avoid grey squares
+        self._last_image_lock = threading.Lock()  # Protect last_displayed_image from race conditions
 
         # -- UI State --
         self.ui_state = UIState(self)
@@ -128,6 +131,9 @@ def __init__(self, image_dir: Path, engine: QQmlApplicationEngine):
         self.resize_timer.timeout.connect(self._handle_resize)
         self.pending_width = None
         self.pending_height = None
+        
+        # Track if any dialog is open to disable keybindings
+        self._dialog_open = False
 
 
     @Slot(str)
@@ -140,7 +146,7 @@ def apply_filter(self, filter_string: str):
 
         self._filter_string = filter_string
         self._filter_enabled = True
-        self.refresh_image_list()
+        self._apply_filter_to_cached_list()  # Fast in-memory filtering
         self.dataChanged.emit()
         self.ui_state.filterStringChanged.emit()  # Notify UI of filter change
 
@@ -160,7 +166,7 @@ def clear_filter(self):
             return
         self._filter_enabled = False
         self._filter_string = ""
-        self.refresh_image_list()
+        self._apply_filter_to_cached_list()  # Fast in-memory filtering
         self.dataChanged.emit()
         self.ui_state.filterStringChanged.emit()  # Notify UI of filter change
         self.current_index = min(self.current_index, max(0, len(self.image_files) - 1))
@@ -189,7 +195,7 @@ def _handle_resize(self):
         log.info("Display size changed to: %dx%d (physical pixels)", self.pending_width, self.pending_height)
         self.display_width = self.pending_width
         self.display_height = self.pending_height
-        self.display_generation += 1
+        self.display_generation += 1  # Invalidates old entries via cache key
         
         # Mark display as ready after first size report
         is_first_resize = not self.display_ready
@@ -197,8 +203,7 @@ def _handle_resize(self):
             self.display_ready = True
             log.info("Display size now stable, enabling prefetch")
         
-        self.image_cache.clear()
-        self.prefetcher.cancel_all()
+        self.prefetcher.cancel_all()  # Cancel stale tasks to avoid wasted work
         
         # On first resize, execute deferred prefetch; on subsequent resizes, do normal prefetch
         if is_first_resize and self.pending_prefetch_index is not None:
@@ -214,36 +219,51 @@ def set_zoomed(self, zoomed: bool):
             return
         self.is_zoomed = zoomed
         log.info("Zoom state changed to: %s", zoomed)
-        self.display_generation += 1 # Invalidate cache
-        self.image_cache.clear()
-        self.prefetcher.cancel_all()
+        self.display_generation += 1  # Invalidates old entries via cache key
+        
+        # NOTE: We don't clear the cache here. The generation increment is enough.
+        # Cache keys include display_generation, so zoomed/unzoomed images become
+        # naturally unreachable and LRU will evict them. This lets us instantly
+        # reuse cached images if user toggles zoom on/off repeatedly.
+        self.prefetcher.cancel_all()  # Cancel stale tasks to avoid wasted work
         self.prefetcher.update_prefetch(self.current_index)
         self.sync_ui_state()
         self.ui_state.isZoomedChanged.emit()
 
     def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        # Don't handle key events when a dialog is open
+        if self._dialog_open:
+            return False
+            
         if watched == self.main_window and event.type() == QEvent.Type.KeyPress:
             handled = self.keybinder.handle_key_press(event)
             if handled:
                 return True
         return super().eventFilter(watched, event)
 
-    def _do_prefetch(self, index: int, is_navigation: bool = False):
+    def _do_prefetch(self, index: int, is_navigation: bool = False, direction: Optional[int] = None):
         """Helper to defer prefetch until display size is stable.
         
         Args:
             index: The index to prefetch around
             is_navigation: True if called from user navigation (arrow keys, etc.)
+            direction: 1 for forward, -1 for backward, None to use last direction
         """
+        # If navigation occurs during resize debounce, cancel timer and apply resize immediately
+        # to ensure prefetch uses correct dimensions
+        if is_navigation and self.resize_timer.isActive():
+            self.resize_timer.stop()
+            self._handle_resize()
+        
         if not self.display_ready:
             log.debug("Display not ready, deferring prefetch for index %d", index)
             self.pending_prefetch_index = index
             return
-        self.prefetcher.update_prefetch(index, is_navigation=is_navigation)
+        self.prefetcher.update_prefetch(index, is_navigation=is_navigation, direction=direction)
     
     def load(self):
         """Loads images, sidecar data, and starts services."""
-        self.refresh_image_list()
+        self.refresh_image_list()  # Initial scan from disk
         if not self.image_files:
             self.current_index = 0
         else:
@@ -258,25 +278,42 @@ def load(self):
 
 
     def refresh_image_list(self):
-        """Rescans the directory for images and applies the current filter."""
-        all_images = find_images(self.image_dir)
+        """Rescans the directory for images from disk and updates cache.
+        
+        This does a full disk scan and should only be called when:
+        - Application starts (load())
+        - Directory watcher detects file changes
+        - User explicitly refreshes
+        
+        For filtering, use _apply_filter_to_cached_list() instead.
+        """
+        self._all_images = find_images(self.image_dir)
+        self._apply_filter_to_cached_list()
+    
+    def _apply_filter_to_cached_list(self):
+        """Applies current filter to cached image list without disk I/O."""
         if self._filter_enabled and self._filter_string:
             needle = self._filter_string.lower()
             self.image_files = [
-                img for img in all_images
+                img for img in self._all_images
                 if needle in img.path.stem.lower()
             ]
         else:
-            self.image_files = all_images
+            self.image_files = self._all_images
 
         self.prefetcher.set_image_files(self.image_files)
         self._metadata_cache_index = (-1, -1) # Invalidate cache
         self.ui_state.imageCountChanged.emit()
 
     def get_decoded_image(self, index: int) -> Optional[DecodedImage]:
-        """Retrieves a decoded image, blocking until ready to ensure correct display."""
-        if not self.image_files: # Handle empty image list
-            log.warning("get_decoded_image called with empty image_files.")
+        """Retrieves a decoded image, blocking until ready to ensure correct display.
+        
+        This blocks the UI thread on cache miss, but that's acceptable for an image viewer
+        where users expect to see the correct image immediately. The prefetcher minimizes
+        cache misses by decoding adjacent images in advance.
+        """
+        if not self.image_files or index < 0 or index >= len(self.image_files):
+            log.warning("get_decoded_image called with empty image_files or out of bounds index.")
             return None
 
         _, _, display_gen = self.get_display_info()
@@ -285,7 +322,8 @@ def get_decoded_image(self, index: int) -> Optional[DecodedImage]:
         # Check cache first
         if cache_key in self.image_cache:
             decoded = self.image_cache[cache_key]
-            self.last_displayed_image = decoded
+            with self._last_image_lock:
+                self.last_displayed_image = decoded
             return decoded
         
         # Cache miss: need to decode synchronously to ensure correct image displays
@@ -293,7 +331,8 @@ def get_decoded_image(self, index: int) -> Optional[DecodedImage]:
             decode_start = time.perf_counter()
             log.info("Cache miss for index %d (gen: %d). Blocking decode.", index, display_gen)
         
-        future = self.prefetcher.submit_task(index, self.prefetcher.generation)
+        # Submit with priority=True to cancel pending prefetch tasks and free up workers
+        future = self.prefetcher.submit_task(index, self.prefetcher.generation, priority=True)
         if future:
             try:
                 # Wait for decode to complete (blocking but fast for JPEGs)
@@ -303,22 +342,27 @@ def get_decoded_image(self, index: int) -> Optional[DecodedImage]:
                     cache_key = f"{decoded_index}_{decoded_display_gen}"
                     if cache_key in self.image_cache:
                         decoded = self.image_cache[cache_key]
-                        self.last_displayed_image = decoded
+                        with self._last_image_lock:
+                            self.last_displayed_image = decoded
                         if _debug_mode:
                             elapsed = time.perf_counter() - decode_start
                             log.info("Decoded image %d in %.3fs", index, elapsed)
                         return decoded
             except concurrent.futures.TimeoutError:
-                log.error("Timeout decoding image at index %d", index)
-                return self.last_displayed_image
+                log.exception("Timeout decoding image at index %d", index)
+                with self._last_image_lock:
+                    return self.last_displayed_image
             except concurrent.futures.CancelledError:
                 log.warning("Decode cancelled for index %d", index)
-                return self.last_displayed_image
+                with self._last_image_lock:
+                    return self.last_displayed_image
             except Exception as e:
-                log.error("Error decoding image at index %d: %s", index, e)
-                return self.last_displayed_image
+                log.exception("Error decoding image at index %d", index)
+                with self._last_image_lock:
+                    return self.last_displayed_image
         
-        return self.last_displayed_image
+        with self._last_image_lock:
+            return self.last_displayed_image
 
     def sync_ui_state(self):
         """Forces the UI to update by emitting all state change signals."""
@@ -351,22 +395,54 @@ def sync_ui_state(self):
     def next_image(self):
         if self.current_index < len(self.image_files) - 1:
             self.current_index += 1
-            self._do_prefetch(self.current_index, is_navigation=True)
+            self._do_prefetch(self.current_index, is_navigation=True, direction=1)
             self.sync_ui_state()
 
     def prev_image(self):
         if self.current_index > 0:
             self.current_index -= 1
-            self._do_prefetch(self.current_index, is_navigation=True)
+            self._do_prefetch(self.current_index, is_navigation=True, direction=-1)
             self.sync_ui_state()
 
+    @Slot(int)
+    def jump_to_image(self, index: int):
+        """Jump to a specific image by index (0-based)."""
+        if 0 <= index < len(self.image_files):
+            direction = 1 if index > self.current_index else -1
+            self.current_index = index
+            self._do_prefetch(self.current_index, is_navigation=True, direction=direction)
+            self.sync_ui_state()
+            self.update_status_message(f"Jumped to image {index + 1}")
+        else:
+            log.warning("Invalid image index: %d", index)
+            self.update_status_message("Invalid image number")
+
+    def show_jump_to_image_dialog(self):
+        """Shows the jump to image dialog (called from keybinder)."""
+        if self.main_window and hasattr(self.main_window, 'show_jump_to_image_dialog'):
+            self.main_window.show_jump_to_image_dialog()
+        else:
+            log.warning("Cannot open jump to image dialog: main_window or function not available")
+    
+    @Slot()
+    def dialog_opened(self):
+        """Called when any dialog opens to disable global keybindings."""
+        self._dialog_open = True
+        log.debug("Dialog opened, disabling global keybindings")
+    
+    @Slot()
+    def dialog_closed(self):
+        """Called when any dialog closes to re-enable global keybindings."""
+        self._dialog_open = False
+        log.debug("Dialog closed, re-enabling global keybindings")
+
     def toggle_grid_view(self):
         log.warning("Grid view not implemented yet.")
 
     def get_current_metadata(self) -> Dict:
-        if not self.image_files:
+        if not self.image_files or self.current_index >= len(self.image_files):
             if not self._logged_empty_metadata:
-                log.debug("get_current_metadata: image_files is empty, returning {}.")
+                log.debug("get_current_metadata: image_files is empty or index out of bounds, returning {}.")
                 self._logged_empty_metadata = True
             return {}
         self._logged_empty_metadata = False
@@ -393,6 +469,8 @@ def get_current_metadata(self) -> Dict:
         return self._metadata_cache
 
     def toggle_current_flag(self):
+        if not self.image_files or self.current_index >= len(self.image_files):
+            return
         stem = self.image_files[self.current_index].path.stem
         meta = self.sidecar.get_metadata(stem)
         meta.flag = not meta.flag
@@ -401,6 +479,8 @@ def toggle_current_flag(self):
         self.dataChanged.emit()
 
     def toggle_current_reject(self):
+        if not self.image_files or self.current_index >= len(self.image_files):
+            return
         stem = self.image_files[self.current_index].path.stem
         meta = self.sidecar.get_metadata(stem)
         meta.reject = not meta.reject
@@ -434,46 +514,56 @@ def end_current_stack(self):
             log.warning("No stack start marked. Press '[' first.")
 
     def toggle_selection(self):
-        """Toggles the selection status of the current image's RAW file."""
-        if not self.image_files:
+        """Toggles the selection status of the current image's file (RAW if available, otherwise JPG)."""
+        if not self.image_files or self.current_index >= len(self.image_files):
             return
 
         image_file = self.image_files[self.current_index]
-        if image_file.raw_pair:
-            if image_file.raw_pair in self.selected_raws:
-                self.selected_raws.remove(image_file.raw_pair)
-                log.info("Removed %s from selection.", image_file.raw_pair.name)
-            else:
-                self.selected_raws.add(image_file.raw_pair)
-                log.info("Added %s to selection.", image_file.raw_pair.name)
-            
-            # In a real app, we'd update a selection indicator in the UI.
-            # For now, we just log and can use it for batch operations.
-            self.sync_ui_state() # This will trigger a UI refresh
+        # Use RAW if available, otherwise use JPG
+        file_to_select = image_file.raw_pair if image_file.raw_pair else image_file.path
+        
+        if file_to_select in self.selected_raws:
+            self.selected_raws.remove(file_to_select)
+            log.info("Removed %s from selection.", file_to_select.name)
+        else:
+            self.selected_raws.add(file_to_select)
+            log.info("Added %s to selection.", file_to_select.name)
+        
+        # In a real app, we'd update a selection indicator in the UI.
+        # For now, we just log and can use it for batch operations.
+        self.sync_ui_state() # This will trigger a UI refresh
 
 
     def launch_helicon(self):
-        """Launches Helicon Focus with selected RAWs or all RAWs in defined stacks."""
+        """Launches Helicon Focus with selected files (RAW preferred, JPG fallback) or stacks."""
         if self.selected_raws:
-            log.info("Launching Helicon with %d selected RAW files.", len(self.selected_raws))
-            self._launch_helicon_with_files(sorted(list(self.selected_raws)))
-            self.selected_raws.clear()
+            log.info("Launching Helicon with %d selected files.", len(self.selected_raws))
+            success = self._launch_helicon_with_files(sorted(list(self.selected_raws)))
+            if success:
+                self.selected_raws.clear()
 
         elif self.stacks:
             log.info("Launching Helicon for %d defined stacks.", len(self.stacks))
+            any_success = False
             for start, end in self.stacks:
-                raw_files_to_process = []
+                files_to_process = []
                 for idx in range(start, end + 1):
-                    if idx < len(self.image_files) and self.image_files[idx].raw_pair:
-                        raw_files_to_process.append(self.image_files[idx].raw_pair)
+                    if idx < len(self.image_files):
+                        img_file = self.image_files[idx]
+                        # Use RAW if available, otherwise use JPG
+                        file_to_use = img_file.raw_pair if img_file.raw_pair else img_file.path
+                        files_to_process.append(file_to_use)
                 
-                if raw_files_to_process:
-                    self._launch_helicon_with_files(raw_files_to_process)
+                if files_to_process:
+                    success = self._launch_helicon_with_files(files_to_process)
+                    if success:
+                        any_success = True
                 else:
-                    log.warning("No valid RAW files found for stack [%d, %d].", start, end)
+                    log.warning("No valid files found for stack [%d, %d].", start, end)
             
-            # clear_all_stacks() already emits stackSummaryChanged
-            self.clear_all_stacks()
+            # Only clear stacks if at least one launch succeeded
+            if any_success:
+                self.clear_all_stacks()
 
         else:
             log.warning("No selection or stacks defined to launch Helicon Focus.")
@@ -481,21 +571,26 @@ def launch_helicon(self):
 
         self.sync_ui_state()
 
-    def _launch_helicon_with_files(self, raw_files: List[Path]):
-        """Helper to launch Helicon with a specific list of files."""
-        log.info("Launching Helicon Focus with %d RAW files.", len(raw_files))
-        unique_raw_files = sorted(list(set(raw_files)))
-        success, tmp_path = launch_helicon_focus(unique_raw_files)
+    def _launch_helicon_with_files(self, files: List[Path]) -> bool:
+        """Helper to launch Helicon with a specific list of files (RAW or JPG).
+        
+        Returns:
+            True if Helicon was successfully launched, False otherwise.
+        """
+        log.info("Launching Helicon Focus with %d files.", len(files))
+        unique_files = sorted(list(set(files)))
+        success, tmp_path = launch_helicon_focus(unique_files)
         if success and tmp_path:
             # Schedule delayed deletion of the temporary file
             QTimer.singleShot(5000, lambda: self._delete_temp_file(tmp_path))
 
             # Record stacking metadata
             today = date.today().isoformat()
-            for raw_path in unique_raw_files:
+            for file_path in unique_files:
                 # Find the corresponding image file to get the stem
                 for img_file in self.image_files:
-                    if img_file.raw_pair == raw_path:
+                    # Match by either RAW pair or JPG path
+                    if img_file.raw_pair == file_path or img_file.path == file_path:
                         stem = img_file.path.stem
                         meta = self.sidecar.get_metadata(stem)
                         meta.stacked = True
@@ -503,12 +598,15 @@ def _launch_helicon_with_files(self, raw_files: List[Path]):
                         break
             self.sidecar.save()
             self._metadata_cache_index = (-1, -1) # Invalidate cache
+        
+        return success
 
     def _delete_temp_file(self, tmp_path: Path):
+        """Deletes the temporary file list passed to Helicon Focus."""
         if tmp_path.exists():
             try:
-                # os.remove(tmp_path)
-                log.info("Keeping temporary file: %s", tmp_path)
+                os.remove(tmp_path)
+                log.info("Deleted temporary file: %s", tmp_path)
             except OSError as e:
                 log.error("Error deleting temporary file %s: %s", tmp_path, e)
 
@@ -549,6 +647,10 @@ def check_path_exists(self, path):
 
     def get_cache_size(self):
         return config.getfloat('core', 'cache_size_gb')
+    
+    def get_cache_usage_gb(self):
+        """Returns current cache usage in GB."""
+        return self.image_cache.currsize / (1024**3)
 
     def set_cache_size(self, size):
         config.set('core', 'cache_size_gb', size)
@@ -595,6 +697,9 @@ def set_color_mode(self, mode: str):
         config.set('color', 'mode', mode)
         config.save()
         
+        # Clear ICC caches when color mode changes
+        clear_icc_caches()
+        
         # Clear cache and restart prefetcher to apply new color mode
         self.image_cache.clear()
         self.prefetcher.cancel_all()
@@ -750,13 +855,13 @@ def delete_current_image(self):
                 # Clear cache and invalidate display generation to force image reload
                 self.display_generation += 1
                 self.image_cache.clear()
-                # update_prefetch will handle cancelling stale tasks and incrementing generation
+                self.prefetcher.cancel_all()  # Cancel stale tasks since image list changed
                 self.prefetcher.update_prefetch(self.current_index)
                 self.sync_ui_state()
             
         except OSError as e:
             self.update_status_message(f"Delete failed: {e}")
-            log.exception(f"Failed to delete image: {e}")
+            log.exception("Failed to delete image")
 
     @Slot()
     def undo_delete(self):
@@ -803,13 +908,13 @@ def undo_delete(self):
             # Clear cache and invalidate display generation to force image reload
             self.display_generation += 1
             self.image_cache.clear()
-            # update_prefetch will handle cancelling stale tasks and incrementing generation
+            self.prefetcher.cancel_all()  # Cancel stale tasks since image list changed
             self.prefetcher.update_prefetch(self.current_index)
             self.sync_ui_state()
             
         except OSError as e:
             self.update_status_message(f"Undo failed: {e}")
-            log.exception(f"Failed to restore image: {e}")
+            log.exception("Failed to restore image")
             # Put it back in history if it failed
             self.delete_history.append((jpg_path, raw_path))
 
@@ -820,16 +925,25 @@ def shutdown(self):
         if self.recycle_bin_dir.exists():
             files_in_bin = list(self.recycle_bin_dir.glob("*"))
             if files_in_bin:
-                reply = QMessageBox.question(
-                    None,
-                    "Empty Recycle Bin?",
-                    f"There are {len(files_in_bin)} files in the recycle bin. Do you want to permanently delete them?",
-                    QMessageBox.Yes | QMessageBox.No,
-                    QMessageBox.No
-                )
+                file_count = len(files_in_bin)
+                msg_box = QMessageBox()
+                msg_box.setWindowTitle("Recycle Bin")
+                msg_box.setText(f"There are {file_count} files in the recycle bin.")
+                msg_box.setInformativeText("What would you like to do?")
                 
-                if reply == QMessageBox.Yes:
+                # Add custom buttons
+                delete_btn = msg_box.addButton("Delete Permanently", QMessageBox.YesRole)
+                restore_btn = msg_box.addButton(f"Restore {file_count} deleted files", QMessageBox.ActionRole)
+                keep_btn = msg_box.addButton("Keep in Recycle Bin", QMessageBox.NoRole)
+                
+                msg_box.setDefaultButton(keep_btn)
+                msg_box.exec()
+                
+                clicked_button = msg_box.clickedButton()
+                if clicked_button == delete_btn:
                     self.empty_recycle_bin()
+                elif clicked_button == restore_btn:
+                    self.restore_all_from_recycle_bin()
         
         # Clear QML context property to prevent TypeErrors during shutdown
         if self.engine:
@@ -851,8 +965,41 @@ def empty_recycle_bin(self):
             shutil.rmtree(self.recycle_bin_dir)
             self.delete_history.clear()
             log.info("Emptied recycle bin and cleared delete history")
-        except OSError as e:
-            log.exception(f"Failed to empty recycle bin: {e}")
+        except OSError:
+            log.exception("Failed to empty recycle bin")
+    
+    def restore_all_from_recycle_bin(self):
+        """Restores all files from recycle bin to working directory."""
+        if not self.recycle_bin_dir.exists():
+            return
+        
+        try:
+            files_in_bin = list(self.recycle_bin_dir.glob("*"))
+            restored_count = 0
+            
+            for file_in_bin in files_in_bin:
+                # Restore to original location (working directory)
+                dest_path = self.image_dir / file_in_bin.name
+                
+                # If file already exists, skip (don't overwrite)
+                if dest_path.exists():
+                    log.warning("File already exists, skipping: %s", dest_path)
+                    continue
+                
+                try:
+                    file_in_bin.rename(dest_path)
+                    restored_count += 1
+                    log.info("Restored %s from recycle bin", file_in_bin.name)
+                except OSError as e:
+                    log.error("Failed to restore %s: %s", file_in_bin.name, e)
+            
+            # Clear delete history since we restored everything
+            self.delete_history.clear()
+            
+            log.info("Restored %d files from recycle bin", restored_count)
+            
+        except OSError:
+            log.exception("Failed to restore files from recycle bin")
 
     @Slot()
     def edit_in_photoshop(self):
@@ -925,10 +1072,10 @@ def edit_in_photoshop(self):
             log.info("Launched Photoshop with: %s", command)
         except FileNotFoundError as e:
             self.update_status_message(f"Photoshop executable not found: {e}")
-            log.exception(f"Photoshop executable not found: {e}")
+            log.exception("Photoshop executable not found")
         except (OSError, subprocess.SubprocessError) as e:
             self.update_status_message(f"Failed to open in Photoshop: {e}")
-            log.exception(f"Error launching Photoshop: {e}")
+            log.exception("Error launching Photoshop")
 
     @Slot()
     def copy_path_to_clipboard(self):
@@ -1012,7 +1159,7 @@ def _get_stack_info(self, index: int) -> str:
                 break
         if not info and self.stack_start_index is not None and self.stack_start_index == index:
             info = "Stack Start Marked"
-        log.info("_get_stack_info for index %d: %s", index, info)
+        log.debug("_get_stack_info for index %d: %s", index, info)
         return info
 
     def get_stack_summary(self) -> str:
@@ -1024,7 +1171,7 @@ def get_stack_summary(self) -> str:
         return "; ".join(summary)
 
     def is_stacked(self) -> bool:
-        if not self.image_files:
+        if not self.image_files or self.current_index >= len(self.image_files):
             return False
         stem = self.image_files[self.current_index].path.stem
         meta = self.sidecar.get_metadata(stem)
diff --git a/faststack/faststack/benchmark_decode.py b/faststack/faststack/benchmark_decode.py
new file mode 100644
index 0000000..6a5b858
--- /dev/null
+++ b/faststack/faststack/benchmark_decode.py
@@ -0,0 +1,20 @@
+import mmap
+import time
+from pathlib import Path
+from faststack.imaging.jpeg import decode_jpeg_resized, TURBO_AVAILABLE
+
+print(f"TurboJPEG available: {TURBO_AVAILABLE}")
+
+test_image = Path(r"C:\Users\alanr\Pictures\Lightroom\2025\2025-11-14\20251114-PB140001-2.JPG")
+
+# Match the real code path with mmap
+iterations = 20
+start = time.perf_counter()
+for _ in range(iterations):
+    with open(test_image, "rb") as f:
+        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mmapped:
+            jpeg_bytes = mmapped[:]
+    decode_jpeg_resized(jpeg_bytes, 1920, 1080)
+elapsed = time.perf_counter() - start
+
+print(f"Average time (with mmap): {elapsed/iterations*1000:.1f}ms")
diff --git a/faststack/faststack/imaging/cache.py b/faststack/faststack/imaging/cache.py
index b760ceb..d0d4262 100644
--- a/faststack/faststack/imaging/cache.py
+++ b/faststack/faststack/imaging/cache.py
@@ -34,5 +34,12 @@ def get_decoded_image_size(item) -> int:
     # In the full app, this would also account for the QImage/QTexture.
     from faststack.models import DecodedImage
     if isinstance(item, DecodedImage):
-        return item.buffer.nbytes
+        # Handle both numpy arrays and memoryview buffers
+        if hasattr(item.buffer, 'nbytes'):
+            return item.buffer.nbytes
+        elif hasattr(item.buffer, '__len__'):
+            return len(item.buffer)
+        else:
+            # Fallback: compute from dimensions
+            return item.width * item.height * 3
     return 1 # Should not happen
diff --git a/faststack/faststack/imaging/prefetch.py b/faststack/faststack/imaging/prefetch.py
index 857f55c..ab2f394 100644
--- a/faststack/faststack/imaging/prefetch.py
+++ b/faststack/faststack/imaging/prefetch.py
@@ -3,6 +3,7 @@
 import logging
 import os
 import io
+import hashlib
 from concurrent.futures import ThreadPoolExecutor, Future
 from typing import List, Dict, Optional, Callable
 import mmap
@@ -11,7 +12,7 @@
 from PIL import Image as PILImage, ImageCms
 
 from faststack.models import ImageFile, DecodedImage
-from faststack.imaging.jpeg import decode_jpeg_rgb, decode_jpeg_resized
+from faststack.imaging.jpeg import decode_jpeg_rgb, decode_jpeg_resized, TURBO_AVAILABLE
 from faststack.config import config
 
 log = logging.getLogger(__name__)
@@ -23,6 +24,33 @@
 _monitor_profile_cache: Dict[str, Optional[ImageCms.ImageCmsProfile]] = {}
 _monitor_profile_warning_logged = False
 
+# Cache for ICC transforms to avoid rebuilding on every image
+_icc_transform_cache: Dict[tuple, ImageCms.ImageCmsTransform] = {}
+
+def get_icc_transform(src_profile: ImageCms.ImageCmsProfile, monitor_profile: ImageCms.ImageCmsProfile, 
+                      src_profile_key: str, monitor_profile_path: str):
+    """Get or create a cached ICC transform.
+    
+    Building transforms is expensive, so we cache them by stable keys:
+    - src_profile_key: SHA-256 digest of the embedded ICC bytes
+    - monitor_profile_path: file path to the monitor ICC profile
+    """
+    key = (src_profile_key, monitor_profile_path)
+    if key not in _icc_transform_cache:
+        _icc_transform_cache[key] = ImageCms.buildTransform(
+            src_profile, monitor_profile, "RGB", "RGB"
+        )
+        log.debug("Built new ICC transform for profile pair (src=%s, monitor=%s)", src_profile_key[:16], monitor_profile_path)
+    return _icc_transform_cache[key]
+
+def clear_icc_caches():
+    """Clear all ICC-related caches (profiles and transforms)."""
+    global _monitor_profile_cache, _icc_transform_cache, _monitor_profile_warning_logged
+    _monitor_profile_cache.clear()
+    _icc_transform_cache.clear()
+    _monitor_profile_warning_logged = False
+    log.info("Cleared ICC profile and transform caches")
+
 def get_monitor_profile():
     """Dynamically load monitor ICC profile based on current config.
     
@@ -49,11 +77,11 @@ def get_monitor_profile():
         profile = ImageCms.ImageCmsProfile(monitor_icc_path)
         log.debug("Loaded monitor ICC profile: %s", monitor_icc_path)
         _monitor_profile_cache[monitor_icc_path] = profile
-        return profile
     except (OSError, ImageCms.PyCMSError) as e:
         log.warning("Failed to load monitor ICC profile from %s: %s", monitor_icc_path, e)
         _monitor_profile_cache[monitor_icc_path] = None
-        return None
+    
+    return _monitor_profile_cache[monitor_icc_path]
 
 
 def apply_saturation_compensation(
@@ -99,14 +127,15 @@ def apply_saturation_compensation(
     rgb_region[:] = rgb.reshape(height, width * 3).astype(np.uint8)
 
 class Prefetcher:
-    def __init__(self, image_files: List[ImageFile], cache_put: Callable, prefetch_radius: int, get_display_info: Callable):
+    def __init__(self, image_files: List[ImageFile], cache_put: Callable, prefetch_radius: int, get_display_info: Callable, debug: bool = False):
         self.image_files = image_files
         self.cache_put = cache_put
         self.prefetch_radius = prefetch_radius
         self.get_display_info = get_display_info
+        self.debug = debug
         # Use CPU count for I/O-bound JPEG decoding
         # Rule of thumb: 2x CPU cores for I/O bound, 1x for CPU bound
-        optimal_workers = min((os.cpu_count() or 1) * 2, 8)  # Cap at 8
+        optimal_workers = min((os.cpu_count() or 1) * 2, 4)  # Cap at 4
         
         self.executor = ThreadPoolExecutor(
             max_workers=optimal_workers,
@@ -120,20 +149,36 @@ def __init__(self, image_files: List[ImageFile], cache_put: Callable, prefetch_r
         self._initial_radius = 2  # Small radius at startup to reduce cache thrash
         self._navigation_count = 0  # Track how many times user has navigated
         self._radius_expanded = False
+        
+        # Directional prefetching
+        self._last_navigation_direction: int = 1  # 1 = forward, -1 = backward
+        self._direction_bias: float = 0.7  # 70% of radius in travel direction
 
     def set_image_files(self, image_files: List[ImageFile]):
         if self.image_files != image_files:
             self.image_files = image_files
             self.cancel_all()
 
-    def update_prefetch(self, current_index: int, is_navigation: bool = False):
+    def update_prefetch(self, current_index: int, is_navigation: bool = False, direction: Optional[int] = None):
         """Updates the prefetching queue based on the current image index.
         
         Args:
             current_index: The index to prefetch around
             is_navigation: True if this is from user navigation (arrow keys, etc.)
+            direction: 1 for forward, -1 for backward, None to use last direction
         """
-        self.generation += 1
+        # NOTE: Generation is NOT incremented here. It only changes when display size,
+        # zoom state, or color mode changes - events that actually invalidate cached images.
+        # Navigation just shifts which indices to prefetch.
+        
+        # Clean up old generation entries to prevent memory leak
+        old_generations = [g for g in self._scheduled if g < self.generation]
+        for g in old_generations:
+            del self._scheduled[g]
+        
+        # Track navigation direction
+        if direction is not None:
+            self._last_navigation_direction = direction
         
         # Track navigation to expand radius after user starts moving
         if is_navigation:
@@ -145,134 +190,256 @@ def update_prefetch(self, current_index: int, is_navigation: bool = False):
         # Use smaller radius initially to reduce cache thrash before display size is stable
         effective_radius = self._initial_radius if not self._radius_expanded else self.prefetch_radius
         
-        log.debug("Updating prefetch for index %d, generation %d, radius %d", current_index, self.generation, effective_radius)
+        if self.debug:
+            log.info("Prefetch radius: initial=%d, configured=%d, effective=%d", 
+                     self._initial_radius, self.prefetch_radius, effective_radius)
+        
+        # Calculate asymmetric range based on direction
+        if self._last_navigation_direction > 0:  # Moving forward
+            behind = max(1, int(effective_radius * (1 - self._direction_bias)))
+            ahead = effective_radius - behind + 1
+        else:  # Moving backward
+            ahead = max(1, int(effective_radius * (1 - self._direction_bias)))
+            behind = effective_radius - ahead + 1
+        
+        start = max(0, current_index - behind)
+        end = min(len(self.image_files), current_index + ahead + 1)
+        
+        log.debug("Prefetch range: [%d, %d) for index %d (direction=%d, behind=%d, ahead=%d)", 
+                  start, end, current_index, self._last_navigation_direction, behind, ahead)
 
-        # Cancel stale futures
+        # Get scheduled set for current generation
+        scheduled = self._scheduled.setdefault(self.generation, set())
+        
+        # Cancel stale futures and remove from scheduled
         stale_keys = []
-        for index, future in self.futures.items():
-            if not self._is_in_prefetch_range(index, current_index, effective_radius):
-                future.cancel()
-                stale_keys.append(index)
+        for index, future in list(self.futures.items()):
+            if index < start or index >= end:
+                if future.cancel():
+                    stale_keys.append(index)
+                    scheduled.discard(index)  # Remove from scheduled set
         for key in stale_keys:
             del self.futures[key]
 
-        # Submit new tasks (with deduplication)
-        start = max(0, current_index - effective_radius)
-        end = min(len(self.image_files), current_index + effective_radius + 1)
+        # Submit new tasks - prioritize current image and direction of travel
         
-        wanted = set(range(start, end))
-        scheduled = self._scheduled.setdefault(self.generation, set())
-        new_indices = wanted - scheduled
-
-        for i in new_indices:
-            if i not in self.futures:
+        # Build priority order: current first, then in direction of travel
+        priority_order = [current_index]
+        if self._last_navigation_direction > 0:
+            priority_order.extend(range(current_index + 1, end))
+            priority_order.extend(range(current_index - 1, start - 1, -1))
+        else:
+            priority_order.extend(range(current_index - 1, start - 1, -1))
+            priority_order.extend(range(current_index + 1, end))
+        
+        for i in priority_order:
+            if i < 0 or i >= len(self.image_files):
+                continue
+            if i not in scheduled and i not in self.futures:
                 self.submit_task(i, self.generation)
                 scheduled.add(i)
 
-    def submit_task(self, index: int, generation: int) -> Optional[Future]:
-        """Submits a decoding task for a given index."""
+    def submit_task(self, index: int, generation: int, priority: bool = False) -> Optional[Future]:
+        """Submits a decoding task for a given index.
+        
+        Args:
+            index: Image index to decode
+            generation: Generation number for cache invalidation
+            priority: If True, cancels lower-priority pending tasks to free up workers
+        """
         if index in self.futures and not self.futures[index].done():
             return self.futures[index] # Already submitted
 
+        # For high-priority tasks (current image), cancel pending prefetch tasks
+        # to free up worker threads and reduce blocking time
+        if priority:
+            cancelled_count = 0
+            for task_index, future in list(self.futures.items()):
+                if task_index != index and not future.done() and future.cancel():
+                    cancelled_count += 1
+                    del self.futures[task_index]
+            if cancelled_count > 0:
+                log.debug("Cancelled %d pending prefetch tasks to prioritize index %d", cancelled_count, index)
+
         image_file = self.image_files[index]
         display_width, display_height, display_generation = self.get_display_info()
 
         future = self.executor.submit(self._decode_and_cache, image_file, index, generation, display_width, display_height, display_generation)
         self.futures[index] = future
-        log.debug("Submitted prefetch task for index %d", index)
+        log.debug("Submitted %s task for index %d", "priority" if priority else "prefetch", index)
         return future
 
     def _decode_and_cache(self, image_file: ImageFile, index: int, generation: int, display_width: int, display_height: int, display_generation: int) -> Optional[tuple[int, int]]:
         """The actual work done by the thread pool."""
-        local_generation = self.generation # Capture current generation for this worker
-
-        if generation != local_generation:
-            log.debug("Skipping stale task for index %d (gen %d != %d)", index, generation, local_generation)
+        import time
+        
+        t_start = time.perf_counter()
+        
+        # Early check: if generation has already advanced since this task was submitted, skip it
+        if generation != self.generation:
+            log.debug("Skipping stale task for index %d (submitted gen %d != current gen %d)", index, generation, self.generation)
             return None
 
         try:
             # Get current color management mode
             color_mode = config.get('color', 'mode', fallback="none").lower()
 
-            # Option C: Full ICC pipeline with Pillow
+            # Option C: Full ICC pipeline - Use TurboJPEG for decode, Pillow only for ICC conversion
             if color_mode == "icc":
                 monitor_profile = get_monitor_profile()
+                monitor_icc_path = config.get('color', 'monitor_icc_path', fallback="").strip()
                 
                 if monitor_profile is not None:
-                    img = PILImage.open(str(image_file.path))
+                    # FAST: Use TurboJPEG for decode + resize
+                    t_before_read = time.perf_counter()
+                    with open(image_file.path, "rb") as f:
+                        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mmapped:
+                            # Pass mmap directly - no copy! Decoders accept bytes-like objects
+                            buffer = decode_jpeg_resized(mmapped, display_width, display_height)
+                    t_after_read = time.perf_counter()
+                    if buffer is None:
+                        return None
+                    t_after_decode = time.perf_counter()
                     
-                    # Resize before color conversion for speed
-                    if display_width > 0 and display_height > 0:
-                        img.thumbnail((display_width, display_height), PILImage.Resampling.LANCZOS)
+                    # Convert numpy array to PIL Image for ICC conversion
+                    img = PILImage.fromarray(buffer)
+                    t_after_array_to_pil = time.perf_counter()
                     
-                    # Extract embedded ICC profile or assume sRGB
-                    icc_bytes = img.info.get("icc_profile")
-                    src_profile = None
+                    # Extract ICC profile from original file (need to read header only)
+                    t_before_profile_read = time.perf_counter()
+                    with PILImage.open(image_file.path) as orig:
+                        icc_bytes = orig.info.get("icc_profile")
+                    t_after_profile_read = time.perf_counter()
                     
+                    src_profile = None
+                    src_profile_key = None
                     if icc_bytes:
                         try:
                             src_profile = ImageCms.ImageCmsProfile(io.BytesIO(icc_bytes))
+                            # Compute stable key: SHA-256 digest of ICC bytes
+                            src_profile_key = hashlib.sha256(icc_bytes).hexdigest()
                             log.debug("Using embedded ICC profile from %s", image_file.path)
                         except (OSError, ImageCms.PyCMSError, ValueError) as e:
                             log.warning("Failed to parse ICC profile from %s: %s", image_file.path, e)
                     
                     if src_profile is None:
                         src_profile = SRGB_PROFILE
+                        # Use a constant key for sRGB since it's always the same
+                        src_profile_key = "srgb_builtin"
                         log.debug("No embedded profile, assuming sRGB for %s", image_file.path)
                     
-                    # Convert from source profile to monitor profile
-                    log.debug("Converting image from source to monitor profile")
-                    img = ImageCms.profileToProfile(
-                        img,
-                        src_profile,
-                        monitor_profile,
-                        outputMode="RGB",
-                    )
-                    
-                    rgb = np.array(img, dtype=np.uint8)
-                    h, w, _ = rgb.shape
-                    bytes_per_line = w * 3
-                    arr = rgb.reshape(-1).copy()
+                    # Convert from source profile to monitor profile using cached transform
+                    try:
+                        log.debug("Converting image from source to monitor profile")
+                        t_before_icc = time.perf_counter()
+                        transform = get_icc_transform(src_profile, monitor_profile, src_profile_key, monitor_icc_path)
+                        # Alan 11-20-25 - Add inPlace=True to speed up copy, shouldn't have many negative effects
+                        ImageCms.applyTransform(img, transform, inPlace=True)
+                        t_after_icc = time.perf_counter()
+                        
+                        rgb = np.array(img, dtype=np.uint8)
+                        h, w, _ = rgb.shape
+                        bytes_per_line = w * 3
+                        arr = rgb.reshape(-1).copy()
+                        t_after_copy = time.perf_counter()
+                        
+                        if self.debug:
+                            decoder = "TurboJPEG" if TURBO_AVAILABLE else "Pillow"
+                            log.info("ICC decode timing for index %d (%s): read=%.3fs, decode=%.3fs, array_to_pil=%.3fs, profile_read=%.3fs, icc=%.3fs, copy=%.3fs, total=%.3fs, size=%dx%d",
+                                     index, decoder, t_after_read - t_before_read, t_after_decode - t_after_read,
+                                     t_after_array_to_pil - t_after_decode, t_after_profile_read - t_before_profile_read,
+                                     t_after_icc - t_before_icc, t_after_copy - t_after_icc,
+                                     t_after_copy - t_start, w, h)
+                    except (OSError, ImageCms.PyCMSError, ValueError) as e:
+                        # ICC conversion failed, fall back to standard decode
+                        log.warning("ICC profile conversion failed for %s: %s, falling back to standard decode", image_file.path, e)
+                        t_before_fallback_read = time.perf_counter()
+                        with open(image_file.path, "rb") as f:
+                            with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mmapped:
+                                # Pass mmap directly - no copy!
+                                buffer = decode_jpeg_resized(mmapped, display_width, display_height)
+                        t_after_fallback_read = time.perf_counter()
+                        if buffer is None:
+                            return None
+                        t_after_fallback_decode = time.perf_counter()
+                        
+                        h, w, _ = buffer.shape
+                        bytes_per_line = w * 3
+                        arr = buffer.reshape(-1).copy()
+                        
+                        if self.debug:
+                            decoder = "TurboJPEG" if TURBO_AVAILABLE else "Pillow"
+                            log.info("ICC fallback decode timing for index %d (%s): read=%.3fs, decode=%.3fs, total=%.3fs, size=%dx%d",
+                                     index, decoder, t_after_fallback_read - t_before_fallback_read,
+                                     t_after_fallback_decode - t_after_fallback_read,
+                                     t_after_fallback_decode - t_start, w, h)
                 else:
                     # Fall back to standard decode if ICC profile not available
                     log.warning("ICC mode selected but no monitor profile available, using standard decode")
+                    t_before_read = time.perf_counter()
                     with open(image_file.path, "rb") as f:
                         with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mmapped:
-                            jpeg_bytes = mmapped[:]
-                    
-                    buffer = decode_jpeg_resized(jpeg_bytes, display_width, display_height)
+                            # Pass mmap directly - no copy!
+                            buffer = decode_jpeg_resized(mmapped, display_width, display_height)
+                    t_after_read = time.perf_counter()
                     if buffer is None:
                         return None
+                    t_after_decode = time.perf_counter()
                     
                     h, w, _ = buffer.shape
                     bytes_per_line = w * 3
                     arr = buffer.reshape(-1).copy()
+                    
+                    if self.debug:
+                        decoder = "TurboJPEG" if TURBO_AVAILABLE else "Pillow"
+                        log.info("Standard decode timing (no ICC profile) for index %d (%s): read=%.3fs, decode=%.3fs, total=%.3fs, size=%dx%d",
+                                 index, decoder, t_after_read - t_before_read, t_after_decode - t_after_read,
+                                 t_after_decode - t_start, w, h)
             
             else:
                 # Standard decode path (Option A or no color management)
+                t_before_read = time.perf_counter()
                 with open(image_file.path, "rb") as f:
                     with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mmapped:
-                        jpeg_bytes = mmapped[:]
-                
-                buffer = decode_jpeg_resized(jpeg_bytes, display_width, display_height)
+                        # Pass mmap directly - no copy! Decoders accept bytes-like objects
+                        buffer = decode_jpeg_resized(mmapped, display_width, display_height)
+                t_after_read = time.perf_counter()
                 if buffer is None:
                     return None
+                t_after_decode = time.perf_counter()
                     
                 h, w, _ = buffer.shape
                 bytes_per_line = w * 3
                 arr = buffer.reshape(-1).copy()
+                t_after_copy = time.perf_counter()
                 
                 # Option A: Saturation compensation
                 if color_mode == "saturation":
                     try:
+                        t_before_saturation = time.perf_counter()
                         factor = float(config.get('color', 'saturation_factor', fallback="1.0"))
                         apply_saturation_compensation(arr, w, h, bytes_per_line, factor)
+                        t_after_saturation = time.perf_counter()
+                        
+                        if self.debug:
+                            decoder = "TurboJPEG" if TURBO_AVAILABLE else "Pillow"
+                            log.info("Saturation decode timing for index %d (%s): read=%.3fs, decode=%.3fs, copy=%.3fs, saturation=%.3fs, total=%.3fs, size=%dx%d",
+                                     index, decoder, t_after_read - t_before_read, t_after_decode - t_after_read,
+                                     t_after_copy - t_after_decode, t_after_saturation - t_before_saturation,
+                                     t_after_saturation - t_start, w, h)
                     except (ValueError, AssertionError) as e:
                         log.warning("Failed to apply saturation compensation: %s", e)
+                else:
+                    # No color management - log standard timing
+                    if self.debug:
+                        decoder = "TurboJPEG" if TURBO_AVAILABLE else "Pillow"
+                        log.info("Standard decode timing for index %d (%s): read=%.3fs, decode=%.3fs, copy=%.3fs, total=%.3fs, size=%dx%d",
+                                 index, decoder, t_after_read - t_before_read, t_after_decode - t_after_read,
+                                 t_after_copy - t_after_decode, t_after_copy - t_start, w, h)
             
-            # Re-check generation before caching
-            if self.generation != local_generation:
-                log.debug("Generation changed for index %d before caching. Skipping cache_put.", index)
+            # Re-check generation before caching (in case it changed during decode)
+            if self.generation != generation:
+                log.debug("Generation changed for index %d before caching (current gen %d != submitted gen %d). Skipping cache_put.", index, self.generation, generation)
                 return None
             
             decoded_image = DecodedImage(
@@ -287,8 +454,8 @@ def _decode_and_cache(self, image_file: ImageFile, index: int, generation: int,
             log.debug("Successfully decoded and cached image at index %d for display gen %d", index, display_generation)
             return index, display_generation
             
-        except Exception as e:
-            log.error("Error decoding image %s at index %d: %s", image_file.path, index, e)
+        except Exception:
+            log.exception("Error decoding image %s at index %d", image_file.path, index)
         
         return None
 
diff --git a/faststack/faststack/io/helicon.py b/faststack/faststack/io/helicon.py
index 8d7144a..08bd032 100644
--- a/faststack/faststack/io/helicon.py
+++ b/faststack/faststack/io/helicon.py
@@ -53,6 +53,7 @@ def launch_helicon_focus(raw_files: List[Path]) -> Tuple[bool, Optional[Path]]:
             tmp_path = Path(tmp.name)
 
         log.info(f"Temporary file for Helicon Focus: {tmp_path}")
+        log.info(f"Input files: {[str(f) for f in raw_files]}")
 
         # Build command list safely
         args = [helicon_exe, "-i", str(tmp_path.resolve())]
@@ -69,8 +70,8 @@ def launch_helicon_focus(raw_files: List[Path]) -> Tuple[bool, Optional[Path]]:
                 log.exception(f"Invalid helicon args format: {e}")
                 return False, None
 
-        log.info(f"Launching Helicon Focus with {len(raw_files)} files.")
-        log.info(f"Helicon Focus command: {args}") # Log the full command
+        log.info(f"Launching Helicon Focus with {len(raw_files)} files")
+        log.info(f"Command: {' '.join(args)}")
         
         # SECURITY: Explicitly disable shell execution
         subprocess.Popen(
diff --git a/faststack/faststack/io/indexer.py b/faststack/faststack/io/indexer.py
index 595c7c4..8fe9dbe 100644
--- a/faststack/faststack/io/indexer.py
+++ b/faststack/faststack/io/indexer.py
@@ -37,7 +37,7 @@ def find_images(directory: Path) -> List[ImageFile]:
                         raws[stem] = []
                     raws[stem].append((p, entry.stat()))
     except OSError as e:
-        log.error("Error scanning directory %s: %s", directory, e)
+        log.exception("Error scanning directory %s", directory)
         return []
 
     # Sort JPGs by filename
@@ -55,10 +55,10 @@ def find_images(directory: Path) -> List[ImageFile]:
     elapsed = time.perf_counter() - t_start
     paired_count = sum(1 for im in image_files if im.raw_pair)
     
-    # Log timing info if DEBUG level is enabled
     if log.isEnabledFor(logging.DEBUG):
-        log.info("find_images: found %d images in %.3fs", len(image_files), elapsed)
-    log.info("Found %d JPG files and paired %d with RAWs.", len(image_files), paired_count)
+        log.info("Found %d JPG files and paired %d with RAWs in %.3fs", len(image_files), paired_count, elapsed)
+    else:
+        log.info("Found %d JPG files and paired %d with RAWs.", len(image_files), paired_count)
     return image_files
 
 def _find_raw_pair(
@@ -76,7 +76,7 @@ def _find_raw_pair(
 
     for raw_path, raw_stat in potential_raws:
         dt = abs(jpg_stat.st_mtime - raw_stat.st_mtime)
-        if dt < min_dt:
+        if dt <= min_dt:
             min_dt = dt
             best_match = raw_path
 
diff --git a/faststack/faststack/io/sidecar.py b/faststack/faststack/io/sidecar.py
index 6f35d29..46128cc 100644
--- a/faststack/faststack/io/sidecar.py
+++ b/faststack/faststack/io/sidecar.py
@@ -11,9 +11,10 @@
 log = logging.getLogger(__name__)
 
 class SidecarManager:
-    def __init__(self, directory: Path, watcher):
+    def __init__(self, directory: Path, watcher, debug: bool = False):
         self.path = directory / "faststack.json"
         self.watcher = watcher
+        self.debug = debug
         self.data = self.load()
 
     def stop_watcher(self):
@@ -35,9 +36,7 @@ def load(self) -> Sidecar:
                 data = json.load(f)
             json_load_time = time.perf_counter() - t_start
             
-            # Import debug flag from app module
-            from faststack.app import _debug_mode
-            if _debug_mode:
+            if self.debug:
                 log.info(f"SidecarManager.load: json.load() took {json_load_time:.3f}s")
             
             if data.get("version") != 2:
@@ -65,7 +64,7 @@ def save(self):
         temp_path = self.path.with_suffix(".tmp")
         was_watcher_running = False
         try:
-            if self.watcher and self.watcher.is_alive():
+            if self.watcher and hasattr(self.watcher, 'is_alive') and self.watcher.is_alive():
                 self.stop_watcher()
                 was_watcher_running = True
             with temp_path.open("w") as f:
diff --git a/faststack/faststack/qml/FilterDialog.qml b/faststack/faststack/qml/FilterDialog.qml
index 92f0582..95926db 100644
--- a/faststack/faststack/qml/FilterDialog.qml
+++ b/faststack/faststack/qml/FilterDialog.qml
@@ -7,8 +7,9 @@ Dialog {
     title: "Filter Images"
     modal: true
     standardButtons: Dialog.Ok | Dialog.Cancel
-    width: 400
-    height: 200
+    closePolicy: Popup.CloseOnEscape
+    width: 500
+    height: 250
 
     property string filterString: ""
 
@@ -24,30 +25,30 @@ Dialog {
 
     contentItem: Column {
         spacing: 16
-        anchors.fill: parent
-        anchors.margins: 20
+        padding: 20
 
         Label {
             text: "Show only images whose filename contains:"
             wrapMode: Text.WordWrap
-            width: parent.width
+            width: parent.width - parent.padding * 2
         }
 
         TextField {
             id: filterField
-            text: filterDialog.filterString
             placeholderText: "Enter text to filter (e.g., 'stacked', 'IMG_001')..."
-            width: parent.width
+            width: parent.width - parent.padding * 2
+            height: 50
             selectByMouse: true
             focus: true
+            font.pixelSize: 16
+            verticalAlignment: TextInput.AlignVCenter
             
             onTextChanged: {
                 filterDialog.filterString = text
             }
             
-            Keys.onReturnPressed: {
-                filterDialog.accept()
-            }
+            Keys.onReturnPressed: filterDialog.accept()
+            Keys.onEnterPressed: filterDialog.accept()
         }
 
         Label {
@@ -55,7 +56,7 @@ Dialog {
             font.italic: true
             opacity: 0.7
             wrapMode: Text.WordWrap
-            width: parent.width
+            width: parent.width - parent.padding * 2
         }
     }
 
@@ -66,5 +67,12 @@ Dialog {
         filterField.text = filterDialog.filterString
         filterField.forceActiveFocus()
         filterField.selectAll()
+        // Notify Python that a dialog is open
+        controller.dialog_opened()
+    }
+    
+    onClosed: {
+        // Notify Python that dialog is closed
+        controller.dialog_closed()
     }
 }
diff --git a/faststack/faststack/qml/JumpToImageDialog.qml b/faststack/faststack/qml/JumpToImageDialog.qml
new file mode 100644
index 0000000..0b9fe4e
--- /dev/null
+++ b/faststack/faststack/qml/JumpToImageDialog.qml
@@ -0,0 +1,79 @@
+import QtQuick
+import QtQuick.Controls 2.15
+import QtQuick.Controls.Material 2.15
+import QtQuick.Layouts 1.15
+
+Dialog {
+    id: jumpDialog
+    title: "Jump to Image"
+    standardButtons: Dialog.Ok | Dialog.Cancel
+    modal: true
+    closePolicy: Popup.CloseOnEscape
+    width: 400
+
+    property int maxImageCount: 0
+
+    // Inherit Material theme from parent
+    Material.theme: uiState && uiState.theme === 0 ? Material.Dark : Material.Light
+    Material.accent: "#4fb360"
+
+    onOpened: {
+        imageNumberField.text = ""
+        imageNumberField.forceActiveFocus()
+        // Notify Python that a dialog is open
+        controller.dialog_opened()
+    }
+    
+    onClosed: {
+        // Notify Python that dialog is closed
+        controller.dialog_closed()
+    }
+
+    onAccepted: {
+        var num = parseInt(imageNumberField.text)
+        if (!isNaN(num) && num >= 1 && num <= maxImageCount) {
+            controller.jump_to_image(num - 1) // Convert 1-based to 0-based index
+        }
+    }
+
+    contentItem: Item {
+        implicitWidth: 400
+        implicitHeight: 100
+
+        ColumnLayout {
+            anchors.fill: parent
+            anchors.margins: 0
+            spacing: 20
+
+            Label {
+                text: "Enter image number (1-" + jumpDialog.maxImageCount + "):"
+                Layout.fillWidth: true
+                wrapMode: Text.WordWrap
+            }
+
+            TextField {
+                id: imageNumberField
+                Layout.preferredWidth: 100
+                Layout.preferredHeight: 40
+                Layout.alignment: Qt.AlignLeft
+                placeholderText: "Number"
+                font.pixelSize: 16
+                horizontalAlignment: TextInput.AlignHCenter
+                maximumLength: Math.max(1, Math.ceil(Math.log10(jumpDialog.maxImageCount + 1)))
+                selectByMouse: true
+                focus: true
+                validator: IntValidator {
+                    bottom: 1
+                    top: jumpDialog.maxImageCount
+                }
+                
+                Keys.onReturnPressed: jumpDialog.accept()
+                Keys.onEnterPressed: jumpDialog.accept()
+            }
+
+            Item {
+                Layout.fillHeight: true
+            }
+        }
+    }
+}
diff --git a/faststack/faststack/qml/Main.qml b/faststack/faststack/qml/Main.qml
index 4b61da5..5223ad6 100644
--- a/faststack/faststack/qml/Main.qml
+++ b/faststack/faststack/qml/Main.qml
@@ -16,6 +16,7 @@ ApplicationWindow {
     title: "FastStack"
 
     Material.theme: uiState.theme === 0 ? Material.Dark : Material.Light
+    Material.accent: "#4fb360"
 
     property bool isDarkTheme: uiState.theme === 0
     property color currentBackgroundColor: isDarkTheme ? "#000000" : "white"
@@ -320,6 +321,8 @@ ApplicationWindow {
         title: "Key Bindings"
         standardButtons: Dialog.Ok
         modal: true
+        closePolicy: Popup.CloseOnEscape
+        focus: true
         width: 500
         height: 600
 
@@ -331,12 +334,12 @@ ApplicationWindow {
             text: "<b>FastStack Keyboard and Mouse Commands</b><br><br>" +
                   "<b>Navigation:</b><br>" +
                   "&nbsp;&nbsp;J / Right Arrow: Next Image<br>" +
-                  "&nbsp;&nbsp;K / Left Arrow: Previous Image<br><br>" +
+                  "&nbsp;&nbsp;K / Left Arrow: Previous Image<br>" +
+                  "&nbsp;&nbsp;G: Jump to Image Number<br><br>" +
                   "<b>Viewing:</b><br>" +
                   "&nbsp;&nbsp;Mouse Wheel: Zoom in/out<br>" +
                   "&nbsp;&nbsp;Left-click + Drag: Pan image<br>" +
-                  "&nbsp;&nbsp;Ctrl+0: Reset zoom and pan to fit window<br>" +
-                  "&nbsp;&nbsp;G: Toggle Grid View (not implemented)<br><br>" +
+                  "&nbsp;&nbsp;Ctrl+0: Reset zoom and pan to fit window<br><br>" +
                   "<b>Rating & Stacking:</b><br>" +
                   "&nbsp;&nbsp;Space: Toggle Flag<br>" +
                   "&nbsp;&nbsp;X: Toggle Reject<br>" +
@@ -362,6 +365,8 @@ ApplicationWindow {
         title: "Stack Information"
         standardButtons: Dialog.Ok
         modal: true
+        closePolicy: Popup.CloseOnEscape
+        focus: true
         width: 400
         height: 300
 
@@ -382,11 +387,18 @@ ApplicationWindow {
     }
 
     FilterDialog {
-    id: filterDialog
-    onAccepted: {
-        controller.apply_filter(filterString)
+        id: filterDialog
+        onAccepted: {
+            controller.apply_filter(filterString)
+        }
     }
-}
 
+    JumpToImageDialog {
+        id: jumpToImageDialog
+        maxImageCount: uiState.imageCount
+    }
 
+    function show_jump_to_image_dialog() {
+        jumpToImageDialog.open()
+    }
 }
diff --git a/faststack/faststack/qml/SettingsDialog.qml b/faststack/faststack/qml/SettingsDialog.qml
index 809a375..65e3792 100644
--- a/faststack/faststack/qml/SettingsDialog.qml
+++ b/faststack/faststack/qml/SettingsDialog.qml
@@ -7,9 +7,28 @@ Dialog {
     title: "Settings"
     standardButtons: Dialog.Ok | Dialog.Cancel
     modal: true
+    closePolicy: Popup.CloseOnEscape
+    focus: true
     width: 600
     height: 600
 
+    // Live cache usage value (updated by timer)
+    property real cacheUsage: 0.0
+
+    onVisibleChanged: {
+        cacheUsageTimer.running = visible
+        if (visible) {
+            controller.dialog_opened()
+        } else {
+            controller.dialog_closed()
+        }
+    }
+    
+    onOpened: {
+        // Refresh text field when dialog opens with current value
+        cacheSizeField.text = settingsDialog.cacheSize.toFixed(1)
+    }
+
     property string heliconPath: ""
     property double cacheSize: 1.5
     property int prefetchRadius: 4
@@ -82,17 +101,27 @@ Dialog {
         TextField {
             id: cacheSizeField
             Layout.fillWidth: true
-            text: settingsDialog.cacheSize.toFixed(1) // Display with one decimal place
-            onTextChanged: {
+            
+            Component.onCompleted: {
+                text = settingsDialog.cacheSize.toFixed(1)
+            }
+            
+            onEditingFinished: {
                 var value = parseFloat(text)
                 if (!isNaN(value) && value >= 0.5 && value <= 16) {
                     settingsDialog.cacheSize = value
-                } else if (text === "") { // Handle empty text
-                    settingsDialog.cacheSize = 1.5 // Default to 1.5 if empty
+                    text = value.toFixed(1)  // Format it
+                } else {
+                    // Invalid input, reset to current value
+                    text = settingsDialog.cacheSize.toFixed(1)
                 }
             }
         }
-        Label {} // Placeholder
+        Label {
+            id: cacheUsageLabel
+            text: "In use: " + settingsDialog.cacheUsage.toFixed(2) + " GB"
+            color: "#1013e6"
+        }
 
         // Prefetch Radius
         Label { text: "Prefetch Radius:" }
@@ -131,4 +160,13 @@ Dialog {
             }
         }
     }
+
+    // Poll cache usage periodically while the dialog is open
+    Timer {
+        id: cacheUsageTimer
+        interval: 1000
+        repeat: true
+        running: false
+        onTriggered: settingsDialog.cacheUsage = uiState.get_cache_usage_gb()
+    }
 }
diff --git a/faststack/faststack/ui/keystrokes.py b/faststack/faststack/ui/keystrokes.py
index cd3327d..a79ca3d 100644
--- a/faststack/faststack/ui/keystrokes.py
+++ b/faststack/faststack/ui/keystrokes.py
@@ -21,9 +21,7 @@ def __init__(self, controller):
             Qt.Key_Right: "next_image",
             Qt.Key_K: "prev_image",
             Qt.Key_Left: "prev_image",
-
-            # View Mode
-            Qt.Key_G: "toggle_grid_view",
+            Qt.Key_G: "show_jump_to_image_dialog",
 
             # Metadata
             Qt.Key_Space: "toggle_current_flag",
@@ -67,7 +65,7 @@ def _call(self, method_name: str):
     def handle_key_press(self, event):
         key = event.key()
         text = event.text()
-        log.info(f"Key pressed: {key} ({text!r}) with modifiers {event.modifiers()}")
+        log.debug(f"Key pressed: {key} ({text!r}) with modifiers {event.modifiers()}")
 
         # Check for modifier + key combinations
         for (mapped_key, mapped_modifier), method_name in self.modifier_key_map.items():
diff --git a/faststack/faststack/ui/provider.py b/faststack/faststack/ui/provider.py
index ae7feca..2c6e800 100644
--- a/faststack/faststack/ui/provider.py
+++ b/faststack/faststack/ui/provider.py
@@ -274,6 +274,10 @@ def check_path_exists(self, path):
     @Slot(result=float)
     def get_cache_size(self):
         return self.app_controller.get_cache_size()
+    
+    @Slot(result=float)
+    def get_cache_usage_gb(self):
+        return self.app_controller.get_cache_usage_gb()
 
     @Slot(float)
     def set_cache_size(self, size):
diff --git a/faststack/pyproject.toml b/faststack/pyproject.toml
index d1a36fd..1098412 100644
--- a/faststack/pyproject.toml
+++ b/faststack/pyproject.toml
@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "faststack"
-version = "0.8"
+version = "0.9"
 authors = [
     { name="Alan Rockefeller", email="alanrockefeller@gmail.com" },
 ]