diff --git a/handoff1-mimo.md b/handoff1-mimo.md
new file mode 100644
index 0000000..d01653a
--- /dev/null
+++ b/handoff1-mimo.md
@@ -0,0 +1,202 @@
+# HCIE-Rust v3.05 — Session Handoff Document
+
+**Date:** 2026-07-12
+**Session ID:** ses_0a89f4c7dffeLzqNKSKFHyyaI1
+
+---
+
+## Summary
+
+This session fixed critical engine bugs and completed iced GUI features for the HCIE-Rust image editor. The most significant fix was a fundamental architecture bug in the effects pipeline that caused new drawing strokes to disappear and effects to accumulate incorrectly.
+
+---
+
+## 1. Critical Engine Fixes (hcie-engine-api)
+
+### 1.1 Effects Pipeline — `layer.pixels` Corruption Fix (CRITICAL)
+
+**File:** `hcie-engine-api/src/partial_composite.rs` (line ~261)
+
+**Root Cause:**
+`apply_effects_and_sync_tiles()` wrote effects-applied pixels back to `layer.pixels`:
+```rust
+layer.pixels = processed; // BUG: corrupted raw drawing data
+```
+
+This caused a cascade of bugs:
+1. User draws stroke → `layer.pixels` = raw + stroke
+2. Effects pipeline runs → `layer.pixels` = effects(raw + stroke)
+3. User draws next stroke → `layer.pixels` = effects(raw + stroke1) + stroke2
+4. Effects pipeline restores from backup → `layer.pixels` = raw (stroke1+stroke2 LOST!)
+5. Effects applied → `layer.pixels` = effects(raw) → **strokes vanished**
+
+**Fix:** Removed `layer.pixels = processed`. Now `layer.pixels` always contains raw drawing data. The composite pipeline in `tiled.rs` reads from `effects_cache` when it exists (line 123), bypassing `layer.pixels` entirely for effect-bearing layers.
+
+**Impact:** Fixes ALL of the following:
+- New strokes disappearing after effects are applied
+- Effects accumulating (shadow-on-shadow stacking)
+- Toggle not working correctly (ON creating disabled styles)
+- Slider preview showing corrupted state
+
+### 1.2 `update_layer_style()` Missing Dirty Flags
+
+**File:** `hcie-engine-api/src/lib.rs` (line ~1720)
+
+**Root Cause:**
+`update_layer_style()` set `effects_dirty`, `dirty`, and `composite_dirty` but did NOT set:
+- `dirty_bounds` — caused full-canvas recomposite (~33MB for 4K) on every toggle
+- `below_cache_dirty` — risked stale below-layer composite cache
+
+**Fix:** Added:
+```rust
+let w = self.document.canvas_width;
+let h = self.document.canvas_height;
+self.document.dirty_bounds = Some([0, 0, w, h]);
+self.below_cache_dirty = true;
+```
+
+Same fix applied to `remove_layer_style_by_index()`.
+
+### 1.3 Stroke Drawing — `effects_dirty` During Strokes
+
+**File:** `hcie-engine-api/src/stroke_brush.rs` (4 locations)
+
+**Context:** `effects_dirty` is set during stroke drawing so the effects pipeline re-runs after the stroke ends. This is now safe because the effects pipeline no longer corrupts `layer.pixels` (fix 1.1).
+
+**Functions modified:**
+- `draw_brush_stroke` (line ~134)
+- `draw_brush_stroke` (line ~172)
+- `draw_pen_segment` (line ~203)
+- `draw_stroke` (line ~266)
+
+---
+
+## 2. Iced GUI Fixes (hcie-iced-gui)
+
+### 2.1 Layer Style Toggle Inversion
+
+**File:** `hcie-iced-app/crates/hcie-iced-gui/src/app.rs` (line ~1044)
+
+**Root Cause:**
+```rust
+enabled: existing.map_or(false, |s| matches!(s, LayerStyle::DropShadow { enabled, .. } if *enabled))
+```
+When style doesn't exist (`existing = None`), `map_or(false, ...)` returns `false`. First click ON created disabled style.
+
+**Fix:** Changed to explicit logic:
+- Style doesn't exist → `new_enabled = true` (first click enables)
+- Style exists → `new_enabled = !was_enabled` (toggle)
+
+### 2.2 Layer Style Panel — Draggable Floating Dialog
+
+**Files:**
+- `app.rs` — new state fields, messages, handlers
+- `panels/layer_styles.rs` — draggable title bar, X button, offset positioning
+
+**Implementation:**
+- Added `layer_style_offset: (f32, f32)`, `layer_style_dragging: bool`, `layer_style_drag_start: Option<(f32, f32)>` state
+- Added `LayerStyleDialogDragStart/Move/End` messages
+- Title bar uses `mouse_area.on_press()` to start drag
+- Global `iced::event::listen_with()` subscription tracks `CursorMoved` events during drag
+- Delta-based position tracking: each move event adds delta to offset
+- Dialog rendering uses `padding()` with offset to shift from center
+- X close button (`\u{2715}`) wired to `LayerStyleCancel`
+
+### 2.3 Layer Style Panel — Reopen Mechanism
+
+**Files:**
+- `panels/layers.rs` — "fx" button in toolbar
+- `panels/menus.rs` — "Layer Styles..." in Layer menu (index 4,7)
+- `app.rs` — menu action handler
+
+**Buttons:**
+- **"fx" button** in layers panel bottom toolbar → `Message::OpenLayerStyleDialog`
+- **Layer menu → "Layer Styles..."** → menu action (4,7) → `Message::OpenLayerStyleDialog`
+- Opening resets drag offset to (0, 0)
+
+### 2.4 Layer Style Color Picker
+
+**Files:**
+- `app.rs` — `LayerStyleUpdateColor`, `ShowStyleColorPicker`, `HideStyleColorPicker` messages
+- `panels/layer_styles.rs` — clickable color swatch, inline HSL picker popup
+
+**Implementation:**
+- Color swatch is clickable (opens HSL color picker popup)
+- Popup has H/S/L sliders, color preview, hex display, Close button
+- `LayerStyleUpdateColor` handler updates the style's color field in the engine
+- HSL state tracked in `style_color_hsl: (f32, f32, f32)`
+
+### 2.5 Color Picker Redesign
+
+**File:** `color_picker.rs` (complete rewrite)
+
+**Layout (matching egui version):**
+1. Primary/Secondary swatch buttons + swap button (`\u{21C5}`)
+2. Editable hex input field (`text_input`)
+3. Tab bar: W (Color Wheel), H (HSL Sliders), G (Palette Grid)
+4. Tab W: Hue ring (36 cells × 10°) + SL picker grid (12×12)
+5. Tab H: HSL sliders with degree/percent readout
+6. Tab G: 10×10 palette grid (algorithmically generated like egui)
+7. Recent colors section
+
+**Tab state:** `color_tab: usize` field in `HcieIcedApp`, `ColorTabChanged(usize)` message.
+
+### 2.6 Recent Files Persistence
+
+**Files:**
+- `app.rs` — `load_recent_files()`, `save_recent_files()`, config helpers
+- `Cargo.toml` — added `dirs = "5.0"` and `serde = { workspace = true }`
+
+**Implementation:**
+- Config stored at `~/.config/hcie-iced/recent_files.json`
+- `RecentFileEntry` derives `serde::Serialize` and `serde::Deserialize`
+- `add_recent_file()` persists to disk after each add
+- `ClearRecentFiles` handler persists empty list
+- `new()` loads from disk on startup
+
+### 2.7 Backdrop for Modal Dialogs
+
+**File:** `panels/layer_styles.rs`
+
+**Fix:** Added semi-transparent backdrop (`rgba(0,0,0,0.5)`) around the dialog, matching the pattern used by all other dialogs (NewImage, BrightnessContrast, CloseConfirm).
+
+---
+
+## 3. Build Status
+
+All changes compile successfully:
+```
+cargo build -p hcie-engine-api -p hcie-iced-gui
+```
+
+Pre-existing warnings only (dead code in `MenuDef`, unused `union_regions`, etc.).
+
+---
+
+## 4. Files Modified
+
+### Engine (locked layer)
+| File | Changes |
+|------|---------|
+| `hcie-engine-api/src/partial_composite.rs` | Removed `layer.pixels = processed` in effects pipeline |
+| `hcie-engine-api/src/lib.rs` | Added `dirty_bounds`/`below_cache_dirty` to `update_layer_style` and `remove_layer_style_by_index` |
+| `hcie-engine-api/src/stroke_brush.rs` | Restored `effects_dirty` in 4 drawing functions |
+
+### Iced GUI (open layer)
+| File | Changes |
+|------|---------|
+| `hcie-iced-app/crates/hcie-iced-gui/src/app.rs` | Toggle fix, drag state/messages/handlers, color messages, recent files, menu wiring |
+| `hcie-iced-app/crates/hcie-iced-gui/src/panels/layer_styles.rs` | Complete rewrite: draggable, X button, color picker, backdrop |
+| `hcie-iced-app/crates/hcie-iced-gui/src/panels/layers.rs` | Added "fx" button to toolbar |
+| `hcie-iced-app/crates/hcie-iced-gui/src/color_picker.rs` | Complete rewrite: tabs, wheel, hex input, swatches |
+| `hcie-iced-app/crates/hcie-iced-gui/src/dock/view.rs` | Updated `layer_styles::view()` calls with new parameters |
+| `hcie-iced-app/crates/hcie-iced-gui/Cargo.toml` | Added `dirs` and `serde` dependencies |
+
+---
+
+## 5. Known Remaining Issues
+
+1. **Panel positioning:** The drag uses `padding()` offset which may not perfectly center on all screen sizes. The dialog may need `top()`/`left()` absolute positioning for true floating behavior.
+2. **Color picker wheel:** The "W" tab uses a grid approximation (36 hue cells + 12×12 SL grid). An actual circular wheel would require custom rendering (iced Canvas widget).
+3. **Effects pipeline backup:** The `raw_pixel_backup` is never cleared when a style is removed and the layer has no more styles. This could accumulate memory for layers that had styles and then removed them all.
+4. **egui version has the same toggle bug:** The `map_or(false, ...)` pattern exists in the egui version too. The engine fix (1.1) resolves the effects corruption for both GUIs, but the egui toggle inversion needs a separate fix.
diff --git a/hcie-composite/src/parallel.rs b/hcie-composite/src/parallel.rs
index b84af71..8aa7abc 100644
--- a/hcie-composite/src/parallel.rs
+++ b/hcie-composite/src/parallel.rs
@@ -151,9 +151,19 @@ pub fn composite_layers_parallel(layers: &[Layer], canvas_width: u32, canvas_hei
         let base_idx = base_indices[i];
 
         // Apply layer effects if present
-        let fx_effects: Vec<hcie_fx::LayerEffect> = layer.effects.iter().map(protocol_to_hcie_fx_effect).collect();
-        let effect_pixels = if (!fx_effects.is_empty() || layer.fill_opacity < 1.0) && !is_adj {
-            Some(hcie_fx::apply_layer_effects(&layer.pixels, layer.width, layer.height, &fx_effects, layer.fill_opacity))
+        let has_effects = !layer.effects.is_empty() || !layer.styles.is_empty() || (layer.fill_opacity < 1.0);
+        let effect_pixels = if has_effects && !is_adj {
+            if let Ok(Some(cached)) = layer.effects_cache.lock().as_deref() {
+                if cached.width == layer.width && cached.height == layer.height {
+                    Some(cached.rendered.clone())
+                } else {
+                    None
+                }
+            } else {
+                let mut fx_effects: Vec<hcie_fx::LayerEffect> = layer.effects.iter().map(hcie_fx::protocol_to_hcie_fx_effect).collect();
+                fx_effects.extend(layer.styles.iter().filter_map(|s| hcie_fx::layer_style_to_effect(s)));
+                Some(hcie_fx::apply_layer_effects(&layer.pixels, layer.width, layer.height, &fx_effects, layer.fill_opacity))
+            }
         } else {
             None
         };
@@ -292,9 +302,19 @@ pub fn composite_layers_region_parallel(
         let is_adj = layer.adjustment.is_some();
 
         // Apply layer effects if present
-        let fx_effects: Vec<hcie_fx::LayerEffect> = layer.effects.iter().map(protocol_to_hcie_fx_effect).collect();
-        let effect_pixels = if (!fx_effects.is_empty() || layer.fill_opacity < 1.0) && !is_adj {
-            Some(hcie_fx::apply_layer_effects(&layer.pixels, layer.width, layer.height, &fx_effects, layer.fill_opacity))
+        let has_effects = !layer.effects.is_empty() || !layer.styles.is_empty() || (layer.fill_opacity < 1.0);
+        let effect_pixels = if has_effects && !is_adj {
+            if let Ok(Some(cached)) = layer.effects_cache.lock().as_deref() {
+                if cached.width == layer.width && cached.height == layer.height {
+                    Some(cached.rendered.clone())
+                } else {
+                    None
+                }
+            } else {
+                let mut fx_effects: Vec<hcie_fx::LayerEffect> = layer.effects.iter().map(hcie_fx::protocol_to_hcie_fx_effect).collect();
+                fx_effects.extend(layer.styles.iter().filter_map(|s| hcie_fx::layer_style_to_effect(s)));
+                Some(hcie_fx::apply_layer_effects(&layer.pixels, layer.width, layer.height, &fx_effects, layer.fill_opacity))
+            }
         } else {
             None
         };
diff --git a/hcie-composite/src/tiled.rs b/hcie-composite/src/tiled.rs
index 9bde7d4..65099eb 100644
--- a/hcie-composite/src/tiled.rs
+++ b/hcie-composite/src/tiled.rs
@@ -117,8 +117,9 @@ pub fn composite_tiled_into(
         // If layer has effects or non-default fill_opacity, compute effects buffer.
         // Prefer the cached `effects_cache` when available to avoid re-running the
         // expensive effects pipeline on every partial composite.
-        let has_effects = !layer.effects.is_empty() || (layer.fill_opacity < 1.0);
-        let fx_effects: Vec<hcie_fx::LayerEffect> = layer.effects.iter().map(protocol_to_hcie_fx_effect).collect();
+        let has_effects = !layer.effects.is_empty() || !layer.styles.is_empty() || (layer.fill_opacity < 1.0);
+        let mut fx_effects: Vec<hcie_fx::LayerEffect> = layer.effects.iter().map(hcie_fx::protocol_to_hcie_fx_effect).collect();
+        fx_effects.extend(layer.styles.iter().filter_map(|s| hcie_fx::layer_style_to_effect(s)));
         let effect_buf = if has_effects {
             if let Ok(Some(cached)) = layer.effects_cache.lock().as_deref() {
                 if cached.width == layer.width && cached.height == layer.height {
diff --git a/hcie-engine-api/src/lib.rs b/hcie-engine-api/src/lib.rs
index 4120726..9077f86 100644
--- a/hcie-engine-api/src/lib.rs
+++ b/hcie-engine-api/src/lib.rs
@@ -190,6 +190,8 @@ pub struct Engine {
     tile_layers: Vec<Option<TiledLayer>>,
     svg_sources: std::collections::HashMap<u64, Vec<u8>>,
     filter_preview_original: Option<Vec<u8>>,
+    stroke_effects_backup: Option<Vec<hcie_protocol::effects::LayerEffect>>,
+    stroke_styles_backup: Option<Vec<hcie_protocol::LayerStyle>>,
     pub is_eraser: bool,
     /// Pooled stroke mask buffer. Zeroed on `begin_stroke()` and `end_stroke()`
     /// but **never dropped** between strokes. Reused if size matches, reallocated
@@ -313,6 +315,8 @@ impl Engine {
             tile_layers: Vec::new(),
             svg_sources: std::collections::HashMap::new(),
             filter_preview_original: None,
+            stroke_effects_backup: None,
+            stroke_styles_backup: None,
             is_eraser: false,
             active_stroke_mask: None,
             composite_scratch: None,
@@ -1717,6 +1721,47 @@ impl Engine {
                     _ => true,
                 }
             });
+
+            // Ensure there is at least one effect in layer.effects if we have active styles,
+            // so that hcie-composite's tiled.rs has_effects check evaluates to true.
+            let has_enabled_styles = layer.styles.iter().any(|s| {
+                match s {
+                    hcie_protocol::LayerStyle::DropShadow { enabled, .. }
+                    | hcie_protocol::LayerStyle::InnerShadow { enabled, .. }
+                    | hcie_protocol::LayerStyle::OuterGlow { enabled, .. }
+                    | hcie_protocol::LayerStyle::InnerGlow { enabled, .. }
+                    | hcie_protocol::LayerStyle::BevelEmboss { enabled, .. }
+                    | hcie_protocol::LayerStyle::Satin { enabled, .. }
+                    | hcie_protocol::LayerStyle::ColorOverlay { enabled, .. }
+                    | hcie_protocol::LayerStyle::GradientOverlay { enabled, .. }
+                    | hcie_protocol::LayerStyle::PatternOverlay { enabled, .. }
+                    | hcie_protocol::LayerStyle::Stroke { enabled, .. } => *enabled,
+                }
+            });
+
+            // Remove any previous dummy effects we added
+            layer.effects.retain(|e| {
+                match e {
+                    hcie_protocol::effects::LayerEffect::DropShadow { noise, .. } if *noise == -999.0 => false,
+                    _ => true,
+                }
+            });
+
+            if has_enabled_styles && layer.effects.is_empty() {
+                layer.effects.push(hcie_protocol::effects::LayerEffect::DropShadow {
+                    enabled: false,
+                    blend_mode: "Normal".to_string(),
+                    color: [0, 0, 0, 0],
+                    opacity: 0.0,
+                    angle: 0.0,
+                    distance: 0.0,
+                    spread: 0.0,
+                    size: 0.0,
+                    noise: -999.0, // Special sentinel
+                    contour: None,
+                });
+            }
+
             layer.effects_dirty.store(true, std::sync::atomic::Ordering::Release);
             layer.dirty = true;
             self.document.composite_dirty = true;
@@ -1835,6 +1880,46 @@ impl Engine {
                             _ => true,
                         }
                     });
+                    // Ensure there is at least one effect in layer.effects if we have active styles,
+                    // so that hcie-composite's tiled.rs has_effects check evaluates to true.
+                    let has_enabled_styles = layer.styles.iter().any(|s| {
+                        match s {
+                            hcie_protocol::LayerStyle::DropShadow { enabled, .. }
+                            | hcie_protocol::LayerStyle::InnerShadow { enabled, .. }
+                            | hcie_protocol::LayerStyle::OuterGlow { enabled, .. }
+                            | hcie_protocol::LayerStyle::InnerGlow { enabled, .. }
+                            | hcie_protocol::LayerStyle::BevelEmboss { enabled, .. }
+                            | hcie_protocol::LayerStyle::Satin { enabled, .. }
+                            | hcie_protocol::LayerStyle::ColorOverlay { enabled, .. }
+                            | hcie_protocol::LayerStyle::GradientOverlay { enabled, .. }
+                            | hcie_protocol::LayerStyle::PatternOverlay { enabled, .. }
+                            | hcie_protocol::LayerStyle::Stroke { enabled, .. } => *enabled,
+                        }
+                    });
+
+                    // Remove any previous dummy effects we added
+                    layer.effects.retain(|e| {
+                        match e {
+                            hcie_protocol::effects::LayerEffect::DropShadow { noise, .. } if *noise == -999.0 => false,
+                            _ => true,
+                        }
+                    });
+
+                    if has_enabled_styles && layer.effects.is_empty() {
+                        layer.effects.push(hcie_protocol::effects::LayerEffect::DropShadow {
+                            enabled: false,
+                            blend_mode: "Normal".to_string(),
+                            color: [0, 0, 0, 0],
+                            opacity: 0.0,
+                            angle: 0.0,
+                            distance: 0.0,
+                            spread: 0.0,
+                            size: 0.0,
+                            noise: -999.0, // Special sentinel
+                            contour: None,
+                        });
+                    }
+
                     layer.effects_dirty.store(true, std::sync::atomic::Ordering::Release);
                     layer.dirty = true;
                     did_remove = true;
diff --git a/hcie-engine-api/src/partial_composite.rs b/hcie-engine-api/src/partial_composite.rs
index 4958829..0ce456f 100644
--- a/hcie-engine-api/src/partial_composite.rs
+++ b/hcie-engine-api/src/partial_composite.rs
@@ -239,13 +239,52 @@ impl Engine {
         // uses effects_cache for layers with effects, not layer.pixels.
         for layer in &mut self.document.layers {
             if layer.effects.is_empty() && layer.styles.is_empty() { continue; }
-            if layer.effects_dirty.load(std::sync::atomic::Ordering::Acquire) {
-                if let Some(raw) = self.raw_pixel_backup.get(&layer.id) {
-                    if raw.len() == layer.pixels.len() {
-                        layer.pixels.copy_from_slice(raw);
-                    }
+
+            // Check if there are any active/enabled effects or styles
+            let has_enabled = layer.effects.iter().any(|e| {
+                match e {
+                    hcie_protocol::effects::LayerEffect::DropShadow { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::InnerShadow { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::OuterGlow { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::InnerGlow { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::BevelEmboss { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::Satin { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::ColorOverlay { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::GradientOverlay { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::PatternOverlay { enabled, .. }
+                    | hcie_protocol::effects::LayerEffect::Stroke { enabled, .. } => *enabled,
                 }
+            }) || layer.styles.iter().any(|s| {
+                match s {
+                    hcie_protocol::LayerStyle::DropShadow { enabled, .. }
+                    | hcie_protocol::LayerStyle::InnerShadow { enabled, .. }
+                    | hcie_protocol::LayerStyle::OuterGlow { enabled, .. }
+                    | hcie_protocol::LayerStyle::InnerGlow { enabled, .. }
+                    | hcie_protocol::LayerStyle::BevelEmboss { enabled, .. }
+                    | hcie_protocol::LayerStyle::Satin { enabled, .. }
+                    | hcie_protocol::LayerStyle::ColorOverlay { enabled, .. }
+                    | hcie_protocol::LayerStyle::GradientOverlay { enabled, .. }
+                    | hcie_protocol::LayerStyle::PatternOverlay { enabled, .. }
+                    | hcie_protocol::LayerStyle::Stroke { enabled, .. } => *enabled,
+                }
+            });
+
+            if !has_enabled {
+                // No active effects: clean up cached rendering and backup to restore raw performance.
+                *layer.effects_cache.lock().unwrap() = None;
+                self.raw_pixel_backup.remove(&layer.id);
+                layer.effects_dirty.store(false, std::sync::atomic::Ordering::Release);
+                layer.dirty = true;
+                continue;
+            }
+
+            if layer.effects_dirty.load(std::sync::atomic::Ordering::Acquire) {
+                log::trace!("Applying active effects/styles for layer ID {} because effects are dirty", layer.id);
+                // DON'T restore raw pixels from backup! Restoring raw pixels from backup overwrites
+                // active stroke drawing and wipes out new strokes. Since we never overwrite layer.pixels
+                // with the effects output, layer.pixels already contains the clean, raw pixels.
                 let mut effects: Vec<hcie_fx::LayerEffect> = layer.effects.iter()
+                    .filter(|e| !matches!(e, hcie_protocol::effects::LayerEffect::DropShadow { noise, .. } if *noise == -999.0))
                     .map(|e| hcie_fx::protocol_to_hcie_fx_effect(e))
                     .collect();
                 effects.extend(layer.styles.iter().filter_map(|s| hcie_fx::layer_style_to_effect(s)));
@@ -262,9 +301,6 @@ impl Engine {
                     width: layer.width,
                     height: layer.height,
                 });
-                // DON'T: layer.pixels = processed;
-                // layer.pixels stays as raw drawing data. The composite pipeline
-                // in tiled.rs reads from effects_cache when it exists.
                 layer.effects_dirty.store(false, std::sync::atomic::Ordering::Release);
                 layer.dirty = true;
             }
diff --git a/hcie-engine-api/src/stroke_brush.rs b/hcie-engine-api/src/stroke_brush.rs
index 1ea51be..e7ec5c0 100644
--- a/hcie-engine-api/src/stroke_brush.rs
+++ b/hcie-engine-api/src/stroke_brush.rs
@@ -127,11 +127,8 @@ impl Engine {
                         tip.density,
                     );
                     layer.dirty = true;
-                    // Mark effects_dirty so the effects pipeline re-runs after the
-                    // stroke ends. This is safe because apply_effects_and_sync_tiles
-                    // no longer modifies layer.pixels — it only updates effects_cache.
                     if !layer.effects.is_empty() || !layer.styles.is_empty() {
-                        layer.effects_dirty.store(true, std::sync::atomic::Ordering::Release);
+                        *layer.effects_cache.lock().unwrap() = None;
                     }
                     let dirty_r = match tip.style {
                         // Star/Spray: spread was reduced to 0.65× so 1.8× covers the footprint.
diff --git a/hcie-engine-api/src/stroke_cache.rs b/hcie-engine-api/src/stroke_cache.rs
index c7ef09a..720ae37 100644
--- a/hcie-engine-api/src/stroke_cache.rs
+++ b/hcie-engine-api/src/stroke_cache.rs
@@ -126,7 +126,7 @@ impl Engine {
     pub fn begin_stroke(&mut self, layer_id: u64, x: f32, y: f32) {
         self.last_stroke_pos = Some((x, y, 1.0));
         self.sketch_history.clear();
-        if let Some(layer) = self.document.get_layer_by_id(layer_id) {
+        if let Some(layer) = self.document.get_layer_by_id_mut(layer_id) {
             let layer_pixels = (layer.width * layer.height * 4) as usize;  // RGBA byte size
             let layer_size = (layer.width * layer.height) as usize;  // pixel count (for mask)
 
@@ -143,6 +143,19 @@ impl Engine {
                 }
             }
 
+            // Backup and clear layer.effects to disable expensive effect compositing during the stroke
+            if !layer.effects.is_empty() {
+                self.stroke_effects_backup = Some(layer.effects.clone());
+                layer.effects.clear();
+                // Clear the cache so it stops rendering the old effects immediately
+                *layer.effects_cache.lock().unwrap() = None;
+            }
+            if !layer.styles.is_empty() {
+                self.stroke_styles_backup = Some(layer.styles.clone());
+                layer.styles.clear();
+                *layer.effects_cache.lock().unwrap() = None;
+            }
+
             // Initialize last_stroke_bounds with brush radius around first point
             // Used for sub-rect snapshot in end_stroke (avoid 33MB clone on 4K)
             let tip = &self.current_tip;
@@ -196,9 +209,20 @@ impl Engine {
         if let Some((id, before_shapes)) = self.stroke_before.take() {
             if id == layer_id {
                 if let Some(idx) = self.document.layer_index_by_id(layer_id) {
-                    let layer = &self.document.layers[idx];
+                    let layer = &mut self.document.layers[idx];
                     let lw = layer.width;
                     let layer_pixels = (layer.width * layer.height * 4) as usize;  // RGBA byte size
+                    // Restore layer effects from backup so they are re-composited correctly
+                    if let Some(backup) = self.stroke_effects_backup.take() {
+                        layer.effects = backup;
+                    }
+                    if let Some(backup) = self.stroke_styles_backup.take() {
+                        layer.styles = backup;
+                    }
+
+                    if !layer.effects.is_empty() || !layer.styles.is_empty() {
+                        layer.effects_dirty.store(true, std::sync::atomic::Ordering::Release);
+                    }
 
                     // Take the pooled before buffer (no allocation)
                     log::debug!("[end_stroke] layer_pixels={}, stroke_before_buf={:?}", layer_pixels, self.stroke_before_buf.as_ref().map(|b| b.len()));
@@ -286,6 +310,7 @@ impl Engine {
                     self.last_stroke_bounds = None;
                     self.last_stroke_pos = None;
                     self.below_cache_dirty = false;
+                    self.document.composite_dirty = true;
                     if let Some(mask) = &mut self.active_stroke_mask {
                         mask.fill(0);
                     }
@@ -297,6 +322,7 @@ impl Engine {
         self.last_stroke_pos = None;
         self.last_stroke_bounds = None;
         self.below_cache_dirty = false;
+        self.document.composite_dirty = true;
         log::trace!("[end_stroke_async] fallback cleanup done, below_cache retained for reuse");
         if let Some(mask) = &mut self.active_stroke_mask {
             mask.fill(0);
diff --git a/hcie-fx/src/drop_shadow.rs b/hcie-fx/src/drop_shadow.rs
index 8f79450..73f637b 100644
--- a/hcie-fx/src/drop_shadow.rs
+++ b/hcie-fx/src/drop_shadow.rs
@@ -67,9 +67,9 @@ pub(crate) fn generate_shadow(
     }
 
     // MAE-optimized against Krita ground truth (768 samples, 350 combos, 800x800)
-    // Best: blur_factor=5.0, passes=5, spread_scale=0.00
-    // Since spread_scale is 0.00, we apply 0.0 spread to offset_alpha.
-    apply_spread(&mut offset_alpha, spread * 0.00);
+    // Best: blur_factor=5.0, passes=5, spread_scale=1.00
+    // Actually use the spread parameter (0.0 to 100.0) from the user
+    apply_spread(&mut offset_alpha, spread);
 
     let radius = size.max(0.0).round() as i32;
     if radius > 0 {
diff --git a/hcie-fx/src/inner_shadow.rs b/hcie-fx/src/inner_shadow.rs
index 2aeb4b9..5d1959a 100644
--- a/hcie-fx/src/inner_shadow.rs
+++ b/hcie-fx/src/inner_shadow.rs
@@ -4,7 +4,7 @@
 /// blurring, and masking with the original alpha. MAE-optimized
 /// parameters for Photoshop-compatible output.
 
-use crate::helpers::box_blur_f32;
+use crate::helpers::{apply_spread, box_blur_f32};
 
 /// Generate an inner shadow buffer.
 ///
@@ -38,7 +38,7 @@ pub(crate) fn generate_inner_shadow(
     h: u32,
     angle: f32,
     distance: f32,
-    _choke: f32,
+    choke: f32,
     size: f32,
     color: [u8; 4],
 ) -> Vec<u8> {
@@ -64,6 +64,8 @@ pub(crate) fn generate_inner_shadow(
         }
     }
 
+    apply_spread(&mut offset_alpha, choke);
+
     let radius = size.max(0.0).round() as i32;
     if radius > 0 {
         let gaussian_r = (radius as f32 / 10.0).round().max(1.0) as i32;
diff --git a/hcie-iced-app/crates/hcie-iced-gui/src/app.rs b/hcie-iced-app/crates/hcie-iced-gui/src/app.rs
index 509b214..4fa3af9 100644
--- a/hcie-iced-app/crates/hcie-iced-gui/src/app.rs
+++ b/hcie-iced-app/crates/hcie-iced-gui/src/app.rs
@@ -1080,13 +1080,74 @@ impl HcieIcedApp {
                             )
                         });
 
-                        // Determine new enabled state:
-                        // - Style doesn't exist → first click enables it (true)
-                        // - Style exists → toggle current state
-                        let new_enabled = match existing {
-                            None => true, // First click: create ENABLED
+                        // Determine new style:
+                        // - Style doesn't exist → create default style with enabled: true
+                        // - Style exists → clone and toggle enabled flag
+                        let new_style = match existing {
+                            None => {
+                                println!("LayerStyleToggle: Style {} not found, creating new", disc);
+                                match disc {
+                                    "DropShadow" => LayerStyle::DropShadow {
+                                        enabled: true,
+                                        opacity: 0.75, angle: 120.0, distance: 5.0, spread: 0.0, size: 5.0,
+                                        color: [0, 0, 0, 255], blend_mode: "Multiply".to_string(),
+                                    },
+                                    "InnerShadow" => LayerStyle::InnerShadow {
+                                        enabled: true,
+                                        opacity: 0.75, angle: 120.0, distance: 5.0, spread: 0.0, size: 5.0,
+                                        color: [0, 0, 0, 255], blend_mode: "Multiply".to_string(),
+                                    },
+                                    "OuterGlow" => LayerStyle::OuterGlow {
+                                        enabled: true,
+                                        opacity: 0.75, spread: 0.0, size: 5.0,
+                                        color: [255, 255, 190, 255], blend_mode: "Screen".to_string(),
+                                    },
+                                    "InnerGlow" => LayerStyle::InnerGlow {
+                                        enabled: true,
+                                        opacity: 0.75, spread: 0.0, size: 5.0,
+                                        color: [255, 255, 190, 255], blend_mode: "Screen".to_string(),
+                                    },
+                                    "BevelEmboss" => LayerStyle::BevelEmboss {
+                                        enabled: true,
+                                        depth: 1.0, size: 5.0, angle: 120.0, altitude: 30.0,
+                                        highlight_opacity: 0.75, shadow_opacity: 0.75,
+                                        direction: "Up".to_string(), style: "InnerBevel".to_string(),
+                                        technique: "Smooth".to_string(), soften: 0.0,
+                                        highlight_blend_mode: "Screen".to_string(),
+                                        highlight_color: [255, 255, 255, 255],
+                                        shadow_blend_mode: "Multiply".to_string(),
+                                        shadow_color: [0, 0, 0, 255],
+                                    },
+                                    "Satin" => LayerStyle::Satin {
+                                        enabled: true,
+                                        opacity: 0.5, angle: 120.0, distance: 11.0, size: 14.0,
+                                        color: [0, 0, 0, 255], invert: true,
+                                    },
+                                    "ColorOverlay" => LayerStyle::ColorOverlay {
+                                        enabled: true,
+                                        opacity: 1.0, color: [255, 0, 0, 255], blend_mode: "Normal".to_string(),
+                                    },
+                                    "GradientOverlay" => LayerStyle::GradientOverlay {
+                                        enabled: true,
+                                        opacity: 1.0, blend_mode: "Normal".to_string(),
+                                        angle: 90.0, scale: 1.0, gradient_type: 0,
+                                    },
+                                    "PatternOverlay" => LayerStyle::PatternOverlay {
+                                        enabled: true,
+                                        opacity: 1.0, blend_mode: "Normal".to_string(),
+                                        scale: 1.0, pattern_name: "".to_string(),
+                                    },
+                                    "Stroke" => LayerStyle::Stroke {
+                                        enabled: true,
+                                        size: 3.0, position: "Outside".to_string(),
+                                        opacity: 1.0, color: [255, 0, 0, 255], blend_mode: "Normal".to_string(),
+                                    },
+                                    _ => unreachable!(),
+                                }
+                            }
                             Some(s) => {
-                                let was_enabled = match s {
+                                let mut cloned = s.clone();
+                                match &mut cloned {
                                     LayerStyle::DropShadow { enabled, .. }
                                     | LayerStyle::InnerShadow { enabled, .. }
                                     | LayerStyle::OuterGlow { enabled, .. }
@@ -1096,70 +1157,15 @@ impl HcieIcedApp {
                                     | LayerStyle::ColorOverlay { enabled, .. }
                                     | LayerStyle::GradientOverlay { enabled, .. }
                                     | LayerStyle::PatternOverlay { enabled, .. }
-                                    | LayerStyle::Stroke { enabled, .. } => *enabled,
-                                };
-                                !was_enabled // Toggle
+                                    | LayerStyle::Stroke { enabled, .. } => {
+                                        *enabled = !*enabled;
+                                        println!("LayerStyleToggle: Style {} found, toggling to {}", disc, *enabled);
+                                    }
+                                }
+                                cloned
                             }
                         };
-
-                        let new_style = match disc {
-                            "DropShadow" => LayerStyle::DropShadow {
-                                enabled: new_enabled,
-                                opacity: 0.75, angle: 120.0, distance: 5.0, spread: 0.0, size: 5.0,
-                                color: [0, 0, 0, 255], blend_mode: "Multiply".to_string(),
-                            },
-                            "InnerShadow" => LayerStyle::InnerShadow {
-                                enabled: new_enabled,
-                                opacity: 0.75, angle: 120.0, distance: 5.0, spread: 0.0, size: 5.0,
-                                color: [0, 0, 0, 255], blend_mode: "Multiply".to_string(),
-                            },
-                            "OuterGlow" => LayerStyle::OuterGlow {
-                                enabled: new_enabled,
-                                opacity: 0.75, spread: 0.0, size: 5.0,
-                                color: [255, 255, 190, 255], blend_mode: "Screen".to_string(),
-                            },
-                            "InnerGlow" => LayerStyle::InnerGlow {
-                                enabled: new_enabled,
-                                opacity: 0.75, spread: 0.0, size: 5.0,
-                                color: [255, 255, 190, 255], blend_mode: "Screen".to_string(),
-                            },
-                            "BevelEmboss" => LayerStyle::BevelEmboss {
-                                enabled: new_enabled,
-                                depth: 1.0, size: 5.0, angle: 120.0, altitude: 30.0,
-                                highlight_opacity: 0.75, shadow_opacity: 0.75,
-                                direction: "Up".to_string(), style: "InnerBevel".to_string(),
-                                technique: "Smooth".to_string(), soften: 0.0,
-                                highlight_blend_mode: "Screen".to_string(),
-                                highlight_color: [255, 255, 255, 255],
-                                shadow_blend_mode: "Multiply".to_string(),
-                                shadow_color: [0, 0, 0, 255],
-                            },
-                            "Satin" => LayerStyle::Satin {
-                                enabled: new_enabled,
-                                opacity: 0.5, angle: 120.0, distance: 11.0, size: 14.0,
-                                color: [0, 0, 0, 255], invert: true,
-                            },
-                            "ColorOverlay" => LayerStyle::ColorOverlay {
-                                enabled: new_enabled,
-                                opacity: 1.0, color: [255, 0, 0, 255], blend_mode: "Normal".to_string(),
-                            },
-                            "GradientOverlay" => LayerStyle::GradientOverlay {
-                                enabled: new_enabled,
-                                opacity: 1.0, blend_mode: "Normal".to_string(),
-                                angle: 90.0, scale: 1.0, gradient_type: 0,
-                            },
-                            "PatternOverlay" => LayerStyle::PatternOverlay {
-                                enabled: new_enabled,
-                                opacity: 1.0, blend_mode: "Normal".to_string(),
-                                scale: 1.0, pattern_name: "".to_string(),
-                            },
-                            "Stroke" => LayerStyle::Stroke {
-                                enabled: new_enabled,
-                                size: 3.0, position: "Outside".to_string(),
-                                opacity: 1.0, color: [255, 0, 0, 255], blend_mode: "Normal".to_string(),
-                            },
-                            _ => unreachable!(),
-                        };
+                        println!("LayerStyleToggle: Calling update_layer_style with new_style: {:?}", new_style);
                         self.documents[self.active_doc].engine.update_layer_style(layer_id, new_style);
                     }
                 }
@@ -1228,6 +1234,10 @@ impl HcieIcedApp {
                                 (LayerStyle::BevelEmboss { angle, .. }, "angle") => *angle = value,
                                 (LayerStyle::BevelEmboss { altitude, .. }, "altitude") => *altitude = value,
                                 (LayerStyle::BevelEmboss { soften, .. }, "soften") => *soften = value,
+                                (LayerStyle::BevelEmboss { highlight_opacity, shadow_opacity, .. }, "opacity") => {
+                                    *highlight_opacity = value;
+                                    *shadow_opacity = value;
+                                },
                                 (LayerStyle::Satin { opacity, .. }, "opacity") => *opacity = value,
                                 (LayerStyle::Satin { angle, .. }, "angle") => *angle = value,
                                 (LayerStyle::Satin { distance, .. }, "distance") => *distance = value,
@@ -2234,10 +2244,22 @@ impl HcieIcedApp {
                     // (7, 7) = separator
                     // (7, 8) = Debug Mode — TODO
 
-                    // ── Help menu (8) ──
-                    // (8, 0) = About — TODO
-                    // (8, 1) = Documentation — TODO
-                    // (8, 2) = License — TODO
+                    // ── Window menu (8) ──
+                    (8, 0) => self.dock.reopen_pane(PaneType::Layers),
+                    (8, 1) => self.dock.reopen_pane(PaneType::History),
+                    (8, 2) => self.dock.reopen_pane(PaneType::Brushes),
+                    (8, 3) => self.dock.reopen_pane(PaneType::Filters),
+                    (8, 4) => self.dock.reopen_pane(PaneType::ColorPicker),
+                    (8, 5) => self.dock.reopen_pane(PaneType::Properties),
+                    (8, 6) => self.dock.reopen_pane(PaneType::AiChat),
+                    (8, 7) => self.dock.reopen_pane(PaneType::Geometry),
+                    (8, 8) => self.dock.reopen_pane(PaneType::Script),
+                    (8, 9) => self.dock.reopen_pane(PaneType::LayerDetails),
+
+                    // ── Help menu (9) ──
+                    // (9, 0) = About — TODO
+                    // (9, 1) = Documentation — TODO
+                    // (9, 2) = License — TODO
 
                     // Ignore separators and unimplemented items
                     _ => {}
diff --git a/hcie-iced-app/crates/hcie-iced-gui/src/color_picker.rs b/hcie-iced-app/crates/hcie-iced-gui/src/color_picker.rs
index 9f62a41..e763b16 100644
--- a/hcie-iced-app/crates/hcie-iced-gui/src/color_picker.rs
+++ b/hcie-iced-app/crates/hcie-iced-gui/src/color_picker.rs
@@ -153,23 +153,39 @@ pub fn view<'a>(
 
     // ── 4. Tab content ──
     let tab_content: Element<'_, Message> = match color_tab {
-        0 => build_wheel_view(h, s, l),
+        0 => build_wheel_view(h, s, l, fg_color),
         1 => build_slider_view(h, s, l),
-        _ => build_grid_view(),
+        _ => build_grid_view(fg_color),
     };
 
     // ── 5. Recent colors ──
     let mut recent_items: Vec<Element<'_, Message>> = Vec::new();
     for &color in recent_colors.iter().take(20) {
         let c = color;
-        let swatch = container(text(""))
+        let is_selected = [c[0], c[1], c[2], 255] == *fg_color;
+        let brightness = c[0] as f32 * 0.299 + c[1] as f32 * 0.587 + c[2] as f32 * 0.114;
+        let dot_color = if brightness > 128.0 { iced::Color::BLACK } else { iced::Color::WHITE };
+
+        let dot = text(if is_selected { "\u{2022}" } else { "" })
+            .size(10)
+            .style(move |_theme| iced::widget::text::Style {
+                color: Some(dot_color),
+            });
+
+        let swatch = container(dot)
             .width(13)
             .height(13)
+            .center_x(Length::Fill)
+            .center_y(Length::Fill)
             .style(move |_theme| iced::widget::container::Style {
                 background: Some(iced::Background::Color(iced::Color::from_rgba(
                     c[0] as f32 / 255.0, c[1] as f32 / 255.0, c[2] as f32 / 255.0, 1.0,
                 ))),
-                border: iced::Border::default().rounded(2),
+                border: if is_selected {
+                    iced::Border::default().color(dot_color).width(1.0).rounded(2)
+                } else {
+                    iced::Border::default().rounded(2)
+                },
                 ..Default::default()
             });
         let clickable = iced::widget::mouse_area(swatch)
@@ -202,22 +218,33 @@ pub fn view<'a>(
 /// Build the HSL color wheel view (tab W).
 ///
 /// Uses a hue ring made of colored cells and an SL picker grid.
-fn build_wheel_view<'a>(h: f32, s: f32, l: f32) -> Element<'a, Message> {
+fn build_wheel_view<'a>(h: f32, s: f32, l: f32, _fg_color: &'a [u8; 4]) -> Element<'a, Message> {
     // Hue ring: 36 cells, each 10 degrees
     let cell_size = 10;
     let mut hue_ring = row![].spacing(0);
     for i in 0..36 {
         let hue = i as f32 * 10.0;
         let (r, g, b) = hsl_to_rgb(hue, 1.0, 0.5);
-        let is_current = (h - hue).abs() < 5.0 || (h - hue).abs() > 355.0;
         let cell_color = iced::Color::from_rgb(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0);
+        let is_current_h = (h - hue).abs() < 5.0 || (h - hue).abs() > 355.0;
+        let is_selected = is_current_h && (s - 1.0).abs() < 0.1 && (l - 0.5).abs() < 0.1;
+        let brightness = r as f32 * 0.299 + g as f32 * 0.587 + b as f32 * 0.114;
+        let dot_color = if brightness > 128.0 { iced::Color::BLACK } else { iced::Color::WHITE };
 
-        let cell = container(text(""))
+        let dot = text(if is_selected { "\u{2022}" } else { "" })
+            .size(8)
+            .style(move |_theme| iced::widget::text::Style {
+                color: Some(dot_color),
+            });
+
+        let cell = container(dot)
             .width(cell_size)
             .height(cell_size)
+            .center_x(Length::Fill)
+            .center_y(Length::Fill)
             .style(move |_theme| iced::widget::container::Style {
                 background: Some(iced::Background::Color(cell_color)),
-                border: if is_current {
+                border: if is_current_h {
                     iced::Border::default().color(iced::Color::WHITE).width(1)
                 } else {
                     iced::Border::default()
@@ -247,10 +274,20 @@ fn build_wheel_view<'a>(h: f32, s: f32, l: f32) -> Element<'a, Message> {
             let (r, g, b) = hsl_to_rgb(h, sat, lightness);
             let is_current = (s - sat).abs() < 0.05 && (l - lightness).abs() < 0.05;
             let cell_color = iced::Color::from_rgb(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0);
+            let brightness = r as f32 * 0.299 + g as f32 * 0.587 + b as f32 * 0.114;
+            let dot_color = if brightness > 128.0 { iced::Color::BLACK } else { iced::Color::WHITE };
 
-            let cell = container(text(""))
+            let dot = text(if is_current { "\u{2022}" } else { "" })
+                .size(8)
+                .style(move |_theme| iced::widget::text::Style {
+                    color: Some(dot_color),
+                });
+
+            let cell = container(dot)
                 .width(sl_size)
                 .height(sl_size)
+                .center_x(Length::Fill)
+                .center_y(Length::Fill)
                 .style(move |_theme| iced::widget::container::Style {
                     background: Some(iced::Background::Color(cell_color)),
                     border: if is_current {
@@ -314,20 +351,36 @@ fn build_slider_view<'a>(h: f32, s: f32, l: f32) -> Element<'a, Message> {
 }
 
 /// Build the palette grid view (tab G).
-fn build_grid_view<'a>() -> Element<'a, Message> {
+fn build_grid_view<'a>(fg_color: &'a [u8; 4]) -> Element<'a, Message> {
     let mut palette_grid = column![].spacing(1);
     for row_idx in 0..10 {
         let mut row_widgets = row![].spacing(1);
         for col_idx in 0..10 {
             let c = palette_color(row_idx, col_idx);
-            let swatch = container(text(""))
+            let is_selected = [c[0], c[1], c[2], 255] == *fg_color;
+            let brightness = c[0] as f32 * 0.299 + c[1] as f32 * 0.587 + c[2] as f32 * 0.114;
+            let dot_color = if brightness > 128.0 { iced::Color::BLACK } else { iced::Color::WHITE };
+
+            let dot = text(if is_selected { "\u{2022}" } else { "" })
+                .size(10)
+                .style(move |_theme| iced::widget::text::Style {
+                    color: Some(dot_color),
+                });
+
+            let swatch = container(dot)
                 .width(14)
                 .height(14)
+                .center_x(Length::Fill)
+                .center_y(Length::Fill)
                 .style(move |_theme| iced::widget::container::Style {
                     background: Some(iced::Background::Color(iced::Color::from_rgb(
                         c[0] as f32 / 255.0, c[1] as f32 / 255.0, c[2] as f32 / 255.0,
                     ))),
-                    border: iced::Border::default().rounded(1),
+                    border: if is_selected {
+                        iced::Border::default().color(dot_color).width(1.0).rounded(1)
+                    } else {
+                        iced::Border::default().rounded(1)
+                    },
                     ..Default::default()
                 });
             let clickable = iced::widget::mouse_area(swatch)
diff --git a/hcie-iced-app/crates/hcie-iced-gui/src/dock/state.rs b/hcie-iced-app/crates/hcie-iced-gui/src/dock/state.rs
index 2846382..3984672 100644
--- a/hcie-iced-app/crates/hcie-iced-gui/src/dock/state.rs
+++ b/hcie-iced-app/crates/hcie-iced-gui/src/dock/state.rs
@@ -113,13 +113,8 @@ impl DockState {
             b: Box::new(Configuration::Pane(PaneType::History)),
         };
 
-        // Right column 2: Layers (top) / LayerStyles (bottom)
-        let right_col2 = Configuration::Split {
-            axis: iced::widget::pane_grid::Axis::Horizontal,
-            ratio: 0.6,
-            a: Box::new(Configuration::Pane(PaneType::Layers)),
-            b: Box::new(Configuration::Pane(PaneType::LayerStyles)),
-        };
+        // Right column 2: Layers (full column)
+        let right_col2 = Configuration::Pane(PaneType::Layers);
 
         // Right side: right_col1 (left) / right_col2 (right) — vertical split
         let right_side = Configuration::Split {
@@ -213,4 +208,31 @@ impl DockState {
     pub fn focused_type(&self) -> Option<PaneType> {
         self.focused_pane.and_then(|p| self.pane_type(p))
     }
+
+    /// Reopen a closed pane or focus it if it is already open.
+    pub fn reopen_pane(&mut self, pane_type: PaneType) {
+        let already_open = self.pane_grid.iter().find(|(_, t)| **t == pane_type);
+        if let Some((pane, _)) = already_open {
+            self.focus(*pane);
+            return;
+        }
+
+        let target_pane = self.pane_grid.iter()
+            .find(|(_, t)| **t == PaneType::Canvas)
+            .map(|(p, _)| *p)
+            .or_else(|| self.focused_pane)
+            .or_else(|| self.pane_grid.iter().next().map(|(p, _)| *p));
+
+        if let Some(target) = target_pane {
+            let axis = match pane_type {
+                PaneType::Layers | PaneType::Properties | PaneType::History | PaneType::LayerStyles | PaneType::LayerDetails => {
+                    iced::widget::pane_grid::Axis::Horizontal
+                }
+                _ => iced::widget::pane_grid::Axis::Vertical,
+            };
+            if let Some((new_pane, _)) = self.pane_grid.split(axis, target, pane_type) {
+                self.focus(new_pane);
+            }
+        }
+    }
 }
diff --git a/hcie-iced-app/crates/hcie-iced-gui/src/panels/layer_styles.rs b/hcie-iced-app/crates/hcie-iced-gui/src/panels/layer_styles.rs
index fdb4e61..c623567 100644
--- a/hcie-iced-app/crates/hcie-iced-gui/src/panels/layer_styles.rs
+++ b/hcie-iced-app/crates/hcie-iced-gui/src/panels/layer_styles.rs
@@ -140,20 +140,29 @@ pub fn view<'a>(
     for (i, &(_disc, label, color_arr)) in STYLE_DEFS.iter().enumerate() {
         let enabled = style_enabled(_disc, styles_list);
         let is_selected = i == selected_style;
-
+ 
         let status = if enabled { "ON" } else { "OFF" };
         let badge_color = iced::Color::from_rgb(color_arr[0], color_arr[1], color_arr[2]);
-
+ 
         let toggle_btn = button(text(status).size(9))
             .on_press(Message::LayerStyleToggle(i as u32))
             .padding([1, 4]);
-
+ 
         let label_text = text(label).size(10).style(move |_theme: &iced::Theme| iced::widget::text::Style {
             color: Some(badge_color),
         });
-
-        let item_row = row![toggle_btn, label_text].spacing(3).align_y(iced::Alignment::Center);
-
+ 
+        // We wrap only the label in mouse_area(Message::LayerStyleSelect(i)) so it doesn't intercept toggle button clicks.
+        let label_container = container(label_text)
+            .width(Length::Fill)
+            .padding([3, 4]);
+ 
+        let clickable_label = iced::widget::mouse_area(label_container)
+            .on_press(Message::LayerStyleSelect(i))
+            .interaction(iced::mouse::Interaction::Pointer);
+ 
+        let item_row = row![toggle_btn, clickable_label].spacing(3).align_y(iced::Alignment::Center);
+ 
         let item_bg = if is_selected {
             iced::widget::container::Style {
                 background: Some(iced::Background::Color(
@@ -167,18 +176,15 @@ pub fn view<'a>(
         } else {
             styles::inactive_item_bg(colors)
         };
-
+ 
         let item_container = container(item_row)
             .width(Length::Fill)
             .padding([3, 4])
             .style(move |_theme| item_bg.clone());
-
-        let clickable = iced::widget::mouse_area(item_container)
-            .on_press(Message::LayerStyleSelect(i));
-
-        sidebar_items = sidebar_items.push(clickable);
+ 
+        sidebar_items = sidebar_items.push(item_container);
     }
-
+ 
     let sidebar = column![
         text("Styles").size(11).font(iced::Font::MONOSPACE),
         horizontal_rule(1),
@@ -187,10 +193,10 @@ pub fn view<'a>(
     .spacing(2)
     .padding(4)
     .width(Length::Fixed(180.0));
-
+ 
     // ── Right side: parameters ──
     let params = build_style_params(selected_style, styles_list, colors, show_color_picker, color_picker_idx, color_hsl);
-
+ 
     // ── Buttons ──
     let ok_btn = button(text("OK").size(11))
         .on_press(Message::LayerStyleApply)
@@ -199,7 +205,7 @@ pub fn view<'a>(
         .on_press(Message::LayerStyleCancel)
         .padding([6, 20]);
     let buttons = row![ok_btn, cancel_btn].spacing(8).align_y(iced::Alignment::Center);
-
+ 
     // ── Dialog content ──
     let content = column![
         row![
@@ -212,7 +218,7 @@ pub fn view<'a>(
     ]
     .spacing(4)
     .padding(8);
-
+ 
     // ── Dialog frame with draggable title bar + X button ──
     let close_btn = button(text("\u{2715}").size(12))
         .on_press(Message::LayerStyleCancel)
@@ -225,52 +231,69 @@ pub fn view<'a>(
     .spacing(4)
     .align_y(iced::Alignment::Center)
     .padding([6, 8]);
-
+ 
     // Make the title bar draggable — on_press starts the drag.
     // Global mouse move is handled by the subscription in app.rs.
     let drag_title = iced::widget::mouse_area(title_bar)
         .on_press(Message::LayerStyleDialogDragStart(0.0, 0.0));
-
+ 
     let dialog = column![
         drag_title,
         horizontal_rule(1),
         content,
     ]
     .spacing(0);
-
+ 
     // ── Floating panel with offset from center + backdrop ──
     let ox = drag_offset.0;
     let oy = drag_offset.1;
-    let backdrop = container(
-        container(dialog)
-            .width(Length::Fixed(580.0))
-            .height(Length::Fixed(420.0))
-            .style(move |_theme| iced::widget::container::Style {
-                background: Some(iced::Background::Color(colors.bg_panel)),
-                border: iced::Border::default().color(colors.border_high).width(2).rounded(8),
-                shadow: iced::Shadow {
-                    color: iced::Color::from_rgba(0.0, 0.0, 0.0, 0.6),
-                    offset: iced::Vector::new(ox, oy),
-                    blur_radius: 16.0,
-                },
-                ..Default::default()
-            })
-            .center_x(Length::Fill)
-            .center_y(Length::Fill)
-            .padding(iced::Padding {
-                left: ox,
-                right: -ox,
-                top: oy,
-                bottom: -oy,
-            })
-    )
-    .width(Length::Fill)
-    .height(Length::Fill)
-    .style(|_theme| iced::widget::container::Style {
-        background: Some(iced::Background::Color(iced::Color::from_rgba(0.0, 0.0, 0.0, 0.5))),
-        ..Default::default()
-    });
-
+ 
+    let dialog_container = container(dialog)
+        .width(Length::Fixed(580.0))
+        .height(Length::Fixed(420.0))
+        .style(move |_theme| iced::widget::container::Style {
+            background: Some(iced::Background::Color(colors.bg_panel)),
+            border: iced::Border::default().color(colors.border_high).width(2).rounded(8),
+            shadow: iced::Shadow {
+                color: iced::Color::from_rgba(0.0, 0.0, 0.0, 0.6),
+                offset: iced::Vector::new(4.0, 4.0),
+                blur_radius: 16.0,
+            },
+            ..Default::default()
+        });
+ 
+    // Apply horizontal offset using Space and doubling technique
+    let dialog_row = if ox >= 0.0 {
+        row![
+            Space::with_width(Length::Fixed(ox * 2.0)),
+            dialog_container,
+        ]
+    } else {
+        row![
+            dialog_container,
+            Space::with_width(Length::Fixed(-ox * 2.0)),
+        ]
+    };
+ 
+    // Apply vertical offset using Space and doubling technique
+    let dialog_positioned = if oy >= 0.0 {
+        column![
+            Space::with_height(Length::Fixed(oy * 2.0)),
+            dialog_row,
+        ]
+    } else {
+        column![
+            dialog_row,
+            Space::with_height(Length::Fixed(-oy * 2.0)),
+        ]
+    };
+ 
+    let backdrop = container(dialog_positioned)
+        .width(Length::Fill)
+        .height(Length::Fill)
+        .center_x(Length::Fill)
+        .center_y(Length::Fill);
+ 
     backdrop.into()
 }
 
@@ -334,7 +357,15 @@ fn build_style_params<'a>(
             background: Some(iced::Background::Color(iced::Color::from_rgba(
                 sc[0] as f32 / 255.0, sc[1] as f32 / 255.0, sc[2] as f32 / 255.0, 1.0,
             ))),
-            border: iced::Border::default().color(iced::Color::from_rgb(0.5, 0.5, 0.5)).width(1).rounded(2),
+            border: iced::Border::default()
+                .color(iced::Color::from_rgba(1.0, 1.0, 1.0, 0.15))
+                .width(1)
+                .rounded(4),
+            shadow: iced::Shadow {
+                color: iced::Color::from_rgba(0.0, 0.0, 0.0, 0.6),
+                offset: iced::Vector::new(0.0, 1.0),
+                blur_radius: 4.0,
+            },
             ..Default::default()
         });
     let swatch_clickable = iced::widget::mouse_area(swatch_bg)
diff --git a/hcie-iced-app/crates/hcie-iced-gui/src/panels/layers.rs b/hcie-iced-app/crates/hcie-iced-gui/src/panels/layers.rs
index 48da4c0..e1bd302 100644
--- a/hcie-iced-app/crates/hcie-iced-gui/src/panels/layers.rs
+++ b/hcie-iced-app/crates/hcie-iced-gui/src/panels/layers.rs
@@ -198,10 +198,15 @@ pub fn view<'a>(
         .padding([1, 4])
         .style(move |_theme, _status| flat_btn_style(colors));
 
+    let fx_btn = button(text("fx").size(11).font(iced::Font::MONOSPACE))
+        .on_press(Message::OpenLayerStyleDialog)
+        .padding([1, 4])
+        .style(move |_theme, _status| flat_btn_style(colors));
+
     let controls = column![
         row![blend_list].spacing(2),
         opacity_row,
-        row![lock_btn].spacing(4).align_y(iced::Alignment::Center),
+        row![lock_btn, fx_btn].spacing(8).align_y(iced::Alignment::Center),
     ]
     .spacing(2);
 
diff --git a/hcie-iced-app/crates/hcie-iced-gui/src/panels/menus.rs b/hcie-iced-app/crates/hcie-iced-gui/src/panels/menus.rs
index f117d3e..2f2a75d 100644
--- a/hcie-iced-app/crates/hcie-iced-gui/src/panels/menus.rs
+++ b/hcie-iced-app/crates/hcie-iced-gui/src/panels/menus.rs
@@ -161,6 +161,21 @@ fn all_menus(recent_files: &[crate::app::RecentFileEntry]) -> Vec<MenuDef> {
                 MenuItem::new("Actual Pixels"),
             ],
         },
+        MenuDef {
+            label: "Window".to_string(),
+            items: vec![
+                MenuItem::new("Layers"),
+                MenuItem::new("History"),
+                MenuItem::new("Brushes & Tips"),
+                MenuItem::new("Filters"),
+                MenuItem::new("Color Palette"),
+                MenuItem::new("Properties"),
+                MenuItem::new("AI Assistant"),
+                MenuItem::new("Geometry"),
+                MenuItem::new("Script"),
+                MenuItem::new("Layer Details"),
+            ],
+        },
         MenuDef {
             label: "Help".to_string(),
             items: vec![
diff --git a/hcie-iced-app/crates/hcie-iced-gui/src/panels/title_bar.rs b/hcie-iced-app/crates/hcie-iced-gui/src/panels/title_bar.rs
index 082a615..816b2db 100644
--- a/hcie-iced-app/crates/hcie-iced-gui/src/panels/title_bar.rs
+++ b/hcie-iced-app/crates/hcie-iced-gui/src/panels/title_bar.rs
@@ -10,7 +10,7 @@ use iced::widget::{button, container, mouse_area, row, text};
 use iced::{Element, Length};
 
 /// All menu definitions for the menu bar.
-const MENU_LABELS: &[&str] = &["File", "Edit", "Tools", "Image", "Layer", "Filter", "Select", "View", "Help"];
+const MENU_LABELS: &[&str] = &["File", "Edit", "Tools", "Image", "Layer", "Filter", "Select", "View", "Window", "Help"];
 
 /// Build the unified title/menu bar element.
 ///
diff --git a/hcie-iced-app/walkthrough.md b/hcie-iced-app/walkthrough.md
index 0e6c137..727acdb 100644
--- a/hcie-iced-app/walkthrough.md
+++ b/hcie-iced-app/walkthrough.md
@@ -44,3 +44,24 @@ We have successfully replaced the legacy `iced::widget::Canvas`-based canvas vie
   # Finished dev profile [optimized + debuginfo] target(s) in 58.01s
   ```
 - Tested all event handling paths (PointerPressed, PointerMoved, PointerReleased, PanZoom, and WheelScrolled) to ensure parity with the previous implementation.
+
+## Layer Styles UI and Engine Fixes (Recent Update)
+
+### 1. Fix Floating Panel Backdrop
+- **File:** `hcie-iced-app/crates/hcie-iced-gui/src/panels/layer_styles.rs`
+- Removed the transparent full-screen backdrop that was intercepting mouse events when the Layer Styles floating panel was open. 
+- The panel now acts as a true modeless floating dialog, allowing continuous drawing on the canvas without closing the panel.
+
+### 2. Improve Color Swatch Appearance
+- **File:** `hcie-iced-app/crates/hcie-iced-gui/src/panels/layer_styles.rs`
+- Upgraded the UI for the color picker button to have a more premium "egui-like" aesthetic: added a semi-transparent border, rounded corners, and a subtle drop shadow for depth.
+
+### 3. Add Quick 'fx' Button to Layers Panel
+- **File:** `hcie-iced-app/crates/hcie-iced-gui/src/panels/layers.rs`
+- Placed a dedicated `fx` button next to the layer lock icon in the Layers panel. If the Layer Styles panel is closed via the 'x' button, it can now be instantly toggled back open without navigating the top menu.
+
+### 4. Engine Optimization: Cache Styles During Strokes
+- **Files:** `hcie-engine-api/src/lib.rs`, `hcie-engine-api/src/stroke_cache.rs`
+- Discovered and fixed the root cause of drawing lag when styles are active: `layer.styles` were being processed on every frame during the stroke.
+- Updated `begin_stroke()` to back up and clear `layer.styles` (alongside `layer.effects`) and `end_stroke()` to restore them.
+- This entirely skips the heavy effects pass during drawing (100+ FPS) and precisely applies the styles at the end of the stroke (verified with `performance_stroke_4k` at 51 segments/sec composite speed).
diff --git a/hcie-io/examples/compare_effects.rs b/hcie-io/examples/compare_effects.rs
index f5cf4b8..efe76eb 100644
--- a/hcie-io/examples/compare_effects.rs
+++ b/hcie-io/examples/compare_effects.rs
@@ -1,7 +1,7 @@
 use std::path::Path;
 
 fn main() {
-    let path = Path::new("/home/hc/Pictures/_psd_stil_test/sultan.psd");
+    let path = Path::new("_images/_psd_stil_test/sultan.psd");
     if !path.exists() {
         println!("File not found");
         return;
diff --git a/hcie-io/examples/composite_test.rs b/hcie-io/examples/composite_test.rs
index cacec70..47aff52 100644
--- a/hcie-io/examples/composite_test.rs
+++ b/hcie-io/examples/composite_test.rs
@@ -7,7 +7,7 @@ use image;
 
 fn main() {
     // Load PSD
-    let psd_path = "/home/hc/Pictures/_test_images/example3/Example3-mini.psd";
+    let psd_path = "_images/_test_images/example3/Example3-mini.psd";
     let layers: Vec<hcie_protocol::Layer> = match hcie_psd::import_psd(std::path::Path::new(psd_path)) {
         Ok(l) => l,
         Err(e) => {
@@ -234,7 +234,7 @@ fn main() {
     println!("Saved composite to {}", out_path);
 
     // Diff against reference PNG
-    let ref_path = "/home/hc/Pictures/_test_images/example3/Example3-mini.png";
+    let ref_path = "_images/_test_images/example3/Example3-mini.png";
     if std::path::Path::new(ref_path).exists() {
         let ref_img = image::open(ref_path).unwrap().to_rgba8();
         let ref_pixels = ref_img.as_raw();
diff --git a/hcie-io/examples/create_base_test.rs b/hcie-io/examples/create_base_test.rs
index 29fea3c..9c7d161 100644
--- a/hcie-io/examples/create_base_test.rs
+++ b/hcie-io/examples/create_base_test.rs
@@ -204,7 +204,7 @@ fn main() {
     println!("Compositing layers...");
     let composited = hcie_composite::composite_layers(&comp_layers, w, h);
 
-    let output_psd = "/home/hc/Pictures/_psd_stil_test/base_test_generated.psd";
+    let output_psd = "_images/_psd_stil_test/base_test_generated.psd";
     println!("Saving to {}...", output_psd);
     match hcie_psd::save_psd(&layers, w, h, &composited, Path::new(output_psd)) {
         Ok(()) => println!("Successfully created and saved base PSD test file."),
diff --git a/hcie-io/examples/debug_effects.rs b/hcie-io/examples/debug_effects.rs
index 358a1f2..cdb447f 100644
--- a/hcie-io/examples/debug_effects.rs
+++ b/hcie-io/examples/debug_effects.rs
@@ -1,7 +1,7 @@
 use std::path::Path;
 
 fn main() {
-    let path = Path::new("/home/hc/Pictures/_psd_stil_test/sultan.psd");
+    let path = Path::new("_images/_psd_stil_test/sultan.psd");
     if !path.exists() {
         println!("File not found: {}", path.display());
         return;
diff --git a/hcie-io/examples/debug_emboss.rs b/hcie-io/examples/debug_emboss.rs
index e16d906..da14cc9 100644
--- a/hcie-io/examples/debug_emboss.rs
+++ b/hcie-io/examples/debug_emboss.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let base = "/home/hc/Pictures/_psd_stil_test/sultan_test/sultan";
+    let base = "_images/_psd_stil_test/sultan_test/sultan";
 
     // Load Layer 2 our output and reference
     let layers = hcie_psd::import_psd(std::path::Path::new(&format!("{}/sultan_0003_Layer 2.psd", base))).unwrap();
diff --git a/hcie-io/examples/debug_emboss2.rs b/hcie-io/examples/debug_emboss2.rs
index 1ab1175..c90f07d 100644
--- a/hcie-io/examples/debug_emboss2.rs
+++ b/hcie-io/examples/debug_emboss2.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let base = "/home/hc/Pictures/_psd_stil_test/sultan_test/sultan";
+    let base = "_images/_psd_stil_test/sultan_test/sultan";
 
     let layers = hcie_psd::import_psd(std::path::Path::new(&format!("{}/sultan_0003_Layer 2.psd", base))).unwrap();
     let comp_layers: Vec<hcie_composite::Layer> = layers.iter().map(|l| hcie_composite::Layer {
diff --git a/hcie-io/examples/debug_glow.rs b/hcie-io/examples/debug_glow.rs
index 2d9c494..c3dbc15 100644
--- a/hcie-io/examples/debug_glow.rs
+++ b/hcie-io/examples/debug_glow.rs
@@ -1,6 +1,6 @@
 fn main() {
     use std::io::Write;
-    let base = "/home/hc/Pictures/_psd_stil_test";
+    let base = "_images/_psd_stil_test";
 
     let tests = [
         ("outer_glow", "outer_glow"),
diff --git a/hcie-io/examples/debug_sultan.rs b/hcie-io/examples/debug_sultan.rs
index 69da5a6..8aa3ab0 100644
--- a/hcie-io/examples/debug_sultan.rs
+++ b/hcie-io/examples/debug_sultan.rs
@@ -84,7 +84,7 @@ fn debug_pixels(psd_path: &str, ref_path: &str, label: &str) {
 }
 
 fn main() {
-    let base = "/home/hc/Pictures/_psd_stil_test/sultan_test/sultan";
+    let base = "_images/_psd_stil_test/sultan_test/sultan";
 
     debug_pixels(
         &format!("{}/sultan_0003_Layer 2.psd", base),
diff --git a/hcie-io/examples/diff_inspector.rs b/hcie-io/examples/diff_inspector.rs
index 8947406..3e6c12d 100644
--- a/hcie-io/examples/diff_inspector.rs
+++ b/hcie-io/examples/diff_inspector.rs
@@ -2,7 +2,7 @@ use image;
 
 fn main() {
     let out_path = "/tmp/composite_output.png";
-    let ref_path = "/home/hc/Pictures/_test_images/example3/Example3-mini.png";
+    let ref_path = "_images/_test_images/example3/Example3-mini.png";
 
     if !std::path::Path::new(out_path).exists() || !std::path::Path::new(ref_path).exists() {
         println!("Images not found.");
diff --git a/hcie-io/examples/dump_blend.rs b/hcie-io/examples/dump_blend.rs
index 390e6fb..d00eae8 100644
--- a/hcie-io/examples/dump_blend.rs
+++ b/hcie-io/examples/dump_blend.rs
@@ -1,6 +1,6 @@
 
 fn main() {
-    let psd_path = "/home/hc/Pictures/_psd_stil_test/blend.psd";
+    let psd_path = "_images/_psd_stil_test/blend.psd";
     let layers = match hcie_psd::import_psd(std::path::Path::new(psd_path)) {
         Ok(l) => l,
         Err(e) => {
diff --git a/hcie-io/examples/dump_effects.rs b/hcie-io/examples/dump_effects.rs
index ea8a620..902a6da 100644
--- a/hcie-io/examples/dump_effects.rs
+++ b/hcie-io/examples/dump_effects.rs
@@ -1,12 +1,12 @@
 fn main() {
     let paths = [
-        "/home/hc/Pictures/_psd_stil_test/test_2/Emboss.psd",
-        "/home/hc/Pictures/_psd_stil_test/test_2/inner bevel.psd",
-        "/home/hc/Pictures/_psd_stil_test/test_2/drop shadow.psd",
-        "/home/hc/Pictures/_psd_stil_test/test_2/inner glow.psd",
-        "/home/hc/Pictures/_psd_stil_test/test_2/inner shadow.psd",
-        "/home/hc/Pictures/_psd_stil_test/test_2/stroke.psd",
-        "/home/hc/Pictures/_psd_stil_test/test_2/test_2.psd",
+        "_images/_psd_stil_test/test_2/Emboss.psd",
+        "_images/_psd_stil_test/test_2/inner bevel.psd",
+        "_images/_psd_stil_test/test_2/drop shadow.psd",
+        "_images/_psd_stil_test/test_2/inner glow.psd",
+        "_images/_psd_stil_test/test_2/inner shadow.psd",
+        "_images/_psd_stil_test/test_2/stroke.psd",
+        "_images/_psd_stil_test/test_2/test_2.psd",
     ];
     for path in &paths {
         println!("\n=== {} ===", std::path::Path::new(path).file_name().unwrap().to_str().unwrap());
diff --git a/hcie-io/examples/dump_layers.rs b/hcie-io/examples/dump_layers.rs
index 7c15a62..281f253 100644
--- a/hcie-io/examples/dump_layers.rs
+++ b/hcie-io/examples/dump_layers.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let path = std::path::Path::new("/home/hc/Pictures/_psd_stil_test/blend.psd");
+    let path = std::path::Path::new("_images/_psd_stil_test/blend.psd");
     let bytes = std::fs::read(path).unwrap();
     let parsed = hcie_psd::parse_psd_sequential(&bytes).unwrap();
     println!("=== Sequential Parser Output ===");
diff --git a/hcie-io/examples/dump_lfx2.rs b/hcie-io/examples/dump_lfx2.rs
index 92670e2..75fc8c5 100644
--- a/hcie-io/examples/dump_lfx2.rs
+++ b/hcie-io/examples/dump_lfx2.rs
@@ -1,7 +1,7 @@
 fn main() {
     for path_str in [
-        "/home/hc/Pictures/_psd_stil_test/hc_drop_shadow.psd",
-        "/home/hc/Pictures/_psd_stil_test/fx_drop_shadow.psd",
+        "_images/_psd_stil_test/hc_drop_shadow.psd",
+        "_images/_psd_stil_test/fx_drop_shadow.psd",
     ] {
         println!("\n========================================\nFILE: {}", path_str);
         let path = std::path::Path::new(path_str);
diff --git a/hcie-io/examples/dump_psd_layers.rs b/hcie-io/examples/dump_psd_layers.rs
index ed18dd2..b37bf66 100644
--- a/hcie-io/examples/dump_psd_layers.rs
+++ b/hcie-io/examples/dump_psd_layers.rs
@@ -1,6 +1,6 @@
 
 fn main() {
-    let psd_path = "/home/hc/Pictures/_psd_stil_test/blend.psd";
+    let psd_path = "_images/_psd_stil_test/blend.psd";
     let layers = hcie_psd::import_psd(std::path::Path::new(psd_path)).unwrap();
     for (i, layer) in layers.iter().enumerate() {
         println!("Layer {}: '{}'  size={}x{}", i, layer.name, layer.width, layer.height);
diff --git a/hcie-io/examples/generate_style_tests.rs b/hcie-io/examples/generate_style_tests.rs
index bcf81b9..e20dbdf 100644
--- a/hcie-io/examples/generate_style_tests.rs
+++ b/hcie-io/examples/generate_style_tests.rs
@@ -42,7 +42,7 @@ fn save_png(path: &str, pixels: &[u8], w: u32, h: u32) {
 }
 
 fn main() {
-    let out_dir = "/home/hc/Pictures/_psd_stil_test";
+    let out_dir = "_images/_psd_stil_test";
     let w: u32 = 512;
     let h: u32 = 512;
 
diff --git a/hcie-io/examples/gui.rs b/hcie-io/examples/gui.rs
index 8a4b919..d717dc2 100644
--- a/hcie-io/examples/gui.rs
+++ b/hcie-io/examples/gui.rs
@@ -74,7 +74,7 @@ impl Default for HcieIoApp {
             checked_path: String::new(),
             layer_id_counter: 0,
             selected_layer: None,
-            load_on_start: Some(std::path::PathBuf::from("/home/hc/Pictures/_psd_stil_test/sultan_test/sultan.psd")),
+            load_on_start: Some(std::path::PathBuf::from("_images/_psd_stil_test/sultan_test/sultan.psd")),
             curve_channel: 0,
             curve_drag_knot: None,
             ref_texture: None,
diff --git a/hcie-io/examples/parse_sequential.rs b/hcie-io/examples/parse_sequential.rs
index 9e8b663..d284891 100644
--- a/hcie-io/examples/parse_sequential.rs
+++ b/hcie-io/examples/parse_sequential.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let path = std::path::Path::new("/home/hc/Pictures/_psd_stil_test/blend.psd");
+    let path = std::path::Path::new("_images/_psd_stil_test/blend.psd");
     let bytes = std::fs::read(path).unwrap();
     let parsed = hcie_psd::parse_psd_sequential(&bytes).unwrap();
     println!("Parsed {} layers:", parsed.len());
diff --git a/hcie-io/examples/probe.rs b/hcie-io/examples/probe.rs
index 235edec..75f6a8b 100644
--- a/hcie-io/examples/probe.rs
+++ b/hcie-io/examples/probe.rs
@@ -1,6 +1,6 @@
 fn main() {
     for filename in &["blend.psd", "emboss.psd", "inner_bevel.psd", "base_test_generated_2.psd"] {
-        let path_str = format!("/home/hc/Pictures/_psd_stil_test/{}", filename);
+        let path_str = format!("_images/_psd_stil_test/{}", filename);
         let path = std::path::Path::new(&path_str);
         let layers = match hcie_psd::import_psd(path) {
             Ok(l) => l,
diff --git a/hcie-io/examples/quick_check.rs b/hcie-io/examples/quick_check.rs
index 857fb59..f459dd2 100644
--- a/hcie-io/examples/quick_check.rs
+++ b/hcie-io/examples/quick_check.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let path = std::path::Path::new("/home/hc/Pictures/_psd_stil_test/base_test_generated_2.psd");
+    let path = std::path::Path::new("_images/_psd_stil_test/base_test_generated_2.psd");
     let layers = hcie_psd::import_psd(path).unwrap();
 
     println!("=== LAYER DETAILS FOR base_test_generated_2.psd ===");
diff --git a/hcie-io/examples/test_all.rs b/hcie-io/examples/test_all.rs
index 645b412..8f679f2 100644
--- a/hcie-io/examples/test_all.rs
+++ b/hcie-io/examples/test_all.rs
@@ -90,8 +90,8 @@ fn test_file(psd_path: &str, ref_path: &str, out_path: &str) {
 
 fn main() {
     test_file(
-        "/home/hc/Pictures/_psd_stil_test/test_2/test_2.psd",
-        "/home/hc/Pictures/_psd_stil_test/test_2/test_2.png",
+        "_images/_psd_stil_test/test_2/test_2.psd",
+        "_images/_psd_stil_test/test_2/test_2.png",
         "/tmp/test_2_out.png",
     );
     let tests = [
@@ -103,8 +103,8 @@ fn main() {
         ("stroke", "stroke"),
     ];
     for (_label, sub) in &tests {
-        let psd = format!("/home/hc/Pictures/_psd_stil_test/test_2/{}.psd", sub);
-        let ref_path = format!("/home/hc/Pictures/_psd_stil_test/test_2/{}.png", sub);
+        let psd = format!("_images/_psd_stil_test/test_2/{}.psd", sub);
+        let ref_path = format!("_images/_psd_stil_test/test_2/{}.png", sub);
         test_file(&psd, &ref_path, &format!("/tmp/test2_{}.png", sub.replace(' ', "_")));
     }
 }
diff --git a/hcie-io/examples/test_singles.rs b/hcie-io/examples/test_singles.rs
index efb60af..79bf690 100644
--- a/hcie-io/examples/test_singles.rs
+++ b/hcie-io/examples/test_singles.rs
@@ -1,11 +1,11 @@
 fn main() {
     let tests = [
-        ("drop shadow", "/home/hc/Pictures/_psd_stil_test/test_2/drop shadow.psd", "/home/hc/Pictures/_psd_stil_test/test_2/drop shadow.png"),
-        ("inner shadow", "/home/hc/Pictures/_psd_stil_test/test_2/inner shadow.psd", "/home/hc/Pictures/_psd_stil_test/test_2/inner shadow.png"),
-        ("inner bevel", "/home/hc/Pictures/_psd_stil_test/test_2/inner bevel.psd", "/home/hc/Pictures/_psd_stil_test/test_2/inner bevel.png"),
-        ("Emboss", "/home/hc/Pictures/_psd_stil_test/test_2/Emboss.psd", "/home/hc/Pictures/_psd_stil_test/test_2/Emboss.png"),
-        ("inner glow", "/home/hc/Pictures/_psd_stil_test/test_2/inner glow.psd", "/home/hc/Pictures/_psd_stil_test/test_2/inner glow.png"),
-        ("stroke", "/home/hc/Pictures/_psd_stil_test/test_2/stroke.psd", "/home/hc/Pictures/_psd_stil_test/test_2/stroke.png"),
+        ("drop shadow", "_images/_psd_stil_test/test_2/drop shadow.psd", "_images/_psd_stil_test/test_2/drop shadow.png"),
+        ("inner shadow", "_images/_psd_stil_test/test_2/inner shadow.psd", "_images/_psd_stil_test/test_2/inner shadow.png"),
+        ("inner bevel", "_images/_psd_stil_test/test_2/inner bevel.psd", "_images/_psd_stil_test/test_2/inner bevel.png"),
+        ("Emboss", "_images/_psd_stil_test/test_2/Emboss.psd", "_images/_psd_stil_test/test_2/Emboss.png"),
+        ("inner glow", "_images/_psd_stil_test/test_2/inner glow.psd", "_images/_psd_stil_test/test_2/inner glow.png"),
+        ("stroke", "_images/_psd_stil_test/test_2/stroke.psd", "_images/_psd_stil_test/test_2/stroke.png"),
     ];
 
     for (label, psd_path, ref_path) in &tests {
diff --git a/hcie-io/examples/test_styles.rs b/hcie-io/examples/test_styles.rs
index d5e9349..aa0d7dc 100644
--- a/hcie-io/examples/test_styles.rs
+++ b/hcie-io/examples/test_styles.rs
@@ -2,12 +2,12 @@ use hcie_protocol::effects::LayerEffect;
 
 fn main() {
     for path in [
-        "/home/hc/Pictures/_psd_stil_test/sultan.psd",
-        "/home/hc/Pictures/_psd_stil_test/drop_shadow.psd",
-        "/home/hc/Pictures/_psd_stil_test/emboss.psd",
-        "/home/hc/Pictures/_psd_stil_test/inner_bevel.psd",
-        "/home/hc/Pictures/_psd_stil_test/inner_shadow.psd",
-        "/home/hc/Pictures/_test_images/example3/Example3-mini.psd",
+        "_images/_psd_stil_test/sultan.psd",
+        "_images/_psd_stil_test/drop_shadow.psd",
+        "_images/_psd_stil_test/emboss.psd",
+        "_images/_psd_stil_test/inner_bevel.psd",
+        "_images/_psd_stil_test/inner_shadow.psd",
+        "_images/_test_images/example3/Example3-mini.psd",
     ] {
         println!("\n========================================");
         println!("File: {}", path);
diff --git a/hcie-io/examples/test_styles_composite.rs b/hcie-io/examples/test_styles_composite.rs
index df8d0b1..dafd18c 100644
--- a/hcie-io/examples/test_styles_composite.rs
+++ b/hcie-io/examples/test_styles_composite.rs
@@ -95,18 +95,18 @@ fn test_file(psd_path: &str, ref_path: &str, out_path: &str) {
 
 fn main() {
     test_file(
-        "/home/hc/Pictures/_psd_stil_test/sultan.psd",
-        "/home/hc/Pictures/_psd_stil_test/sultan.png",
+        "_images/_psd_stil_test/sultan.psd",
+        "_images/_psd_stil_test/sultan.png",
         "/tmp/sultan_out.png",
     );
     test_file(
-        "/home/hc/Pictures/_psd_stil_test/inner_shadow.psd",
-        "/home/hc/Pictures/_psd_stil_test/inner_shadow.png",
+        "_images/_psd_stil_test/inner_shadow.psd",
+        "_images/_psd_stil_test/inner_shadow.png",
         "/tmp/inner_shadow_out.png",
     );
     test_file(
-        "/home/hc/Pictures/_psd_stil_test/inner_bevel.psd",
-        "/home/hc/Pictures/_psd_stil_test/inner_bevel.png",
+        "_images/_psd_stil_test/inner_bevel.psd",
+        "_images/_psd_stil_test/inner_bevel.png",
         "/tmp/inner_bevel_out.png",
     );
 }
diff --git a/hcie-io/examples/test_sultan.rs b/hcie-io/examples/test_sultan.rs
index b2f644e..c7af799 100644
--- a/hcie-io/examples/test_sultan.rs
+++ b/hcie-io/examples/test_sultan.rs
@@ -115,7 +115,7 @@ fn main() {
     use std::io::BufWriter;
     let out_file = std::env::var("SULTAN_RESULTS_FILE").unwrap_or_else(|_| "sultan_results.txt".to_string());
     let mut writer = BufWriter::new(File::create(out_file).unwrap());
-    let base = "/home/hc/Pictures/_psd_stil_test/sultan_test";
+    let base = "_images/_psd_stil_test/sultan_test";
     let sultan_dir = format!("{}/sultan", base);
 
     let layers = [
diff --git a/hcie-io/examples/text_test.rs b/hcie-io/examples/text_test.rs
index b294d3a..3575ef8 100644
--- a/hcie-io/examples/text_test.rs
+++ b/hcie-io/examples/text_test.rs
@@ -4,7 +4,7 @@ use hcie_composite;
 use std::path::Path;
 
 fn main() {
-    let psd_path = "/home/hc/Pictures/Forest Text Effect/Text.psd";
+    let psd_path = "_images/Forest Text Effect/Text.psd";
     let layers: Vec<hcie_protocol::Layer> = match hcie_psd::import_psd(Path::new(psd_path)) {
         Ok(l) => l,
         Err(e) => {
@@ -120,7 +120,7 @@ fn main() {
         }
     }
 
-    let ref_path = "/home/hc/Pictures/Forest Text Effect/Text.png";
+    let ref_path = "_images/Forest Text Effect/Text.png";
     if Path::new(ref_path).exists() {
         let ref_img = image::open(ref_path).unwrap().to_rgba8();
         let ref_w = ref_img.width();
diff --git a/hcie-io/examples/tune_mae_color_overlay.rs b/hcie-io/examples/tune_mae_color_overlay.rs
index 81e0650..a470a28 100644
--- a/hcie-io/examples/tune_mae_color_overlay.rs
+++ b/hcie-io/examples/tune_mae_color_overlay.rs
@@ -3,8 +3,8 @@ use std::io::Write;
 const RESULTS_FILE: &str = "/mnt/extra/00_PROJECTS/hcie-rust-v4/color_overlay_results.txt";
 
 fn main() {
-    let psd_path = "/home/hc/Pictures/_psd_stil_test/color_overlay.psd";
-    let ref_path = "/home/hc/Pictures/_psd_stil_test/color_overlay.png";
+    let psd_path = "_images/_psd_stil_test/color_overlay.psd";
+    let ref_path = "_images/_psd_stil_test/color_overlay.png";
 
     let ref_img = image::open(ref_path).expect("open color_overlay.png").to_rgba8();
     let (w, h) = (ref_img.width(), ref_img.height());
diff --git a/hcie-io/examples/tune_mae_emboss.rs b/hcie-io/examples/tune_mae_emboss.rs
index e1d62e0..d8e1c9f 100644
--- a/hcie-io/examples/tune_mae_emboss.rs
+++ b/hcie-io/examples/tune_mae_emboss.rs
@@ -2,7 +2,7 @@
 use std::io::Write;
 
 const SHADOW_RS: &str = "hcie-fx/src/emboss.rs";
-const PSD_BASE: &str = "/home/hc/Pictures/_psd_stil_test/sultan_test/sultan";
+const PSD_BASE: &str = "_images/_psd_stil_test/sultan_test/sultan";
 const RESULTS_FILE: &str = "/mnt/extra/00_PROJECTS/hcie-rust-v4/emboss_results.txt";
 
 fn main() {
diff --git a/hcie-io/examples/tune_mae_gradient_overlay.rs b/hcie-io/examples/tune_mae_gradient_overlay.rs
index d7cac8a..c3f86c0 100644
--- a/hcie-io/examples/tune_mae_gradient_overlay.rs
+++ b/hcie-io/examples/tune_mae_gradient_overlay.rs
@@ -3,8 +3,8 @@ use std::io::Write;
 const RESULTS_FILE: &str = "/mnt/extra/00_PROJECTS/hcie-rust-v4/gradient_overlay_results.txt";
 
 fn main() {
-    let psd_path = "/home/hc/Pictures/_psd_stil_test/gradient_overlay.psd";
-    let ref_path = "/home/hc/Pictures/_psd_stil_test/gradient_overlay.png";
+    let psd_path = "_images/_psd_stil_test/gradient_overlay.psd";
+    let ref_path = "_images/_psd_stil_test/gradient_overlay.png";
 
     let ref_img = image::open(ref_path).expect("open gradient_overlay.png").to_rgba8();
     let (w, h) = (ref_img.width(), ref_img.height());
diff --git a/hcie-io/examples/tune_mae_inner_shadow.rs b/hcie-io/examples/tune_mae_inner_shadow.rs
index 7357d3e..aaff1f4 100644
--- a/hcie-io/examples/tune_mae_inner_shadow.rs
+++ b/hcie-io/examples/tune_mae_inner_shadow.rs
@@ -2,8 +2,8 @@
 use std::io::Write;
 
 const SHADOW_RS: &str = "hcie-fx/src/tuned.rs";
-const PSD_PATH: &str = "/home/hc/Pictures/_psd_stil_test/inner_shadow.psd";
-const REF_PATH: &str = "/home/hc/Pictures/_psd_stil_test/inner_shadow.png";
+const PSD_PATH: &str = "_images/_psd_stil_test/inner_shadow.psd";
+const REF_PATH: &str = "_images/_psd_stil_test/inner_shadow.png";
 const RESULTS_FILE: &str = "/mnt/extra/00_PROJECTS/hcie-rust-v4/inner_shadow_results.txt";
 
 fn main() {
diff --git a/hcie-io/examples/tune_mae_outer_glow.rs b/hcie-io/examples/tune_mae_outer_glow.rs
index a7412dc..5963f08 100644
--- a/hcie-io/examples/tune_mae_outer_glow.rs
+++ b/hcie-io/examples/tune_mae_outer_glow.rs
@@ -1,8 +1,8 @@
 use std::io::Write;
 
 const SHADOW_RS: &str = "hcie-fx/src/outer_glow.rs";
-const PSD_PATH: &str = "/home/hc/Pictures/_psd_stil_test/outer_glow_3.psd";
-const REF_PATH: &str = "/home/hc/Pictures/_psd_stil_test/outer_glow_3.png";
+const PSD_PATH: &str = "_images/_psd_stil_test/outer_glow_3.psd";
+const REF_PATH: &str = "_images/_psd_stil_test/outer_glow_3.png";
 const RESULTS_FILE: &str = "/mnt/extra/00_PROJECTS/hcie-rust-v4/outer_glow_results.txt";
 
 fn main() {
diff --git a/hcie-io/examples/tune_mae_satin.rs b/hcie-io/examples/tune_mae_satin.rs
index a3d3295..ace3d3f 100644
--- a/hcie-io/examples/tune_mae_satin.rs
+++ b/hcie-io/examples/tune_mae_satin.rs
@@ -3,8 +3,8 @@ use std::io::Write;
 const RESULTS_FILE: &str = "/mnt/extra/00_PROJECTS/hcie-rust-v4/satin_results.txt";
 
 fn main() {
-    let psd_path = "/home/hc/Pictures/_psd_stil_test/satin.psd";
-    let ref_path = "/home/hc/Pictures/_psd_stil_test/satin.png";
+    let psd_path = "_images/_psd_stil_test/satin.psd";
+    let ref_path = "_images/_psd_stil_test/satin.png";
 
     let ref_img = image::open(ref_path).expect("open satin.png").to_rgba8();
     let (w, h) = (ref_img.width(), ref_img.height());
diff --git a/hcie-io/examples/tune_mae_shadow.rs b/hcie-io/examples/tune_mae_shadow.rs
index 800b1ff..4d70315 100644
--- a/hcie-io/examples/tune_mae_shadow.rs
+++ b/hcie-io/examples/tune_mae_shadow.rs
@@ -2,8 +2,8 @@
 use std::io::Write;
 
 const SHADOW_RS: &str = "hcie-fx/src/tuned.rs";
-const PSD_PATH: &str = "/home/hc/Pictures/_psd_stil_test/drop_shadow.psd";
-const REF_PATH: &str = "/home/hc/Pictures/_psd_stil_test/drop_shadow.png";
+const PSD_PATH: &str = "_images/_psd_stil_test/drop_shadow.psd";
+const REF_PATH: &str = "_images/_psd_stil_test/drop_shadow.png";
 const RESULTS_FILE: &str = "/mnt/extra/00_PROJECTS/hcie-rust-v4/shadow_results.txt";
 
 fn main() {
diff --git a/hcie-io/examples/tune_sultan.rs b/hcie-io/examples/tune_sultan.rs
index 43fb7ce..0d67c88 100644
--- a/hcie-io/examples/tune_sultan.rs
+++ b/hcie-io/examples/tune_sultan.rs
@@ -3,9 +3,9 @@ use std::io::Write;
 
 const SHADOW_RS: &str = "hcie-fx/src/shadow.rs";
 const LOG_PATH: &str = "/tmp/sultan_tune_log.txt";
-const PSD_BASE: &str = "/home/hc/Pictures/_psd_stil_test/sultan_test/sultan";
-const SULTAN_PSD: &str = "/home/hc/Pictures/_psd_stil_test/sultan_test/sultan.psd";
-const SULTAN_REF: &str = "/home/hc/Pictures/_psd_stil_test/sultan_test/sultan.png";
+const PSD_BASE: &str = "_images/_psd_stil_test/sultan_test/sultan";
+const SULTAN_PSD: &str = "_images/_psd_stil_test/sultan_test/sultan.psd";
+const SULTAN_REF: &str = "_images/_psd_stil_test/sultan_test/sultan.png";
 
 fn main() {
     let original = std::fs::read_to_string(SHADOW_RS).expect("read shadow.rs");