diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index ba759a8c2e..10fe84e021 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -34,6 +34,7 @@ dependencies = [
  "libc",
  "little_exif",
  "log",
+ "lsdetect",
  "memmap2",
  "mimalloc",
  "mozjpeg-rs",
@@ -3726,6 +3727,15 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
 
+[[package]]
+name = "lsdetect"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "042f46bce4d9622bb7243bb1d18cac317d1df7891d5f648b96590aed3d773e6f"
+dependencies = [
+ "rayon",
+]
+
 [[package]]
 name = "macro_rules_attribute"
 version = "0.2.3"
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index af61552dc4..2a5707b10e 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -36,6 +36,7 @@ tokio = { version = "1", features = ["full"] }
 uuid = { version = "1.25", features = ["v4", "serde"] }
 walkdir = "2.5.0"
 imageproc = "0.27.0"
+lsdetect = "0.3.0"
 ort = { version = "=2.0.0-rc.10", features = ["ndarray", "load-dynamic"] }
 ndarray = "0.16"
 tauri-plugin-process = "2.3.1"
diff --git a/src-tauri/src/adjustment_utils.rs b/src-tauri/src/adjustment_utils.rs
index ada9e755d1..07e007728b 100644
--- a/src-tauri/src/adjustment_utils.rs
+++ b/src-tauri/src/adjustment_utils.rs
@@ -90,17 +90,25 @@ pub fn hydrate_adjustments(state: &tauri::State<AppState>, adjustments: &mut ser
     }
 }
 
-pub fn apply_spatial_transformations<'a, I: IntoCowImage<'a>>(
+pub fn apply_orientation_and_flip<'a, I: IntoCowImage<'a>>(
     image: I,
     adjustments: &serde_json::Value,
-) -> (Cow<'a, DynamicImage>, (f32, f32)) {
+) -> Cow<'a, DynamicImage> {
     let orientation_steps = adjustments["orientationSteps"].as_u64().unwrap_or(0) as u8;
-    let rotation_degrees = adjustments["rotation"].as_f64().unwrap_or(0.0) as f32;
     let flip_horizontal = adjustments["flipHorizontal"].as_bool().unwrap_or(false);
     let flip_vertical = adjustments["flipVertical"].as_bool().unwrap_or(false);
 
     let coarse_rotated_image = apply_coarse_rotation(image.into_cow(), orientation_steps);
-    let flipped_image = apply_flip(coarse_rotated_image, flip_horizontal, flip_vertical);
+    apply_flip(coarse_rotated_image, flip_horizontal, flip_vertical)
+}
+
+pub fn apply_spatial_transformations<'a, I: IntoCowImage<'a>>(
+    image: I,
+    adjustments: &serde_json::Value,
+) -> (Cow<'a, DynamicImage>, (f32, f32)) {
+    let rotation_degrees = adjustments["rotation"].as_f64().unwrap_or(0.0) as f32;
+
+    let flipped_image = apply_orientation_and_flip(image, adjustments);
     let rotated_image = apply_rotation(flipped_image, rotation_degrees);
 
     let crop_data: Option<Crop> = serde_json::from_value(adjustments["crop"].clone()).ok();
diff --git a/src-tauri/src/auto_straighten.rs b/src-tauri/src/auto_straighten.rs
new file mode 100644
index 0000000000..0f34a1a728
--- /dev/null
+++ b/src-tauri/src/auto_straighten.rs
@@ -0,0 +1,373 @@
+use crate::AppState;
+use crate::adjustment_utils::apply_orientation_and_flip;
+use crate::formats::is_raw_file;
+use crate::guided_perspective::{cross, unit_norm};
+use crate::image_processing::{Crop, downscale_f32_image};
+use crate::mask_generation::build_full_warped_image;
+use image::{DynamicImage, GrayImage};
+use serde_json::{Value, json};
+
+const ANALYSIS_MAX_DIM: u32 = 1024;
+const LSD_SCALE: f64 = 0.8;
+const MAX_AXIS_DEVIATION_DEGREES: f64 = 30.0;
+const MIN_SEGMENT_LENGTH_FRACTION: f64 = 0.02;
+const MIN_VANISHING_DISTANCE: f64 = 5.0;
+const MIN_CLASS_LINES: usize = 3;
+const MIN_CLASS_LENGTH_FRACTION: f64 = 0.25;
+const MAX_ROTATION_DEGREES: f64 = 10.0;
+const MAX_CANDIDATE_LINES: usize = 60;
+const TUNING_ROUNDS: usize = 5;
+const ELIMINATION_RATIO: f64 = 0.6;
+const NEAR_ZERO: f64 = 1e-12;
+
+struct LineSegment {
+    line: [f64; 3],
+    deviation: f64,
+    length: f64,
+    vertical: bool,
+}
+
+fn dot(a: [f64; 3], b: [f64; 3]) -> f64 {
+    a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+}
+
+fn detect_segments(gray: &GrayImage) -> Vec<LineSegment> {
+    let (width, height) = gray.dimensions();
+    let min_length = width.max(height) as f64 * MIN_SEGMENT_LENGTH_FRACTION;
+    lsdetect::detect(gray.as_raw(), width as usize, height as usize, LSD_SCALE)
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(|segment| {
+            let length = segment.length();
+            if length < min_length {
+                return None;
+            }
+            let angle = segment.angle();
+            let (vertical, deviation) = if angle.abs() <= MAX_AXIS_DEVIATION_DEGREES {
+                (false, angle)
+            } else if angle.abs() >= 90.0 - MAX_AXIS_DEVIATION_DEGREES {
+                (true, angle - 90.0 * angle.signum())
+            } else {
+                return None;
+            };
+            let line = cross([segment.x1, segment.y1, 1.0], [segment.x2, segment.y2, 1.0]);
+            let norm = line[0].hypot(line[1]);
+            (norm > f64::EPSILON).then(|| LineSegment {
+                line: [line[0] / norm, line[1] / norm, line[2] / norm],
+                deviation,
+                length,
+                vertical,
+            })
+        })
+        .collect()
+}
+
+fn vanishing_point(a: &LineSegment, b: &LineSegment, width: f64, height: f64) -> Option<[f64; 3]> {
+    let point = cross(a.line, b.line);
+    if point.iter().all(|component| component.abs() < NEAR_ZERO) {
+        return None;
+    }
+    if point[2].abs() > NEAR_ZERO {
+        let (x, y) = (point[0] / point[2], point[1] / point[2]);
+        if (0.0..=width).contains(&x) && (0.0..=height).contains(&y) {
+            return None;
+        }
+    }
+    Some(unit_norm(point))
+}
+
+fn candidate_points(
+    lines: &[&LineSegment],
+    width: f64,
+    height: f64,
+) -> Vec<(usize, usize, [f64; 3])> {
+    let mut longest: Vec<usize> = (0..lines.len()).collect();
+    longest.sort_by(|&a, &b| lines[b].length.total_cmp(&lines[a].length));
+    longest.truncate(MAX_CANDIDATE_LINES);
+    longest
+        .iter()
+        .enumerate()
+        .flat_map(|(n, &i)| longest[n + 1..].iter().map(move |&j| (i, j)))
+        .filter_map(|(i, j)| {
+            vanishing_point(lines[i], lines[j], width, height).map(|point| (i, j, point))
+        })
+        .collect()
+}
+
+fn vanishing_consensus(
+    lines: &[&LineSegment],
+    width: f64,
+    height: f64,
+) -> (Vec<bool>, Option<[f64; 3]>) {
+    let count = lines.len();
+    let candidates = candidate_points(lines, width, height);
+    if count < MIN_CLASS_LINES || candidates.is_empty() {
+        return (vec![false; count], None);
+    }
+    let total_length: f64 = lines.iter().map(|line| line.length).sum();
+    let mut epsilon = 1e-2f64;
+    let mut step = 1.0f64;
+
+    for _ in 0..TUNING_ROUNDS {
+        let eliminated: usize = candidates
+            .iter()
+            .map(|&(i, j, point)| {
+                (0..count)
+                    .filter(|&k| k != i && k != j && dot(point, lines[k].line).abs() >= epsilon)
+                    .count()
+            })
+            .sum();
+        let ratio = eliminated as f64 / (count * candidates.len()) as f64;
+        if ratio < ELIMINATION_RATIO {
+            epsilon = 10f64.powf(epsilon.log10() - step);
+        } else if ratio > ELIMINATION_RATIO {
+            epsilon = 10f64.powf(epsilon.log10() + step);
+        }
+        step /= 2.0;
+    }
+
+    let mut best_quality = 0.0;
+    let mut best_inliers = vec![false; count];
+    let mut best_point = None;
+    for &(i, j, point) in &candidates {
+        let mut quality = 0.0;
+        let inliers: Vec<bool> = (0..count)
+            .map(|k| {
+                if k == i || k == j {
+                    return true;
+                }
+                let distance = dot(point, lines[k].line).abs();
+                if distance >= epsilon {
+                    return false;
+                }
+                let share = lines[k].length / total_length;
+                quality += 0.33 / count as f64
+                    + 0.33 * share
+                    + 0.33 * (1.0 - distance / epsilon) * count as f64 * share;
+                true
+            })
+            .collect();
+        if quality > best_quality {
+            best_quality = quality;
+            best_inliers = inliers;
+            best_point = Some(point);
+        }
+    }
+    (best_inliers, best_point)
+}
+
+fn trusted_lines(
+    segments: &[LineSegment],
+    vertical: bool,
+    width: f64,
+    height: f64,
+) -> Vec<&LineSegment> {
+    let class: Vec<&LineSegment> = segments
+        .iter()
+        .filter(|segment| segment.vertical == vertical)
+        .collect();
+    let (inliers, point) = vanishing_consensus(&class, width, height);
+    let kept: Vec<&LineSegment> = class
+        .into_iter()
+        .zip(inliers)
+        .filter_map(|(segment, keep)| keep.then_some(segment))
+        .collect();
+    let far = point.is_some_and(|p| {
+        p[2].abs() < NEAR_ZERO
+            || (p[0] / p[2] - width / 2.0).hypot(p[1] / p[2] - height / 2.0)
+                >= MIN_VANISHING_DISTANCE * width.hypot(height)
+    });
+    let length: f64 = kept.iter().map(|segment| segment.length).sum();
+    if far
+        && kept.len() >= MIN_CLASS_LINES
+        && length >= width.max(height) * MIN_CLASS_LENGTH_FRACTION
+    {
+        kept
+    } else {
+        Vec::new()
+    }
+}
+
+fn fit_rotation(lines: &[&LineSegment]) -> f64 {
+    let total = lines.len() as f64;
+    let class_totals = |vertical: bool| -> (f64, f64) {
+        lines
+            .iter()
+            .filter(|line| line.vertical == vertical)
+            .fold((0.0, 0.0), |(length, count), line| {
+                (length + line.length, count + 1.0)
+            })
+    };
+    let vertical_totals = class_totals(true);
+    let horizontal_totals = class_totals(false);
+    let (sin_sum, cos_sum) = lines.iter().fold((0.0, 0.0), |(sin_sum, cos_sum), line| {
+        let (class_length, class_count) = if line.vertical {
+            vertical_totals
+        } else {
+            horizontal_totals
+        };
+        let weight = line.length / class_length * class_count / total;
+        let doubled = (2.0 * line.deviation).to_radians();
+        (
+            sin_sum + weight * doubled.sin(),
+            cos_sum + weight * doubled.cos(),
+        )
+    });
+    -0.5 * sin_sum.atan2(cos_sum).to_degrees()
+}
+
+fn detect_rotation(gray: &GrayImage) -> Option<f64> {
+    let (width, height) = (gray.width() as f64, gray.height() as f64);
+    let segments = detect_segments(gray);
+    let mut selected = trusted_lines(&segments, true, width, height);
+    selected.extend(trusted_lines(&segments, false, width, height));
+    if selected.is_empty() {
+        return None;
+    }
+    let rotation = fit_rotation(&selected);
+    (rotation.abs() <= MAX_ROTATION_DEGREES).then_some(rotation)
+}
+
+fn rotation_for_image(image: &DynamicImage, is_raw: bool, adjustments: &Value) -> Option<f64> {
+    let proxy = downscale_f32_image(image, ANALYSIS_MAX_DIM, ANALYSIS_MAX_DIM);
+    let warped = build_full_warped_image(&proxy, is_raw, adjustments);
+    let oriented = apply_orientation_and_flip(warped, adjustments);
+    detect_rotation(&oriented.to_luma8()).map(|rotation| (rotation * 10.0).round() / 10.0)
+}
+
+fn crop_within_bounds(crop: &Crop, width: f64, height: f64, rotation: f64) -> bool {
+    let (sin, cos) = (-rotation).to_radians().sin_cos();
+    let (cx, cy) = (width / 2.0, height / 2.0);
+    [
+        (crop.x, crop.y),
+        (crop.x + crop.width, crop.y),
+        (crop.x, crop.y + crop.height),
+        (crop.x + crop.width, crop.y + crop.height),
+    ]
+    .iter()
+    .all(|&(x, y)| {
+        let rx = cos * (x - cx) - sin * (y - cy) + cx;
+        let ry = sin * (x - cx) + cos * (y - cy) + cy;
+        (-1.0..=width + 1.0).contains(&rx) && (-1.0..=height + 1.0).contains(&ry)
+    })
+}
+
+fn centered_crop(width: f64, height: f64, aspect_ratio: f64, rotation: f64) -> Crop {
+    let (sin, cos) = (rotation.abs() % 180.0).to_radians().sin_cos();
+    let crop_height = (height / (aspect_ratio * sin + cos)).min(width / (aspect_ratio * cos + sin));
+    let crop_width = aspect_ratio * crop_height;
+    Crop {
+        x: ((width - crop_width) / 2.0).round(),
+        y: ((height - crop_height) / 2.0).round(),
+        width: crop_width.round(),
+        height: crop_height.round(),
+    }
+}
+
+fn crop_for_rotation(
+    width: f64,
+    height: f64,
+    aspect_ratio: Option<f64>,
+    rotation: f64,
+    current: Option<Crop>,
+    rotation_delta: f64,
+) -> Crop {
+    let aspect_ratio = aspect_ratio
+        .filter(|ratio| *ratio > 0.0)
+        .unwrap_or(width / height);
+    let Some(current) = current else {
+        return centered_crop(width, height, aspect_ratio, rotation);
+    };
+
+    let (sin, cos) = rotation_delta.to_radians().sin_cos();
+    let (px, py) = (
+        current.x + current.width / 2.0 - width / 2.0,
+        current.y + current.height / 2.0 - height / 2.0,
+    );
+    let followed = Crop {
+        x: (width / 2.0 + px * cos - py * sin - current.width / 2.0).round(),
+        y: (height / 2.0 + px * sin + py * cos - current.height / 2.0).round(),
+        ..current
+    };
+    if crop_within_bounds(&followed, width, height, rotation) {
+        return followed;
+    }
+
+    let (center_x, center_y) = (
+        followed.x + followed.width / 2.0,
+        followed.y + followed.height / 2.0,
+    );
+    let scaled = |scale: f64| Crop {
+        x: center_x - followed.width * scale / 2.0,
+        y: center_y - followed.height * scale / 2.0,
+        width: followed.width * scale,
+        height: followed.height * scale,
+    };
+    let (mut low, mut high) = (0.1, 1.0);
+    let mut best = followed;
+    for _ in 0..12 {
+        let mid = (low + high) / 2.0;
+        let candidate = scaled(mid);
+        if crop_within_bounds(&candidate, width, height, rotation) {
+            best = candidate;
+            low = mid;
+        } else {
+            high = mid;
+        }
+    }
+    if low < 0.15 {
+        return centered_crop(width, height, aspect_ratio, rotation);
+    }
+    Crop {
+        x: best.x.ceil(),
+        y: best.y.ceil(),
+        width: best.width.floor(),
+        height: best.height.floor(),
+    }
+}
+
+pub fn straighten_adjustments(image: &DynamicImage, source_path: &str, adjustments: &mut Value) {
+    let Some(rotation) = rotation_for_image(image, is_raw_file(source_path), adjustments) else {
+        return;
+    };
+
+    let (image_width, image_height) = (image.width() as f64, image.height() as f64);
+    let (width, height) = match adjustments["orientationSteps"].as_u64().unwrap_or(0) {
+        1 | 3 => (image_height, image_width),
+        _ => (image_width, image_height),
+    };
+    let previous_rotation = adjustments["rotation"].as_f64().unwrap_or(0.0);
+    let current_crop: Option<Crop> = serde_json::from_value(adjustments["crop"].clone()).ok();
+    let crop = crop_for_rotation(
+        width,
+        height,
+        adjustments["aspectRatio"].as_f64(),
+        rotation,
+        current_crop,
+        rotation - previous_rotation,
+    );
+
+    adjustments["rotation"] = json!(rotation);
+    adjustments["crop"] = json!({
+        "unit": "px",
+        "x": crop.x,
+        "y": crop.y,
+        "width": crop.width,
+        "height": crop.height,
+    });
+}
+
+#[tauri::command]
+pub fn calculate_auto_straighten(
+    js_adjustments: Value,
+    state: tauri::State<AppState>,
+) -> Result<Option<f64>, String> {
+    let (image, is_raw) = {
+        let guard = state.original_image.lock().unwrap();
+        let loaded = guard
+            .as_ref()
+            .ok_or("No image loaded for auto straighten")?;
+        (loaded.image.clone(), loaded.is_raw)
+    };
+    Ok(rotation_for_image(&image, is_raw, &js_adjustments))
+}
diff --git a/src-tauri/src/file_management.rs b/src-tauri/src/file_management.rs
index 39325e564e..7cde0d2b1e 100644
--- a/src-tauri/src/file_management.rs
+++ b/src-tauri/src/file_management.rs
@@ -2905,11 +2905,15 @@ pub async fn apply_auto_lens_correction_to_paths(
     Ok(())
 }
 
-#[tauri::command]
-pub async fn apply_auto_adjustments_to_paths(
+const FULL_DECODE_WORKER_THREADS: usize = 2;
+
+fn update_sidecars_from_images(
     paths: Vec<String>,
     app_handle: AppHandle,
-) -> Result<(), String> {
+    operation: &'static str,
+    fast_decode: bool,
+    update: impl Fn(&DynamicImage, &str, &mut Value) + Send + Sync + 'static,
+) {
     let state = app_handle.state::<AppState>();
     add_to_thumbnail_queue(&state, paths.len(), &app_handle);
 
@@ -2935,7 +2939,7 @@ pub async fn apply_auto_adjustments_to_paths(
 
         let gpu_context = gpu_processing::get_or_init_gpu_context(&state, &app_handle).ok();
 
-        paths.par_iter().for_each(|path| {
+        let process = |path: &String| {
             let loaded_image: Option<DynamicImage> = (|| -> Result<DynamicImage, String> {
                 let (source_path, sidecar_path) = parse_virtual_path(path);
                 let source_path_str = source_path.to_string_lossy().to_string();
@@ -2944,43 +2948,19 @@ pub async fn apply_auto_adjustments_to_paths(
                 let image = image_loader::load_base_image_from_bytes(
                     &file_bytes,
                     &source_path_str,
-                    true,
+                    fast_decode,
                     &settings,
                     None,
                 )
                 .map_err(|e| e.to_string())?;
 
-                let auto_results = perform_auto_analysis(&image);
-                let auto_adjustments_json = auto_results_to_json(&auto_results);
-
                 let mut existing_metadata = crate::exif_processing::load_sidecar(&sidecar_path);
 
                 if existing_metadata.adjustments.is_null() {
                     existing_metadata.adjustments = serde_json::json!({});
                 }
 
-                if let (Some(existing_map), Some(auto_map)) = (
-                    existing_metadata.adjustments.as_object_mut(),
-                    auto_adjustments_json.as_object(),
-                ) {
-                    for (k, v) in auto_map {
-                        if k == "sectionVisibility" {
-                            if let Some(existing_vis_val) = existing_map.get_mut(k) {
-                                if let (Some(existing_vis), Some(auto_vis)) =
-                                    (existing_vis_val.as_object_mut(), v.as_object())
-                                {
-                                    for (vis_k, vis_v) in auto_vis {
-                                        existing_vis.insert(vis_k.clone(), vis_v.clone());
-                                    }
-                                }
-                            } else {
-                                existing_map.insert(k.clone(), v.clone());
-                            }
-                        } else {
-                            existing_map.insert(k.clone(), v.clone());
-                        }
-                    }
-                }
+                update(&image, &source_path_str, &mut existing_metadata.adjustments);
 
                 if let Ok(json_string) = serde_json::to_string_pretty(&existing_metadata) {
                     let _ = std::fs::write(&sidecar_path, json_string);
@@ -2991,7 +2971,7 @@ pub async fn apply_auto_adjustments_to_paths(
                 }
                 Ok(image)
             })()
-            .map_err(|e| eprintln!("Failed to apply auto adjustments to {}: {}", path, e))
+            .map_err(|e| eprintln!("Failed to apply {} to {}: {}", operation, path, e))
             .ok();
 
             let result = generate_single_thumbnail_and_cache(
@@ -3016,12 +2996,77 @@ pub async fn apply_auto_adjustments_to_paths(
             }
 
             increment_thumbnail_progress(&state, &app_handle);
-        });
+        };
+
+        if fast_decode {
+            paths.par_iter().for_each(process);
+        } else if let Ok(pool) = rayon::ThreadPoolBuilder::new()
+            .num_threads(FULL_DECODE_WORKER_THREADS)
+            .build()
+        {
+            pool.install(|| paths.par_iter().for_each(process));
+        } else {
+            paths.iter().for_each(process);
+        }
     });
+}
+#[tauri::command]
+pub async fn apply_auto_adjustments_to_paths(
+    paths: Vec<String>,
+    app_handle: AppHandle,
+) -> Result<(), String> {
+    update_sidecars_from_images(
+        paths,
+        app_handle,
+        "auto adjustments",
+        true,
+        |image, _, adjustments| {
+            let auto_results = perform_auto_analysis(image);
+            let auto_adjustments_json = auto_results_to_json(&auto_results);
+
+            if let (Some(existing_map), Some(auto_map)) = (
+                adjustments.as_object_mut(),
+                auto_adjustments_json.as_object(),
+            ) {
+                for (k, v) in auto_map {
+                    if k == "sectionVisibility" {
+                        if let Some(existing_vis_val) = existing_map.get_mut(k) {
+                            if let (Some(existing_vis), Some(auto_vis)) =
+                                (existing_vis_val.as_object_mut(), v.as_object())
+                            {
+                                for (vis_k, vis_v) in auto_vis {
+                                    existing_vis.insert(vis_k.clone(), vis_v.clone());
+                                }
+                            }
+                        } else {
+                            existing_map.insert(k.clone(), v.clone());
+                        }
+                    } else {
+                        existing_map.insert(k.clone(), v.clone());
+                    }
+                }
+            }
+        },
+    );
 
     Ok(())
 }
 
+#[tauri::command]
+pub async fn apply_auto_straighten_to_paths(
+    paths: Vec<String>,
+    app_handle: AppHandle,
+) -> Result<(), String> {
+    update_sidecars_from_images(
+        paths,
+        app_handle,
+        "auto straighten",
+        false,
+        crate::auto_straighten::straighten_adjustments,
+    );
+
+    Ok(())
+}
 fn update_metadata_for_paths(
     paths: &[String],
     app_handle: &AppHandle,
diff --git a/src-tauri/src/guided_perspective.rs b/src-tauri/src/guided_perspective.rs
index aba1a260cf..4f8a2c89c6 100644
--- a/src-tauri/src/guided_perspective.rs
+++ b/src-tauri/src/guided_perspective.rs
@@ -40,7 +40,7 @@ pub struct GuidedResultJson {
 const EPS_INF: f64 = 1e-9;
 const EPS_DEG: f64 = 1e-9;
 
-fn unit_norm(v: [f64; 3]) -> [f64; 3] {
+pub(crate) fn unit_norm(v: [f64; 3]) -> [f64; 3] {
     let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
     if n < EPS_INF {
         v
@@ -49,7 +49,7 @@ fn unit_norm(v: [f64; 3]) -> [f64; 3] {
     }
 }
 
-fn cross(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {
+pub(crate) fn cross(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {
     [
         a[1] * b[2] - a[2] * b[1],
         a[2] * b[0] - a[0] * b[2],
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 80e7ef1a60..754c4e5eea 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -30,6 +30,7 @@ mod android_integration;
 mod app_settings;
 mod app_state;
 mod apple_raw;
+mod auto_straighten;
 mod cache_utils;
 mod camera_tethering;
 mod culling;
@@ -2390,6 +2391,8 @@ pub fn run() {
             export_processing::estimate_export_sizes,
             image_processing::calculate_auto_adjustments,
             image_processing::sample_white_balance,
+            auto_straighten::calculate_auto_straighten,
+            file_management::apply_auto_straighten_to_paths,
             mask_generation::generate_mask_overlay,
             file_management::update_exif_fields,
             file_management::get_supported_file_types,
diff --git a/src/components/panel/Editor.tsx b/src/components/panel/Editor.tsx
index 440c8652d0..ca9ca0b790 100644
--- a/src/components/panel/Editor.tsx
+++ b/src/components/panel/Editor.tsx
@@ -26,7 +26,7 @@ import { useSettingsStore } from '../../store/useSettingsStore';
 import { useUIStore } from '../../store/useUIStore';
 import { useLibraryStore } from '../../store/useLibraryStore';
 import { useAiMasking } from '../../hooks/useAiMasking';
-import { useEditorActions } from '../../hooks/useEditorActions';
+import { useEditorActions, withRotation } from '../../hooks/useEditorActions';
 
 const parseRgb = (rgbStr: string): [number, number, number, number] => {
   const match = rgbStr.match(/[\d.]+/g);
@@ -327,27 +327,7 @@ export default function Editor({ onBackToLibrary, onContextMenu, onImageSelect,
 
   const handleStraighten = useCallback(
     (angleCorrection: number) => {
-      setAdjustments((prev: Adjustments) => {
-        const newRotation = (prev.rotation || 0) + angleCorrection;
-        const newCrop =
-          selectedImage?.width && selectedImage?.height
-            ? calculateAutoCropForRotation(
-                selectedImage.width,
-                selectedImage.height,
-                prev.orientationSteps || 0,
-                prev.aspectRatio,
-                newRotation,
-                prev.crop,
-                angleCorrection,
-              )
-            : prev.crop;
-
-        return {
-          ...prev,
-          rotation: newRotation,
-          crop: newCrop,
-        };
-      });
+      setAdjustments((prev: Adjustments) => withRotation(prev, selectedImage, (prev.rotation || 0) + angleCorrection));
       setEditor({ isStraightenActive: false });
     },
     [selectedImage, setAdjustments, setEditor],
diff --git a/src/components/panel/right/CropPanel.tsx b/src/components/panel/right/CropPanel.tsx
index 4d99aeaa04..a4d28a9669 100644
--- a/src/components/panel/right/CropPanel.tsx
+++ b/src/components/panel/right/CropPanel.tsx
@@ -25,6 +25,7 @@ import {
   Info,
   Ban,
   Save,
+  Wand2,
 } from 'lucide-react';
 import { useTranslation, Trans } from 'react-i18next';
 import { invoke } from '@tauri-apps/api/core';
@@ -98,10 +99,11 @@ export default function CropPanel() {
   const selectedImage = useEditorStore((s) => s.selectedImage);
   const adjustments = useEditorStore((s) => s.adjustments);
   const isStraightenActive = useEditorStore((s) => s.isStraightenActive);
+  const isAutoStraightening = useEditorStore((s) => s.isAutoStraightening);
   const isGuidedPerspectiveActive = useEditorStore((s) => s.isGuidedPerspectiveActive);
   const activeOverlay = useEditorStore((s) => s.overlayMode);
   const setEditor = useEditorStore((s) => s.setEditor);
-  const { setAdjustments, handleRotate } = useEditorActions();
+  const { setAdjustments, handleRotate, handleAutoStraighten } = useEditorActions();
 
   const [customW, setCustomW] = useState('');
   const [customH, setCustomH] = useState('');
@@ -1001,6 +1003,14 @@ export default function CropPanel() {
                       >
                         <Ruler size={14} />
                       </button>
+                      <button
+                        onClick={handleAutoStraighten}
+                        className="p-1.5 rounded-md text-text-secondary transition-colors cursor-pointer hover:bg-card-active hover:text-text-primary disabled:cursor-wait"
+                        data-tooltip={t('editor.crop.tooltips.autoStraighten')}
+                        disabled={isAutoStraightening}
+                      >
+                        {isAutoStraightening ? <Loader size={14} className="animate-spin" /> : <Wand2 size={14} />}
+                      </button>
                       <button
                         className="p-1.5 rounded-md text-text-secondary transition-colors cursor-pointer hover:bg-card-active hover:text-text-primary"
                         onClick={resetFineRotation}
diff --git a/src/components/ui/AppProperties.tsx b/src/components/ui/AppProperties.tsx
index 2a3005c8b0..85450d1386 100644
--- a/src/components/ui/AppProperties.tsx
+++ b/src/components/ui/AppProperties.tsx
@@ -35,9 +35,11 @@ export enum Invokes {
   ApplyAdjustments = 'apply_adjustments',
   ApplyAdjustmentsToPaths = 'apply_adjustments_to_paths',
   ApplyAutoAdjustmentsToPaths = 'apply_auto_adjustments_to_paths',
+  ApplyAutoStraightenToPaths = 'apply_auto_straighten_to_paths',
   ApplyDenoising = 'apply_denoising',
   CalculateAutoAdjustments = 'calculate_auto_adjustments',
   SampleWhiteBalance = 'sample_white_balance',
+  CalculateAutoStraighten = 'calculate_auto_straighten',
   CancelAiTask = 'cancel_ai_task',
   CancelExport = 'cancel_export',
   CheckAIConnectorStatus = 'check_ai_connector_status',
diff --git a/src/hooks/useAppContextMenus.ts b/src/hooks/useAppContextMenus.ts
index 55d1f1bf51..748cfb9554 100644
--- a/src/hooks/useAppContextMenus.ts
+++ b/src/hooks/useAppContextMenus.ts
@@ -47,6 +47,7 @@ import {
   User,
   Album as AlbumIcon,
   PencilSparkles,
+  Wand2,
 } from 'lucide-react';
 import { toast } from 'react-toastify';
 import { useTranslation } from 'react-i18next';
@@ -66,9 +67,9 @@ import {
   Album,
   AlbumGroup,
 } from '../components/ui/AppProperties';
-import { Color, COLOR_LABELS, INITIAL_ADJUSTMENTS, normalizeLoadedAdjustments } from '../utils/adjustments';
+import { Color, COLOR_LABELS, INITIAL_ADJUSTMENTS } from '../utils/adjustments';
 import TaggingSubMenu from '../context/TaggingSubMenu';
-import { useEditorActions } from './useEditorActions';
+import { reloadAdjustmentsForPaths, useEditorActions } from './useEditorActions';
 import { useLibraryActions } from './useLibraryActions';
 import { globalImageCache } from '../utils/ImageLRUCache';
 
@@ -92,6 +93,8 @@ export function useAppContextMenus(props: UseAppContextMenusProps) {
   const {
     handleAutoAdjustments,
     handleAutoLensCorrection,
+    handleAutoStraighten,
+    handleAutoStraightenPaths,
     handleResetAdjustments,
     handleCopyAdjustments,
     handlePasteAdjustments,
@@ -247,6 +250,12 @@ export function useAppContextMenus(props: UseAppContextMenusProps) {
               onClick: () => handleAutoLensCorrection([selectedImage.path]),
               disabled: !selectedImage?.isReady,
             },
+            {
+              label: t('contextMenus.editor.autoStraighten'),
+              icon: Wand2,
+              onClick: handleAutoStraighten,
+              disabled: !selectedImage?.isReady,
+            },
             {
               label: t('contextMenus.editor.denoise'),
               icon: Grip,
@@ -377,9 +386,8 @@ export function useAppContextMenus(props: UseAppContextMenusProps) {
       event.preventDefault();
       event.stopPropagation();
 
-      const { selectedImage, copiedAdjustments, setEditor } = useEditorStore.getState();
-      const { multiSelectedPaths, imageList, libraryActivePath, albumTree, activeAlbumId, setLibrary } =
-        useLibraryStore.getState();
+      const { selectedImage, copiedAdjustments } = useEditorStore.getState();
+      const { multiSelectedPaths, imageList, albumTree, activeAlbumId, setLibrary } = useLibraryStore.getState();
       const { appSettings } = useSettingsStore.getState();
       const { activeView, setUI, setPanel } = useUIStore.getState();
       const { setProcess } = useProcessStore.getState();
@@ -500,23 +508,7 @@ export function useAppContextMenus(props: UseAppContextMenusProps) {
         finalSelection.forEach((p) => globalImageCache.delete(p));
 
         invoke(Invokes.ApplyAutoAdjustmentsToPaths, { paths: finalSelection })
-          .then(async () => {
-            if (selectedImage && finalSelection.includes(selectedImage.path)) {
-              const metadata: any = await invoke(Invokes.LoadMetadata, { path: selectedImage.path });
-              if (metadata.adjustments && !metadata.adjustments.is_null) {
-                const normalized = normalizeLoadedAdjustments(metadata.adjustments);
-                setEditor({ adjustments: normalized });
-                useEditorStore.getState().resetHistory(normalized);
-              }
-            }
-            if (libraryActivePath && finalSelection.includes(libraryActivePath)) {
-              const metadata: any = await invoke(Invokes.LoadMetadata, { path: libraryActivePath });
-              if (metadata.adjustments && !metadata.adjustments.is_null) {
-                const normalized = normalizeLoadedAdjustments(metadata.adjustments);
-                setLibrary({ libraryActiveAdjustments: normalized });
-              }
-            }
-          })
+          .then(() => reloadAdjustmentsForPaths(finalSelection))
           .catch((err) => {
             console.error('Failed to apply auto adjustments to paths:', err);
             toast.error(t('contextMenus.toasts.failedApplyAuto', { err }));
@@ -607,6 +599,11 @@ export function useAppContextMenus(props: UseAppContextMenusProps) {
               icon: Aperture,
               onClick: () => handleAutoLensCorrection(finalSelection),
             },
+            {
+              label: t('contextMenus.thumbnail.autoStraighten', { count: selectionCount }),
+              icon: Wand2,
+              onClick: () => handleAutoStraightenPaths(finalSelection),
+            },
             {
               label: denoiseLabel,
               icon: Grip,
diff --git a/src/hooks/useEditorActions.ts b/src/hooks/useEditorActions.ts
index fc55931828..533c26970a 100644
--- a/src/hooks/useEditorActions.ts
+++ b/src/hooks/useEditorActions.ts
@@ -2,10 +2,12 @@ import { useCallback } from 'react';
 import { invoke } from '@tauri-apps/api/core';
 import debounce from 'lodash.debounce';
 import { toast } from 'react-toastify';
+import { useTranslation } from 'react-i18next';
 import { useEditorStore } from '../store/useEditorStore';
 import { useLibraryStore } from '../store/useLibraryStore';
 import { useSettingsStore } from '../store/useSettingsStore';
 import { useProcessStore } from '../store/useProcessStore';
+import { useUIStore } from '../store/useUIStore';
 import {
   Adjustments,
   INITIAL_ADJUSTMENTS,
@@ -14,8 +16,8 @@ import {
   LensAdjustment,
   normalizeLoadedAdjustments,
 } from '../utils/adjustments';
-import { calculateCenteredCrop } from '../utils/cropUtils';
-import { Invokes } from '../components/ui/AppProperties';
+import { calculateAutoCropForRotation, calculateCenteredCrop } from '../utils/cropUtils';
+import { Invokes, SelectedImage } from '../components/ui/AppProperties';
 import { globalImageCache } from '../utils/ImageLRUCache';
 
 export const debouncedSetHistory = debounce((newAdj: Adjustments) => {
@@ -29,7 +31,57 @@ export const debouncedSave = debounce((path: string, adjustmentsToSave: Adjustme
   });
 }, 300);
 
+const waitForImageReady = (path: string) =>
+  new Promise<boolean>((resolve) => {
+    const unsubscribe = useEditorStore.subscribe((state) => {
+      if (state.selectedImage?.path !== path) {
+        unsubscribe();
+        resolve(false);
+      } else if (state.selectedImage.isReady) {
+        unsubscribe();
+        resolve(true);
+      }
+    });
+  });
+
+export const withRotation = (adjustments: Adjustments, image: SelectedImage | null, rotation: number): Adjustments => ({
+  ...adjustments,
+  rotation,
+  crop:
+    image?.width && image?.height
+      ? calculateAutoCropForRotation(
+          image.width,
+          image.height,
+          adjustments.orientationSteps || 0,
+          adjustments.aspectRatio,
+          rotation,
+          adjustments.crop,
+          rotation - (adjustments.rotation || 0),
+        )
+      : adjustments.crop,
+});
+
+export const reloadAdjustmentsForPaths = async (paths: string[]) => {
+  const { selectedImage, setEditor, resetHistory } = useEditorStore.getState();
+  const { libraryActivePath, setLibrary } = useLibraryStore.getState();
+  if (selectedImage && paths.includes(selectedImage.path)) {
+    const meta: any = await invoke(Invokes.LoadMetadata, { path: selectedImage.path });
+    if (meta.adjustments && !meta.adjustments.is_null) {
+      const normalized = normalizeLoadedAdjustments(meta.adjustments);
+      setEditor({ adjustments: normalized });
+      resetHistory(normalized);
+    }
+  }
+  if (libraryActivePath && paths.includes(libraryActivePath)) {
+    const meta: any = await invoke(Invokes.LoadMetadata, { path: libraryActivePath });
+    if (meta.adjustments && !meta.adjustments.is_null) {
+      setLibrary({ libraryActiveAdjustments: normalizeLoadedAdjustments(meta.adjustments) });
+    }
+  }
+};
+
 export function useEditorActions() {
+  const { t } = useTranslation();
   const setEditor = useEditorStore((s) => s.setEditor);
 
   const setAdjustments = useCallback(
@@ -85,6 +137,29 @@ export function useEditorActions() {
     }
   }, [setAdjustments]);
 
+  const handleAutoStraighten = useCallback(async () => {
+    const { selectedImage, isAutoStraightening } = useEditorStore.getState();
+    if (!selectedImage || isAutoStraightening) return;
+    setEditor({ isAutoStraightening: true });
+    try {
+      if (!selectedImage.isReady && !(await waitForImageReady(selectedImage.path))) return;
+      const rotation: number | null = await invoke(Invokes.CalculateAutoStraighten, {
+        jsAdjustments: useEditorStore.getState().adjustments,
+      });
+      if (useEditorStore.getState().selectedImage?.path !== selectedImage.path) return;
+      if (rotation === null) {
+        toast.info(t('editor.crop.autoStraightenNoLines'));
+        return;
+      }
+      setEditor({ liveRotation: null, isStraightenActive: false });
+      setAdjustments((prev: Adjustments) => withRotation(prev, selectedImage, rotation));
+    } catch (err) {
+      toast.error(t('editor.crop.autoStraightenFailed', { error: String(err) }));
+    } finally {
+      setEditor({ isAutoStraightening: false });
+    }
+  }, [setAdjustments, setEditor, t]);
+
   const toggleShowOriginal = useCallback(() => {
     setEditor((state) => {
       const isShowing = !state.showOriginal;
@@ -202,44 +277,43 @@ export function useEditorActions() {
     [setEditor],
   );
 
-  const handleAutoLensCorrection = useCallback(
-    (paths?: string[]) => {
-      const { multiSelectedPaths, libraryActivePath, setLibrary } = useLibraryStore.getState();
-      const { selectedImage, resetHistory } = useEditorStore.getState();
+  const handleAutoLensCorrection = useCallback((paths?: string[]) => {
+    const { multiSelectedPaths } = useLibraryStore.getState();
+    const { selectedImage } = useEditorStore.getState();
 
-      const pathsToUpdate =
-        paths && paths.length > 0
-          ? paths
-          : multiSelectedPaths.length > 0
-            ? multiSelectedPaths
-            : selectedImage
-              ? [selectedImage.path]
-              : [];
+    const pathsToUpdate =
+      paths && paths.length > 0
+        ? paths
+        : multiSelectedPaths.length > 0
+          ? multiSelectedPaths
+          : selectedImage
+            ? [selectedImage.path]
+            : [];
 
-      if (pathsToUpdate.length === 0) return;
+    if (pathsToUpdate.length === 0) return;
 
-      pathsToUpdate.forEach((p) => globalImageCache.delete(p));
+    pathsToUpdate.forEach((p) => globalImageCache.delete(p));
 
-      invoke('apply_auto_lens_correction_to_paths', { paths: pathsToUpdate })
-        .then(async () => {
-          if (selectedImage && pathsToUpdate.includes(selectedImage.path)) {
-            const meta: any = await invoke(Invokes.LoadMetadata, { path: selectedImage.path });
-            if (meta.adjustments && !meta.adjustments.is_null) {
-              const normalized = normalizeLoadedAdjustments(meta.adjustments);
-              setEditor({ adjustments: normalized });
-              resetHistory(normalized);
-            }
-          }
-          if (libraryActivePath && pathsToUpdate.includes(libraryActivePath)) {
-            const meta: any = await invoke(Invokes.LoadMetadata, { path: libraryActivePath });
-            if (meta.adjustments && !meta.adjustments.is_null) {
-              setLibrary({ libraryActiveAdjustments: normalizeLoadedAdjustments(meta.adjustments) });
-            }
-          }
-        })
-        .catch((err) => toast.error(`Failed to apply auto lens correction: ${err}`));
+    invoke('apply_auto_lens_correction_to_paths', { paths: pathsToUpdate })
+      .then(() => reloadAdjustmentsForPaths(pathsToUpdate))
+      .catch((err) => toast.error(`Failed to apply auto lens correction: ${err}`));
+  }, []);
+
+  const handleAutoStraightenPaths = useCallback(
+    (paths: string[]) => {
+      const { selectedImage } = useEditorStore.getState();
+      const editingPath = useUIStore.getState().activeView === 'editor' ? selectedImage?.path : undefined;
+      const batchPaths = paths.filter((path) => path !== editingPath);
+      if (batchPaths.length < paths.length) {
+        handleAutoStraighten();
+      }
+      if (batchPaths.length === 0) return;
+      batchPaths.forEach((p) => globalImageCache.delete(p));
+      invoke(Invokes.ApplyAutoStraightenToPaths, { paths: batchPaths })
+        .then(() => reloadAdjustmentsForPaths(batchPaths))
+        .catch((err) => toast.error(t('editor.crop.autoStraightenFailed', { error: String(err) })));
     },
-    [setEditor],
+    [handleAutoStraighten, t],
   );
 
   const handleCopyAdjustments = useCallback(async (pathOrEvent?: string | any) => {
@@ -402,6 +476,8 @@ export function useEditorActions() {
     setAdjustments,
     handleRotate,
     handleAutoAdjustments,
+    handleAutoStraighten,
+    handleAutoStraightenPaths,
     handleLutSelect,
     setLutPreviewOverride,
     handleResetAdjustments,
diff --git a/src/hooks/useKeyboardShortcuts.ts b/src/hooks/useKeyboardShortcuts.ts
index 86861d0682..b6a0edf223 100644
--- a/src/hooks/useKeyboardShortcuts.ts
+++ b/src/hooks/useKeyboardShortcuts.ts
@@ -31,7 +31,8 @@ export const useKeyboardShortcuts = ({
   handlePasteFiles,
   handleZoomChange,
 }: KeyboardShortcutsProps) => {
-  const { handleRotate, handleCopyAdjustments, handlePasteAdjustments, toggleShowOriginal } = useEditorActions();
+  const { handleRotate, handleAutoStraighten, handleCopyAdjustments, handlePasteAdjustments, toggleShowOriginal } =
+    useEditorActions();
   const { handleRate, handleSetFlag, handleToggleFlag, handleSetColorLabel } = useLibraryActions();
 
   const sortedListRef = useRef(sortedImageList);
@@ -60,6 +61,7 @@ export const useKeyboardShortcuts = ({
       settings: useSettingsStore.getState(),
       process: useProcessStore.getState(),
     });
+    type ShortcutState = ReturnType<typeof getStoreState>;
 
     const comboMap = new Map<string, string>();
     const { appSettings, osPlatform } = useSettingsStore.getState();
@@ -453,6 +455,16 @@ export const useKeyboardShortcuts = ({
           }
         },
       },
+      auto_straighten: {
+        shouldFire: (s: ShortcutState) => s.ui.activeView === 'editor' && !!s.editor.selectedImage,
+        execute: (e: KeyboardEvent, s: ShortcutState) => {
+          e.preventDefault();
+          if (s.ui.activePanel !== Panel.Crop) {
+            s.ui.setPanel(Panel.Crop);
+          }
+          handleAutoStraighten();
+        },
+      },
       rate_0: {
         shouldFire: () => true,
         execute: (e: any) => {
@@ -717,6 +729,7 @@ export const useKeyboardShortcuts = ({
     handlePasteFiles,
     handleZoomChange,
     handleRotate,
+    handleAutoStraighten,
     handleCopyAdjustments,
     handleCopyImagePaths,
     handlePasteAdjustments,
diff --git a/src/i18n/locales/ca.json b/src/i18n/locales/ca.json
index 6844cb2b62..5e1556c70f 100644
--- a/src/i18n/locales/ca.json
+++ b/src/i18n/locales/ca.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Ajustament automàtic",
       "autoLensCorrection": "Correcció d'objectiu automàtica",
+      "autoStraighten": "Redreçar automàticament",
       "cancel": "Cancel·lar",
       "colorLabel": "Etiqueta de color",
       "confirmReset": "Confirmar restabliment",
@@ -278,6 +279,9 @@
       "autoAdjust_other": "Ajustament automàtic de les imatges",
       "autoLensCorrection_one": "Correcció d'objectiu automàtica",
       "autoLensCorrection_other": "Correcció d'objectiu automàtica",
+      "autoStraighten_many": "Redreçar automàticament les imatges",
+      "autoStraighten_one": "Redreçar automàticament la imatge",
+      "autoStraighten_other": "Redreçar automàticament les imatges",
       "collage_one": "Emmarcar imatge",
       "collage_other": "Crear collage",
       "confirmDelete": "Confirmar eliminació",
@@ -470,6 +474,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Relació d'aspecte",
+      "autoStraightenFailed": "No s'ha pogut redreçar automàticament: {{error}}",
+      "autoStraightenNoLines": "No s'han trobat línies rectes per redreçar",
       "custom": {
         "hPlaceholder": "Al",
         "hTooltip": "Alçada",
@@ -569,6 +575,7 @@
       "rotationHeading": "Rotació",
       "title": "Retallar i transformar",
       "tooltips": {
+        "autoStraighten": "Redreçar automàticament (Maj+S)",
         "compositionOverlay": "Superposició de composició",
         "flipHoriz": "Capgirar la imatge horitzontalment",
         "flipVert": "Capgirar la imatge verticalment",
@@ -1668,6 +1675,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Redreçar automàticament",
         "brush_size_down": "Reduir mida del pinzell",
         "brush_size_up": "Augmentar mida del pinzell",
         "color_label_blue": "Etiqueta de color: Blau",
diff --git a/src/i18n/locales/cs.json b/src/i18n/locales/cs.json
index 15e17da54c..d874d5fe85 100644
--- a/src/i18n/locales/cs.json
+++ b/src/i18n/locales/cs.json
@@ -208,6 +208,7 @@
     "editor": {
       "autoAdjust": "Automaticky upravit",
       "autoLensCorrection": "Auto korekce objektivu",
+      "autoStraighten": "Automaticky vyrovnat",
       "cancel": "Zrušit",
       "colorLabel": "Barevný štítek",
       "confirmReset": "Potvrďte reset",
@@ -277,6 +278,10 @@
       "autoAdjust_other": "Automaticky upravit",
       "autoLensCorrection_one": "Auto korekce objektivu",
       "autoLensCorrection_other": "Auto korekce objektivu",
+      "autoStraighten_few": "Automaticky vyrovnat snímky",
+      "autoStraighten_many": "Automaticky vyrovnat snímky",
+      "autoStraighten_one": "Automaticky vyrovnat snímek",
+      "autoStraighten_other": "Automaticky vyrovnat snímky",
       "collage_one": "Zarámovat snímek",
       "collage_other": "Vytvořit koláž",
       "confirmDelete": "Potvrdit smazání",
@@ -469,6 +474,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Poměr stran",
+      "autoStraightenFailed": "Automatické vyrovnání selhalo: {{error}}",
+      "autoStraightenNoLines": "Nenalezeny žádné rovné čáry k vyrovnání",
       "custom": {
         "hPlaceholder": "V",
         "hTooltip": "Výška",
@@ -568,6 +575,7 @@
       "rotationHeading": "Otáčení",
       "title": "Oříznout a transformovat",
       "tooltips": {
+        "autoStraighten": "Automatické vyrovnání (Shift+S)",
         "compositionOverlay": "Překryvná kompozice",
         "flipHoriz": "Překlopit snímek vodorovně",
         "flipVert": "Překlopit snímek svisle",
@@ -1665,6 +1673,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Automatické vyrovnání",
         "brush_size_down": "Zmenšit velikost štětce",
         "brush_size_up": "Zvětšit velikost štětce",
         "color_label_blue": "Barevný štítek: Modrá",
diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json
index 9050f1fca3..150e2e42d3 100644
--- a/src/i18n/locales/de.json
+++ b/src/i18n/locales/de.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Bild autom. anpassen",
       "autoLensCorrection": "Autom. Objektivkorrektur",
+      "autoStraighten": "Automatisch ausrichten",
       "cancel": "Abbrechen",
       "colorLabel": "Farbmarkierung",
       "confirmReset": "Zurücksetzen bestätigen",
@@ -278,6 +279,8 @@
       "autoAdjust_other": "Bilder autom. anpassen",
       "autoLensCorrection_one": "Autom. Objektivkorrektur",
       "autoLensCorrection_other": "Autom. Objektivkorrektur",
+      "autoStraighten_one": "Bild automatisch ausrichten",
+      "autoStraighten_other": "Bilder automatisch ausrichten",
       "collage_one": "Bild rahmen",
       "collage_other": "Collage erstellen",
       "confirmDelete": "Löschen bestätigen",
@@ -470,6 +473,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Seitenverhältnis",
+      "autoStraightenFailed": "Automatisches Ausrichten fehlgeschlagen: {{error}}",
+      "autoStraightenNoLines": "Keine geraden Linien zum Ausrichten gefunden",
       "custom": {
         "hPlaceholder": "H",
         "hTooltip": "Höhe",
@@ -569,6 +574,7 @@
       "rotationHeading": "Drehung",
       "title": "Zuschnitt & Form",
       "tooltips": {
+        "autoStraighten": "Automatisch ausrichten (Shift+S)",
         "compositionOverlay": "Kompositions-Überlagerung",
         "flipHoriz": "Bild horizontal spiegeln",
         "flipVert": "Bild vertikal spiegeln",
@@ -1666,6 +1672,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Automatisch ausrichten",
         "brush_size_down": "Pinselgröße verringern",
         "brush_size_up": "Pinselgröße erhöhen",
         "color_label_blue": "Farbmarkierung: Blau",
diff --git a/src/i18n/locales/en.json b/src/i18n/locales/en.json
index 8300f01221..c84ad11ef1 100644
--- a/src/i18n/locales/en.json
+++ b/src/i18n/locales/en.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Auto Adjust Image",
       "autoLensCorrection": "Auto Lens Correction",
+      "autoStraighten": "Auto Straighten",
       "cancel": "Cancel",
       "colorLabel": "Color Label",
       "confirmReset": "Confirm Reset",
@@ -278,6 +279,8 @@
       "autoAdjust_other": "Auto Adjust Images",
       "autoLensCorrection_one": "Auto Lens Correction",
       "autoLensCorrection_other": "Auto Lens Correction",
+      "autoStraighten_one": "Auto Straighten Image",
+      "autoStraighten_other": "Auto Straighten Images",
       "collage_one": "Frame Image",
       "collage_other": "Create Collage",
       "confirmDelete": "Confirm Delete",
@@ -470,6 +473,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Aspect Ratio",
+      "autoStraightenFailed": "Auto straighten failed: {{error}}",
+      "autoStraightenNoLines": "No straight lines found to level from",
       "custom": {
         "hPlaceholder": "H",
         "hTooltip": "Height",
@@ -569,6 +574,7 @@
       "rotationHeading": "Rotation",
       "title": "Crop & Transform",
       "tooltips": {
+        "autoStraighten": "Auto Straighten (Shift+S)",
         "compositionOverlay": "Composition Overlay",
         "flipHoriz": "Flip image horizontally",
         "flipVert": "Flip image vertically",
@@ -1666,6 +1672,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Auto straighten",
         "brush_size_down": "Decrease brush size",
         "brush_size_up": "Increase brush size",
         "color_label_blue": "Color label: Blue",
diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json
index 3276c471da..1bae9e50dc 100644
--- a/src/i18n/locales/es.json
+++ b/src/i18n/locales/es.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Ajuste automático de imagen",
       "autoLensCorrection": "Corrección de lente automática",
+      "autoStraighten": "Enderezar automáticamente",
       "cancel": "Cancelar",
       "colorLabel": "Etiqueta de color",
       "confirmReset": "Confirmar restablecimiento",
@@ -283,6 +284,9 @@
       "autoAdjust_other": "Ajuste automático de imágenes",
       "autoLensCorrection_one": "Corrección de lente automática",
       "autoLensCorrection_other": "Corrección de lente automática",
+      "autoStraighten_many": "Enderezar imágenes automáticamente",
+      "autoStraighten_one": "Enderezar imagen automáticamente",
+      "autoStraighten_other": "Enderezar imágenes automáticamente",
       "collage_many": "Crear collage",
       "collage_one": "Enmarcar imagen",
       "collage_other": "Crear collage",
@@ -490,6 +494,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Relación de aspecto",
+      "autoStraightenFailed": "Error al enderezar automáticamente: {{error}}",
+      "autoStraightenNoLines": "No se encontraron líneas rectas para enderezar",
       "custom": {
         "hPlaceholder": "Al",
         "hTooltip": "Altura",
@@ -589,6 +595,7 @@
       "rotationHeading": "Rotación",
       "title": "Recortar y transformar",
       "tooltips": {
+        "autoStraighten": "Enderezar automáticamente (Shift+S)",
         "compositionOverlay": "Superposición de composición",
         "flipHoriz": "Voltear imagen horizontalmente",
         "flipVert": "Voltear imagen verticalmente",
@@ -1701,6 +1708,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Enderezar automáticamente",
         "brush_size_down": "Reducir tamaño del pincel",
         "brush_size_up": "Aumentar tamaño del pincel",
         "color_label_blue": "Etiqueta de color: Azul",
diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json
index 4bb2f8d0d6..91f53095da 100644
--- a/src/i18n/locales/fr.json
+++ b/src/i18n/locales/fr.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Ajustement auto de l'image",
       "autoLensCorrection": "Correction d'objectif automatique",
+      "autoStraighten": "Redresser automatiquement",
       "cancel": "Annuler",
       "colorLabel": "Étiquette de couleur",
       "confirmReset": "Confirmer la réinitialisation",
@@ -283,6 +284,9 @@
       "autoAdjust_other": "Ajustement auto des images",
       "autoLensCorrection_one": "Correction d'objectif automatique",
       "autoLensCorrection_other": "Corrections d'objectif automatiques",
+      "autoStraighten_many": "Redresser les images automatiquement",
+      "autoStraighten_one": "Redresser l'image automatiquement",
+      "autoStraighten_other": "Redresser les images automatiquement",
       "collage_many": "Créer un collage",
       "collage_one": "Encadrer l'image",
       "collage_other": "Créer un collage",
@@ -490,6 +494,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Rapport d'aspect",
+      "autoStraightenFailed": "Échec du redressement automatique : {{error}}",
+      "autoStraightenNoLines": "Aucune ligne droite trouvée pour redresser",
       "custom": {
         "hPlaceholder": "H",
         "hTooltip": "Hauteur",
@@ -589,6 +595,7 @@
       "rotationHeading": "Rotation",
       "title": "Recadrage & Transformation",
       "tooltips": {
+        "autoStraighten": "Redresser automatiquement (Maj+S)",
         "compositionOverlay": "Superposition de composition",
         "flipHoriz": "Retourner l'image horizontalement",
         "flipVert": "Retourner l'image verticalement",
@@ -1701,6 +1708,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Redresser automatiquement",
         "brush_size_down": "Diminuer la taille du pinceau",
         "brush_size_up": "Augmenter la taille du pinceau",
         "color_label_blue": "Étiquette de couleur : Bleu",
diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json
index 927201c899..fc5a72e16a 100644
--- a/src/i18n/locales/it.json
+++ b/src/i18n/locales/it.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Regolazione Automatica Immagine",
       "autoLensCorrection": "Correzione automatica obiettivo",
+      "autoStraighten": "Raddrizza automaticamente",
       "cancel": "Annulla",
       "colorLabel": "Etichetta Colore",
       "confirmReset": "Conferma Ripristino",
@@ -283,6 +284,9 @@
       "autoAdjust_other": "Regolazione Automatica Immagini",
       "autoLensCorrection_one": "Correzione automatica obiettivo",
       "autoLensCorrection_other": "Correzione automatica obiettivo",
+      "autoStraighten_many": "Raddrizza immagini automaticamente",
+      "autoStraighten_one": "Raddrizza immagine automaticamente",
+      "autoStraighten_other": "Raddrizza immagini automaticamente",
       "collage_many": "Crea Collage",
       "collage_one": "Incornicia Immagine",
       "collage_other": "Crea Collage",
@@ -490,6 +494,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Proporzioni",
+      "autoStraightenFailed": "Raddrizzamento automatico non riuscito: {{error}}",
+      "autoStraightenNoLines": "Nessuna linea retta trovata per raddrizzare",
       "custom": {
         "hPlaceholder": "A",
         "hTooltip": "Altezza",
@@ -589,6 +595,7 @@
       "rotationHeading": "Rotazione",
       "title": "Ritaglio e Trasformazione",
       "tooltips": {
+        "autoStraighten": "Raddrizza automaticamente (Shift+S)",
         "compositionOverlay": "Sovrapposizione Composizione",
         "flipHoriz": "Rifletti immagine orizzontalmente",
         "flipVert": "Rifletti immagine verticalmente",
@@ -1701,6 +1708,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Raddrizza automaticamente",
         "brush_size_down": "Riduci dimensione pennello",
         "brush_size_up": "Aumenta dimensione pennello",
         "color_label_blue": "Etichetta colore: Blu",
diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json
index d1eea3ab44..29dd635a7f 100644
--- a/src/i18n/locales/ja.json
+++ b/src/i18n/locales/ja.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "画像を自動補正",
       "autoLensCorrection": "自動レンズ補正",
+      "autoStraighten": "自動角度補正",
       "cancel": "キャンセル",
       "colorLabel": "カラーラベル",
       "confirmReset": "リセットを確認",
@@ -278,6 +279,8 @@
       "autoAdjust_other": "画像を自動補正",
       "autoLensCorrection_one": "自動レンズ補正",
       "autoLensCorrection_other": "自動レンズ補正",
+      "autoStraighten_one": "画像を自動角度補正",
+      "autoStraighten_other": "画像を自動角度補正",
       "collage_one": "画像にフレームを追加",
       "collage_other": "コラージュを作成",
       "confirmDelete": "削除を確認",
@@ -468,6 +471,8 @@
     },
     "crop": {
       "aspectRatioHeading": "アスペクト比",
+      "autoStraightenFailed": "自動角度補正に失敗しました: {{error}}",
+      "autoStraightenNoLines": "補正に使える直線が見つかりません",
       "custom": {
         "hPlaceholder": "H",
         "hTooltip": "高さ",
@@ -567,6 +572,7 @@
       "rotationHeading": "回転",
       "title": "切り抜きと変形",
       "tooltips": {
+        "autoStraighten": "自動角度補正（Shift+S）",
         "compositionOverlay": "構図ガイド",
         "flipHoriz": "画像を水平方向に反転",
         "flipVert": "画像を垂直方向に反転",
@@ -1664,6 +1670,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "自動角度補正",
         "brush_size_down": "ブラシサイズを縮小",
         "brush_size_up": "ブラシサイズを拡大",
         "color_label_blue": "カラーラベル: ブルー",
diff --git a/src/i18n/locales/ko.json b/src/i18n/locales/ko.json
index 6e022e75f9..8a3af1c82c 100644
--- a/src/i18n/locales/ko.json
+++ b/src/i18n/locales/ko.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "이미지 자동 조정",
       "autoLensCorrection": "자동 렌즈 교정",
+      "autoStraighten": "자동 수평 맞추기",
       "cancel": "취소",
       "colorLabel": "색상 레이블",
       "confirmReset": "초기화 확인",
@@ -278,6 +279,8 @@
       "autoAdjust_other": "이미지 자동 조정",
       "autoLensCorrection_one": "자동 렌즈 교정",
       "autoLensCorrection_other": "자동 렌즈 교정",
+      "autoStraighten_one": "이미지 자동 수평 맞추기",
+      "autoStraighten_other": "이미지 자동 수평 맞추기",
       "collage_one": "이미지 프레임",
       "collage_other": "콜라주 만들기",
       "confirmDelete": "삭제 확인",
@@ -468,6 +471,8 @@
     },
     "crop": {
       "aspectRatioHeading": "종횡비",
+      "autoStraightenFailed": "자동 수평 맞추기 실패: {{error}}",
+      "autoStraightenNoLines": "수평을 맞출 직선을 찾을 수 없습니다",
       "custom": {
         "hPlaceholder": "높이",
         "hTooltip": "높이",
@@ -567,6 +572,7 @@
       "rotationHeading": "회전",
       "title": "자르기 및 변형",
       "tooltips": {
+        "autoStraighten": "자동 수평 맞추기 (Shift+S)",
         "compositionOverlay": "구도 오버레이",
         "flipHoriz": "이미지를 좌우로 반전",
         "flipVert": "이미지를 상하로 반전",
@@ -1664,6 +1670,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "자동 수평 맞추기",
         "brush_size_down": "브러시 크기 줄이기",
         "brush_size_up": "브러시 크기 늘리기",
         "color_label_blue": "색상 레이블: 파랑",
diff --git a/src/i18n/locales/nl.json b/src/i18n/locales/nl.json
index 071121d0f4..9688e0050d 100644
--- a/src/i18n/locales/nl.json
+++ b/src/i18n/locales/nl.json
@@ -208,6 +208,7 @@
     "editor": {
       "autoAdjust": "Autom. aanpassen",
       "autoLensCorrection": "Autom. lenscorrectie",
+      "autoStraighten": "Automatisch rechtzetten",
       "cancel": "Annuleren",
       "colorLabel": "Kleurlabel",
       "confirmReset": "Herstellen bevestigen",
@@ -272,6 +273,8 @@
       "autoAdjust_other": "Autom. aanpassen",
       "autoLensCorrection_one": "Autom. lenscorrectie",
       "autoLensCorrection_other": "Autom. lenscorrectie",
+      "autoStraighten_one": "Afbeelding automatisch rechtzetten",
+      "autoStraighten_other": "Afbeeldingen automatisch rechtzetten",
       "collage_one": "Afbeelding inkaderen",
       "collage_other": "Collage maken",
       "confirmDelete": "Verwijderen bevestigen",
@@ -464,6 +467,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Beeldverhouding",
+      "autoStraightenFailed": "Automatisch rechtzetten mislukt: {{error}}",
+      "autoStraightenNoLines": "Geen rechte lijnen gevonden om recht te zetten",
       "custom": {
         "hPlaceholder": "H",
         "hTooltip": "Hoogte",
@@ -563,6 +568,7 @@
       "rotationHeading": "Rotatie",
       "title": "Bijsnijden & transformeren",
       "tooltips": {
+        "autoStraighten": "Automatisch rechtzetten (Shift+S)",
         "compositionOverlay": "Compositie-overlay",
         "flipHoriz": "Afbeelding horizontaal spiegelen",
         "flipVert": "Afbeelding verticaal spiegelen",
@@ -1643,6 +1649,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Automatisch rechtzetten",
         "brush_size_down": "Penseelgrootte verkleinen",
         "brush_size_up": "Penseelgrootte vergroten",
         "color_label_blue": "Kleurlabel: blauw",
diff --git a/src/i18n/locales/pl.json b/src/i18n/locales/pl.json
index fe93124699..c71ca4e71f 100644
--- a/src/i18n/locales/pl.json
+++ b/src/i18n/locales/pl.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Auto-korekta obrazu",
       "autoLensCorrection": "Automatyczna korekcja obiektywu",
+      "autoStraighten": "Automatyczne prostowanie",
       "cancel": "Anuluj",
       "colorLabel": "Etykieta koloru",
       "confirmReset": "Potwierdź reset",
@@ -288,6 +289,10 @@
       "autoAdjust_other": "Auto-korekta obrazów",
       "autoLensCorrection_one": "Automatyczna korekcja obiektywu",
       "autoLensCorrection_other": "Automatyczna korekcja obiektywu",
+      "autoStraighten_few": "Automatyczne prostowanie obrazów",
+      "autoStraighten_many": "Automatyczne prostowanie obrazów",
+      "autoStraighten_one": "Automatyczne prostowanie obrazu",
+      "autoStraighten_other": "Automatyczne prostowanie obrazów",
       "collage_few": "Dodaj ramki do obrazów",
       "collage_many": "Utwórz kolaż z {{count}} obrazów",
       "collage_one": "Dodaj ramkę do obrazu",
@@ -510,6 +515,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Proporcje",
+      "autoStraightenFailed": "Automatyczne prostowanie nie powiodło się: {{error}}",
+      "autoStraightenNoLines": "Nie znaleziono prostych linii do wyprostowania",
       "custom": {
         "hPlaceholder": "Wys.",
         "hTooltip": "Wysokość",
@@ -609,6 +616,7 @@
       "rotationHeading": "Obrót",
       "title": "Kadrowanie i Przekształcanie",
       "tooltips": {
+        "autoStraighten": "Automatyczne prostowanie (Shift+S)",
         "compositionOverlay": "Nakładka kompozycji",
         "flipHoriz": "Przerzuć obraz w poziomie",
         "flipVert": "Przerzuć obraz w pionie",
@@ -1738,6 +1746,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Automatyczne prostowanie",
         "brush_size_down": "Zmniejsz rozmiar pędzla",
         "brush_size_up": "Zwiększ rozmiar pędzla",
         "color_label_blue": "Etykieta koloru: Niebieski",
diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json
index beebc888c6..f523099944 100644
--- a/src/i18n/locales/pt.json
+++ b/src/i18n/locales/pt.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Ajuste Automático",
       "autoLensCorrection": "Correção automática de lente",
+      "autoStraighten": "Endireitar automaticamente",
       "cancel": "Cancelar",
       "colorLabel": "Rótulo de Cor",
       "confirmReset": "Confirmar Redefinição",
@@ -283,6 +284,9 @@
       "autoAdjust_other": "Ajustar Imagens Automaticamente",
       "autoLensCorrection_one": "Correção automática de lente",
       "autoLensCorrection_other": "Correção automática de lente",
+      "autoStraighten_many": "Endireitar imagens automaticamente",
+      "autoStraighten_one": "Endireitar imagem automaticamente",
+      "autoStraighten_other": "Endireitar imagens automaticamente",
       "collage_many": "Criar Colagem",
       "collage_one": "Emoldurar Imagem",
       "collage_other": "Criar Colagem",
@@ -490,6 +494,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Proporção de Tela",
+      "autoStraightenFailed": "Falha ao endireitar automaticamente: {{error}}",
+      "autoStraightenNoLines": "Nenhuma linha reta encontrada para endireitar",
       "custom": {
         "hPlaceholder": "A",
         "hTooltip": "Altura",
@@ -589,6 +595,7 @@
       "rotationHeading": "Rotação",
       "title": "Cortar e Transformar",
       "tooltips": {
+        "autoStraighten": "Endireitar automaticamente (Shift+S)",
         "compositionOverlay": "Sobreposição de Composição",
         "flipHoriz": "Inverter imagem horizontalmente",
         "flipVert": "Inverter imagem verticalmente",
@@ -1702,6 +1709,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Endireitar automaticamente",
         "brush_size_down": "Diminuir tamanho do pincel",
         "brush_size_up": "Aumentar tamanho do pincel",
         "color_label_blue": "Rótulo de cor: Azul",
diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json
index b6f854748a..aa6bdeea8d 100644
--- a/src/i18n/locales/ru.json
+++ b/src/i18n/locales/ru.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "Автонастройка изображения",
       "autoLensCorrection": "Автокоррекция объектива",
+      "autoStraighten": "Автовыравнивание",
       "cancel": "Отмена",
       "colorLabel": "Цветовая метка",
       "confirmReset": "Подтвердить сброс",
@@ -288,6 +289,10 @@
       "autoAdjust_other": "Автонастройка изображений",
       "autoLensCorrection_one": "Автокоррекция объектива",
       "autoLensCorrection_other": "Автокоррекция объектива",
+      "autoStraighten_few": "Автовыравнивание изображений",
+      "autoStraighten_many": "Автовыравнивание изображений",
+      "autoStraighten_one": "Автовыравнивание изображения",
+      "autoStraighten_other": "Автовыравнивание изображений",
       "collage_few": "Создать коллаж",
       "collage_many": "Создать коллаж",
       "collage_one": "Добавить рамку",
@@ -510,6 +515,8 @@
     },
     "crop": {
       "aspectRatioHeading": "Соотношение сторон",
+      "autoStraightenFailed": "Не удалось выровнять автоматически: {{error}}",
+      "autoStraightenNoLines": "Не найдено прямых линий для выравнивания",
       "custom": {
         "hPlaceholder": "В",
         "hTooltip": "Высота",
@@ -609,6 +616,7 @@
       "rotationHeading": "Вращение",
       "title": "Обрезка и трансформация",
       "tooltips": {
+        "autoStraighten": "Автовыравнивание (Shift+S)",
         "compositionOverlay": "Сетка композиции",
         "flipHoriz": "Отразить горизонтально",
         "flipVert": "Отразить вертикально",
@@ -1738,6 +1746,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "Автовыравнивание",
         "brush_size_down": "Уменьшить размер кисти",
         "brush_size_up": "Увеличить размер кисти",
         "color_label_blue": "Цветовая метка: Синий",
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index b80b5a67ef..772092b720 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "自动调整图像",
       "autoLensCorrection": "自动镜头校正",
+      "autoStraighten": "自动拉直",
       "cancel": "取消",
       "colorLabel": "颜色标签",
       "confirmReset": "确认重置",
@@ -278,6 +279,8 @@
       "autoAdjust_other": "自动调整图像",
       "autoLensCorrection_one": "自动镜头校正",
       "autoLensCorrection_other": "自动镜头校正",
+      "autoStraighten_one": "自动拉直图像",
+      "autoStraighten_other": "自动拉直图像",
       "collage_one": "装裱图像",
       "collage_other": "创建拼贴画",
       "confirmDelete": "确认删除",
@@ -468,6 +471,8 @@
     },
     "crop": {
       "aspectRatioHeading": "宽高比",
+      "autoStraightenFailed": "自动拉直失败：{{error}}",
+      "autoStraightenNoLines": "未找到可用于拉直的直线",
       "custom": {
         "hPlaceholder": "高",
         "hTooltip": "高度",
@@ -567,6 +572,7 @@
       "rotationHeading": "旋转",
       "title": "裁剪与变换",
       "tooltips": {
+        "autoStraighten": "自动拉直（Shift+S）",
         "compositionOverlay": "构图叠加",
         "flipHoriz": "水平翻转图像",
         "flipVert": "垂直翻转图像",
@@ -1664,6 +1670,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "自动拉直",
         "brush_size_down": "减小画笔大小",
         "brush_size_up": "增大画笔大小",
         "color_label_blue": "颜色标签：蓝色",
diff --git a/src/i18n/locales/zh-TW.json b/src/i18n/locales/zh-TW.json
index 4ec007556e..b34e0cf787 100644
--- a/src/i18n/locales/zh-TW.json
+++ b/src/i18n/locales/zh-TW.json
@@ -209,6 +209,7 @@
     "editor": {
       "autoAdjust": "自動調整影像",
       "autoLensCorrection": "自動鏡頭校正",
+      "autoStraighten": "自動拉直",
       "cancel": "取消",
       "colorLabel": "顏色標籤",
       "confirmReset": "確認重置",
@@ -278,6 +279,8 @@
       "autoAdjust_other": "自動調整影像",
       "autoLensCorrection_one": "自動鏡頭校正",
       "autoLensCorrection_other": "自動鏡頭校正",
+      "autoStraighten_one": "自動拉直影像",
+      "autoStraighten_other": "自動拉直影像",
       "collage_one": "裝裱影像",
       "collage_other": "建立拼貼畫",
       "confirmDelete": "確認刪除",
@@ -468,6 +471,8 @@
     },
     "crop": {
       "aspectRatioHeading": "寬高比",
+      "autoStraightenFailed": "自動拉直失敗：{{error}}",
+      "autoStraightenNoLines": "找不到可用於拉直的直線",
       "custom": {
         "hPlaceholder": "高",
         "hTooltip": "高度",
@@ -567,6 +572,7 @@
       "rotationHeading": "旋轉",
       "title": "裁剪與變換",
       "tooltips": {
+        "autoStraighten": "自動拉直（Shift+S）",
         "compositionOverlay": "構圖疊加",
         "flipHoriz": "水平翻轉影像",
         "flipVert": "垂直翻轉影像",
@@ -1664,6 +1670,7 @@
     },
     "keybinds": {
       "actions": {
+        "auto_straighten": "自動拉直",
         "brush_size_down": "減小畫筆大小",
         "brush_size_up": "增大畫筆大小",
         "color_label_blue": "顏色標籤：藍色",
diff --git a/src/store/useEditorStore.ts b/src/store/useEditorStore.ts
index 3107de0893..8971252535 100644
--- a/src/store/useEditorStore.ts
+++ b/src/store/useEditorStore.ts
@@ -57,6 +57,7 @@ interface EditorState {
   overlayMode: OverlayMode;
   overlayRotation: number;
   isStraightenActive: boolean;
+  isAutoStraightening: boolean;
   isWbPickerActive: boolean;
   isRelightPickerActive: boolean;
   activeRelightLightId: string | null;
@@ -123,6 +124,7 @@ export const useEditorStore = create<EditorState>((set) => ({
   overlayMode: 'thirds',
   overlayRotation: 0,
   isStraightenActive: false,
+  isAutoStraightening: false,
   isWbPickerActive: false,
   isRelightPickerActive: false,
   activeRelightLightId: null,
diff --git a/src/utils/keyboardUtils.ts b/src/utils/keyboardUtils.ts
index 046d57fb11..700183cc32 100644
--- a/src/utils/keyboardUtils.ts
+++ b/src/utils/keyboardUtils.ts
@@ -311,6 +311,12 @@ export const KEYBIND_DEFINITIONS: KeybindDefinition[] = [
     defaultCombo: ['KeyS'],
     section: 'editing',
   },
+  {
+    action: 'auto_straighten',
+    description: 'settings.keybinds.actions.auto_straighten',
+    defaultCombo: ['shift', 'KeyS'],
+    section: 'editing',
+  },
   {
     action: 'brush_size_up',
     description: 'settings.keybinds.actions.brush_size_up',