Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

LR-VIEW-PHOTOGRID: the grid reads only the photos an import batch or an edit touched

Nathaniel Ledfordd184b3ef505f
diff --git a/crates/catalog/src/dates.rs b/crates/catalog/src/dates.rs
index ca463dc55..3b9c56bf0 100644
--- a/crates/catalog/src/dates.rs
+++ b/crates/catalog/src/dates.rs
@@ -156,38 +156,56 @@ impl Catalog {
/// never split by a header. Empty for sort keys without a date and for [`GroupBy::None`]
/// ([`GroupBy::Auto`] means days here).
pub fn date_runs(&self, ids: &[PhotoId], key: SortKey, by: GroupBy) -> Vec<DateRun> {
- if by == GroupBy::None || ids.is_empty() {
+ if !groups_by_date(key, by) || ids.is_empty() {
return Vec::new();
}
- let n = by.prefix();
- let date_of = |id: &PhotoId| -> String {
- let Some(p) = self.photo(*id) else { return String::new() };
- let d = match key {
- SortKey::CaptureDate => p.captured.as_deref(),
- SortKey::ImportDate => Some(p.imported.as_str()),
- SortKey::EditDate => p.edited.as_deref(),
- _ => None,
- };
- d.filter(|d| iso_seconds(d.get(..10).unwrap_or("")).is_some()).and_then(|d| d.get(..n)).unwrap_or("").to_string()
+ date_runs_of(ids, &self.stack_index(), |_, id| self.date_group(id, key, by))
+ }
+
+ /// The date group of photo `id` on its own for [`Catalog::date_runs`] (`2026-09-30` /
+ /// `2026-09` / `2026`; empty without a usable date): a stack's members take the group of its
+ /// first photo in the list there.
+ pub fn date_group(&self, id: PhotoId, key: SortKey, by: GroupBy) -> String {
+ let Some(p) = self.photo(id) else { return String::new() };
+ let d = match key {
+ SortKey::CaptureDate => p.captured.as_deref(),
+ SortKey::ImportDate => Some(p.imported.as_str()),
+ SortKey::EditDate => p.edited.as_deref(),
+ _ => None,
};
- if !matches!(key, SortKey::CaptureDate | SortKey::ImportDate | SortKey::EditDate) {
- return Vec::new();
- }
- let stacks = self.stack_index();
- let mut runs: Vec<DateRun> = Vec::new();
- let mut stack_key: std::collections::HashMap<crate::StackId, String> = Default::default();
- for (i, id) in ids.iter().enumerate() {
- let k = match stacks.get(id) {
- Some((sid, _)) => stack_key.entry(*sid).or_insert_with(|| date_of(id)).clone(),
- None => date_of(id),
- };
- match runs.last_mut() {
- Some(r) if r.key == k => r.count += 1,
- _ => runs.push(DateRun { label: group_label(&k), key: k, start: i, count: 1 }),
+ d.filter(|d| iso_seconds(d.get(..10).unwrap_or("")).is_some()).and_then(|d| d.get(..by.prefix())).unwrap_or("").to_string()
+ }
+}
+
+/// Whether [`Catalog::date_runs`] has runs for sort key `key` grouped `by`.
+pub fn groups_by_date(key: SortKey, by: GroupBy) -> bool {
+ by != GroupBy::None && matches!(key, SortKey::CaptureDate | SortKey::ImportDate | SortKey::EditDate)
+}
+
+/// [`Catalog::date_runs`] from each photo's own group (`group(position, id)`, see
+/// [`Catalog::date_group`]) and the stack index ([`Catalog::stack_index`]).
+pub fn date_runs_of<K: AsRef<str>>(
+ ids: &[PhotoId],
+ stacks: &std::collections::HashMap<PhotoId, (crate::StackId, usize)>,
+ mut group: impl FnMut(usize, PhotoId) -> K,
+) -> Vec<DateRun> {
+ let mut runs: Vec<DateRun> = Vec::new();
+ let mut stack_key: std::collections::HashMap<crate::StackId, String> = Default::default();
+ for (i, id) in ids.iter().enumerate() {
+ let own;
+ let k: &str = match stacks.get(id) {
+ Some((sid, _)) => stack_key.entry(*sid).or_insert_with(|| group(i, *id).as_ref().to_string()),
+ None => {
+ own = group(i, *id);
+ own.as_ref()
}
+ };
+ match runs.last_mut() {
+ Some(r) if r.key == k => r.count += 1,
+ _ => runs.push(DateRun { label: group_label(k), key: k.to_string(), start: i, count: 1 }),
}
- runs
}
+ runs
}
#[cfg(test)]
diff --git a/crates/ui-egui/src/panels/grid.rs b/crates/ui-egui/src/panels/grid.rs
index 8ec5fd6e4..6ce3c49d9 100644
--- a/crates/ui-egui/src/panels/grid.rs
+++ b/crates/ui-egui/src/panels/grid.rs
@@ -42,6 +42,9 @@ pub struct GridStats {
pub layout_builds: u64,
/// Per-view data (date runs, row index) built.
pub view_builds: u64,
+ /// Photos whose date and shape were read from the catalog (every photo of a list read whole;
+ /// only the photos an edit touched of one followed: [`GridCache`]).
+ pub photos_read: u64,
/// Stack indexes built.
pub stack_index_builds: u64,
/// Wall-clock time of the last [`show`].
@@ -62,6 +65,10 @@ type StackIndex = HashMap<PhotoId, (StackId, usize)>;
/// (`None`: no headers) and the grouping.
type RunsKey = (u64, Option<SortKey>, GroupBy);
+/// The most photos an edit may touch for the grid to read only those again (each costs a lookup
+/// and a date parse; past this, reading the whole list is as quick).
+const MAX_FOLLOWED: usize = 4096;
+
/// What the grid derives from the visible photos, kept across frames. Everything is keyed by the
/// session's visible-list generation ([`lightcraft_engine::Session::visible_shared`]), which
/// changes whenever the list is recomputed (any catalog change: crops, orientation, dates, stacks;
@@ -75,21 +82,161 @@ pub struct GridCache {
stacks: Option<(u64, Arc<StackIndex>)>,
/// How many of the photos are browsed (Local) ones, by generation.
local: Option<(u64, usize)>,
+ /// What was read of each photo of the list last shown.
+ read: Option<ListRead>,
+}
+
+/// What the grid read of each photo of a list, position by position: its own date group (a
+/// stack's members take their first photo's when the runs are made) and its cell's shape. A new
+/// list that differs from this one by the photos an edit touched (an import's batch, a capture
+/// time, a crop) is read again only for those: at 180,000 photos, reading every photo again took
+/// most of a 100 ms frame for each batch an import added.
+struct ListRead {
+ ids: Arc<[PhotoId]>,
+ /// The catalog revision it was read at.
+ revision: u64,
+ /// The date and grouping of the groups (`None`: the list has no date runs, no group is read).
+ dates: Option<(SortKey, GroupBy)>,
+ /// Each photo's group, an index into `names`.
+ groups: Vec<u32>,
+ names: Vec<String>,
+ named: HashMap<String, u32>,
+ /// Each photo's shape; `None` for the square grid, whose cells are all alike.
+ shapes: Option<Vec<f32>>,
+}
+
+impl ListRead {
+ fn new(ids: Arc<[PhotoId]>, revision: u64, dates: Option<(SortKey, GroupBy)>, shaped: bool) -> ListRead {
+ let n = ids.len();
+ let groups = Vec::with_capacity(if dates.is_some() { n } else { 0 });
+ ListRead { ids, revision, dates, groups, names: Vec::new(), named: HashMap::new(), shapes: shaped.then(|| Vec::with_capacity(n)) }
+ }
+
+ /// Read photo `id` from the catalog and put it next.
+ fn read(&mut self, cat: &Catalog, id: PhotoId) {
+ if let Some((key, by)) = self.dates {
+ let name = cat.date_group(id, key, by);
+ let next = u32::try_from(self.names.len()).unwrap_or(u32::MAX);
+ let g = match self.named.get(&name) {
+ Some(g) => *g,
+ None => {
+ self.named.insert(name.clone(), next);
+ self.names.push(name);
+ next
+ }
+ };
+ self.groups.push(g);
+ }
+ if let Some(shapes) = self.shapes.as_mut() {
+ shapes.push(shape_of(cat, id));
+ }
+ }
+
+ /// Read every photo of `ids`.
+ fn whole(stats: &mut GridStats, cat: &Catalog, ids: &Arc<[PhotoId]>, dates: Option<(SortKey, GroupBy)>, shaped: bool) -> ListRead {
+ let mut r = ListRead::new(ids.clone(), cat.revision, dates, shaped);
+ if r.dates.is_some() || shaped {
+ for id in ids.iter() {
+ r.read(cat, *id);
+ }
+ stats.photos_read += ids.len() as u64;
+ }
+ r
+ }
+
+ /// `ids` from what was read of the list before it: the photos the catalog says changed since
+ /// are read again, the others are taken over. `None` when the list is not this one with
+ /// those photos changed, added or removed (another view, order or grouping; an edit to more
+ /// than photos of its own, such as a stack): read it whole then.
+ fn follow(self, stats: &mut GridStats, cat: &Catalog, ids: &Arc<[PhotoId]>, dates: Option<(SortKey, GroupBy)>, shaped: bool) -> Option<ListRead> {
+ if self.dates != dates || self.shapes.is_some() != shaped {
+ return None;
+ }
+ let touched: HashSet<PhotoId> = cat.touched_since(self.revision)?.into_iter().collect();
+ if touched.len() > MAX_FOLLOWED {
+ return None;
+ }
+ let mut r = ListRead::new(ids.clone(), cat.revision, dates, shaped);
+ // (the groups' names go on: an import adds a day or two at most)
+ r.names = self.names;
+ r.named = self.named;
+ let mut was = 0;
+ let mut fresh = 0u64;
+ for id in ids.iter() {
+ if touched.contains(id) {
+ r.read(cat, *id);
+ fresh += 1;
+ continue;
+ }
+ // (the photos touched are read again wherever they are now)
+ while self.ids.get(was).is_some_and(|w| touched.contains(w)) {
+ was += 1;
+ }
+ // an untouched photo is where it was, among the others: else this is another list
+ if self.ids.get(was) != Some(id) {
+ return None;
+ }
+ if dates.is_some() {
+ r.groups.push(*self.groups.get(was)?);
+ }
+ if let (Some(to), Some(from)) = (r.shapes.as_mut(), self.shapes.as_ref()) {
+ to.push(*from.get(was)?);
+ }
+ was += 1;
+ }
+ // no untouched photo left the list
+ if self.ids.get(was..).is_some_and(|rest| rest.iter().any(|w| !touched.contains(w))) {
+ return None;
+ }
+ stats.photos_read += fresh;
+ Some(r)
+ }
}
impl GridCache {
- fn runs(&mut self, stats: &mut GridStats, cat: &Catalog, ids: &[PhotoId], key: RunsKey) -> Arc<Vec<DateRun>> {
+ /// The date runs of `ids`, reading what has to be read of them (`square`: the cells' shapes
+ /// are not wanted).
+ fn runs(&mut self, stats: &mut GridStats, cat: &Catalog, ids: &Arc<[PhotoId]>, key: RunsKey, square: bool) -> Arc<Vec<DateRun>> {
+ let shaped = !square;
match &self.runs {
- Some((k, r)) if *k == key => r.clone(),
+ Some((k, r)) if *k == key && self.read.as_ref().is_some_and(|read| read.shapes.is_some() == shaped) => r.clone(),
_ => {
stats.view_builds += 1;
- let r = Arc::new(key.1.map(|sort| cat.date_runs(ids, sort, key.2)).unwrap_or_default());
+ let dates = key.1.map(|sort| (sort, key.2)).filter(|(sort, by)| lightcraft_catalog::dates::groups_by_date(*sort, *by));
+ let read = match self.read.take() {
+ // (the same list, read at this revision)
+ Some(r) if Arc::ptr_eq(&r.ids, ids) && r.revision == cat.revision && r.dates == dates && r.shapes.is_some() == shaped => r,
+ Some(r) => r.follow(stats, cat, ids, dates, shaped).unwrap_or_else(|| ListRead::whole(stats, cat, ids, dates, shaped)),
+ None => ListRead::whole(stats, cat, ids, dates, shaped),
+ };
+ let r = Arc::new(match dates {
+ Some(_) if !ids.is_empty() => {
+ let stacks = self.stacks(stats, cat, key.0);
+ let group = |i: usize, _: PhotoId| read.groups.get(i).and_then(|g| read.names.get(*g as usize)).map_or("", String::as_str);
+ lightcraft_catalog::dates::date_runs_of(ids, &stacks, group)
+ }
+ _ => Vec::new(),
+ });
+ self.read = Some(read);
self.runs = Some((key, r.clone()));
r
}
}
}
+ /// The shape of each cell of the list last shown (width / height), in list order; empty for
+ /// the square grid.
+ fn shapes(&self) -> &[f32] {
+ self.read.as_ref().and_then(|r| r.shapes.as_deref()).unwrap_or(&[])
+ }
+
+ /// The date runs and the cell shapes the grid shows now (tests compare them with a grid made
+ /// afresh).
+ #[cfg(test)]
+ pub(crate) fn runs_and_shapes(&self) -> Option<(Arc<Vec<DateRun>>, Vec<f32>)> {
+ Some((self.runs.as_ref()?.1.clone(), self.shapes().to_vec()))
+ }
+
fn stacks(&mut self, stats: &mut GridStats, cat: &Catalog, generation: u64) -> Arc<StackIndex> {
match &self.stacks {
Some((g, s)) if *g == generation => s.clone(),
@@ -114,18 +261,14 @@ impl GridCache {
}
}
-/// Width / height of each photo's cell: its cropped, oriented shape.
-fn aspects(cat: &Catalog, ids: &[PhotoId]) -> Vec<f32> {
- ids.iter()
- .map(|id| {
- let p = cat.photo(*id);
- let (w, h) = p.map(|p| (p.width.max(1) as f32, p.height.max(1) as f32)).unwrap_or((3.0, 2.0));
- let swap = p.is_some_and(|p| p.develop.orientation.swaps_axes());
- let crop = p.map(|p| p.develop.crop.geometry.rect).unwrap_or(lightcraft_geom::Rect::UNIT);
- let (w, h) = if swap { (h, w) } else { (w, h) };
- (w * crop.width() as f32) / (h * crop.height() as f32).max(1e-3)
- })
- .collect()
+/// Width / height of a photo's cell: its cropped, oriented shape.
+pub(crate) fn shape_of(cat: &Catalog, id: PhotoId) -> f32 {
+ let p = cat.photo(id);
+ let (w, h) = p.map(|p| (p.width.max(1) as f32, p.height.max(1) as f32)).unwrap_or((3.0, 2.0));
+ let swap = p.is_some_and(|p| p.develop.orientation.swaps_axes());
+ let crop = p.map(|p| p.develop.crop.geometry.rect).unwrap_or(lightcraft_geom::Rect::UNIT);
+ let (w, h) = if swap { (h, w) } else { (w, h) };
+ (w * crop.width() as f32) / (h * crop.height() as f32).max(1e-3)
}
/// The rows (of a layout's `rows`, top to bottom) that meet the y range `top..=bottom`, found by
@@ -211,7 +354,7 @@ fn show_inner(app: &mut LightcraftApp, ui: &mut egui::Ui) {
};
let runs_key = (generation, group_key, by);
let stats = &mut app.caches.grid_stats;
- let runs = app.caches.grid.runs(stats, &app.session.catalog, &ids, runs_key);
+ let runs = app.caches.grid.runs(stats, &app.session.catalog, &ids, runs_key, square);
// the layout only changes with the photos (and their shapes), the grouping, the width and
// the thumbnail size
let lay_key = (runs_key, avail_w.to_bits(), target.to_bits(), square);
@@ -219,9 +362,15 @@ fn show_inner(app: &mut LightcraftApp, ui: &mut egui::Ui) {
Some((k, l)) if *k == lay_key => l.clone(),
_ => {
stats.layout_builds += 1;
- let aspects = if square { vec![1.0; ids.len()] } else { aspects(&app.session.catalog, &ids) };
+ let ones;
+ let shapes = if square {
+ ones = vec![1.0; ids.len()];
+ &ones[..]
+ } else {
+ app.caches.grid.shapes()
+ };
let spans: Vec<(usize, usize)> = runs.iter().map(|r| (r.start, r.count)).collect();
- let l = Arc::new(layout(&aspects, &spans, avail_w, target, square));
+ let l = Arc::new(layout(shapes, &spans, avail_w, target, square));
app.caches.grid.layout = Some((lay_key, l.clone()));
l
}
diff --git a/crates/ui-egui/src/tests_grid.rs b/crates/ui-egui/src/tests_grid.rs
index 6c85ecf59..875598db0 100644
--- a/crates/ui-egui/src/tests_grid.rs
+++ b/crates/ui-egui/src/tests_grid.rs
@@ -217,3 +217,142 @@ fn double_clicking_a_stack_badge_toggles_the_stack_once() {
h.settle(SETTLE);
assert!(!collapsed(&h), "a single click toggles it");
}
+
+/// What the grid shows (its date runs, and each cell's shape) is what a grid made afresh for the
+/// same list shows.
+fn assert_as_made_afresh(h: &mut Headless, what: &str) {
+ let vis = h.app.session.visible().to_vec();
+ if vis.is_empty() {
+ // (no photo matches: the grid says so and draws none)
+ return;
+ }
+ let (runs, shapes) = h.app.caches.grid.runs_and_shapes().expect("the grid was drawn");
+ let cat = &h.app.session.catalog;
+ let by = crate::panels::grid::resolve_group(h.app.session.sort.group, h.app.ui.thumb_size);
+ assert_eq!(*runs, cat.date_runs(&vis, h.app.session.sort.key, by), "date runs {what}");
+ // (the square grid's cells are all alike: it reads no shape)
+ let fresh: Vec<f32> =
+ if h.app.ui.view == ViewMode::SquareGrid { Vec::new() } else { vis.iter().map(|id| crate::panels::grid::shape_of(cat, *id)).collect() };
+ assert_eq!(shapes, fresh, "cell shapes {what}");
+}
+
+fn photo(h: &mut Headless, n: u64, captured: &str) -> Op {
+ let id = h.app.session.catalog.alloc_photo_id();
+ let (w, h_) = if n.is_multiple_of(3) { (4000, 6000) } else { (6000, 4000) };
+ let mut p = Photo::new(
+ id,
+ Source::File { path: format!("/lightcraft-grid-test/NEW_{n:05}.jpg") },
+ &format!("NEW_{n:05}.jpg"),
+ "JPEG",
+ w,
+ h_,
+ "2026-01-02T00:00:00",
+ );
+ p.captured = Some(captured.to_string());
+ Op::AddPhoto { photo: Box::new(p) }
+}
+
+/// An import lands its photos a batch at a time: the grid reads the batch's photos, not the
+/// whole list again (at 180,000 photos that was most of a 100 ms frame per batch). An edit to a
+/// photo's date or shape reads that photo.
+#[test]
+fn a_batch_of_new_photos_or_an_edit_to_one_is_read_photo_by_photo() {
+ let mut h = grid(ViewMode::PhotoGrid);
+ let read = h.app.caches.grid_stats.photos_read;
+ assert_eq!(read, N, "the first frame reads every photo");
+ // sixteen photos, on days already shown, a new day, and with no date at all
+ let ops: Vec<Op> = (0..16)
+ .map(|k| {
+ let day = ["2026-12-28T09:30:00", "2026-11-03T10:00:00", "2027-01-05T12:00:00", "nope"][k as usize % 4];
+ photo(&mut h, k, day)
+ })
+ .collect();
+ h.app.session.commit("Import", Op::Batch { ops }).unwrap();
+ h.step();
+ assert_eq!(h.app.caches.grid_stats.photos_read - read, 16, "only the batch's photos are read");
+ assert!(widget(&h, "group:2027-01-05").is_some(), "the new day heads the grid");
+ assert_as_made_afresh(&mut h, "after the batch");
+ // a photo taken on another day: it moves there, and only it is read
+ let read = h.app.caches.grid_stats.photos_read;
+ h.app.session.commit("Capture time", Op::SetCaptured { id: PhotoId(500), captured: Some("2027-02-01T08:00:00".into()) }).unwrap();
+ h.step();
+ assert_eq!(h.app.caches.grid_stats.photos_read - read, 1, "only the photo edited is read");
+ assert!(widget(&h, "group:2027-02-01").is_some(), "its new day heads the grid");
+ assert_as_made_afresh(&mut h, "after a capture time");
+}
+
+/// Whatever the edit, the grid shows what a grid made afresh would: followed photo by photo when
+/// the list changed by the photos the edit touched, else read whole.
+#[test]
+fn a_grid_followed_through_edits_shows_what_a_grid_made_afresh_shows() {
+ let mut h = grid(ViewMode::PhotoGrid);
+ let mut dice = 11u64;
+ let mut roll = |sides: u64| {
+ dice = lightcraft_catalog::mix64(dice);
+ dice % sides
+ };
+ for step in 0..120 {
+ let vis = h.app.session.visible().to_vec();
+ if vis.is_empty() {
+ // (no picks shown: back to every photo)
+ h.app.session.filter.flag = None;
+ continue;
+ }
+ let id = vis[roll(vis.len() as u64) as usize].0;
+ let n = roll(1000);
+ match roll(12) {
+ 0 => {
+ let ops: Vec<Op> =
+ (0..1 + roll(20)).map(|k| photo(&mut h, n * 100 + k, &format!("2026-{:02}-{:02}T10:00:00", 1 + n % 12, 1 + k % 28))).collect();
+ h.app.session.commit("Import", Op::Batch { ops }).unwrap();
+ }
+ 1 => {
+ let _ = h.app.session.commit("Delete", Op::SetDeleted { id: PhotoId(id), deleted: true });
+ }
+ 2 => {
+ let _ = h
+ .app
+ .session
+ .commit("Capture time", Op::SetCaptured { id: PhotoId(id), captured: Some(format!("2026-{:02}-03T10:00:00", 1 + n % 12)) });
+ }
+ 3 => {
+ h.app.session.execute("library.select", &json!({"ids": [id]})).unwrap();
+ let r = h.app.session.execute("photo.rotateRight", &json!({}));
+ assert!(r.is_ok(), "{r:?}");
+ }
+ 4 => {
+ let mut d = (*h.app.session.catalog.photo(PhotoId(id)).unwrap().develop).clone();
+ d.crop.geometry.rect = lightcraft_geom::Rect::new(0.1, 0.0, 0.9 - 0.1 * (n % 4) as f64, 1.0);
+ h.app
+ .session
+ .commit("Crop", Op::SetDevelop { id: PhotoId(id), settings: std::sync::Arc::new(d), label: "Crop".into(), edited: None })
+ .unwrap();
+ }
+ 5 => h.app.session.commit("Rating", Op::SetRating { id: PhotoId(id), rating: (n % 6) as u8 }).unwrap(),
+ 6 => {
+ let key = ["captureDate", "fileName", "importDate"][n as usize % 3];
+ let r = h.app.session.execute("library.sort", &json!({"key": key, "ascending": n.is_multiple_of(2)}));
+ assert!(r.is_ok(), "{r:?}");
+ }
+ 7 => {
+ // a stack: an edit to more than its photos, read whole
+ let other = vis[n as usize % vis.len()].0;
+ let _ = h.app.session.execute("stack.group", &json!({"ids": [id, other], "top": id, "collapsed": n.is_multiple_of(2)}));
+ }
+ 8 => {
+ let _ = h.app.session.execute("edit.undo", &json!({}));
+ }
+ 9 => {
+ // picks, for the filter below to show some
+ for k in 0..1 + n % 40 {
+ let p = vis[(n as usize * 7 + k as usize * 13) % vis.len()];
+ h.app.session.commit("Flag", Op::SetFlag { id: p, flag: lightcraft_catalog::Flag::Pick }).unwrap();
+ }
+ }
+ 10 => h.app.ui.view = if h.app.ui.view == ViewMode::PhotoGrid { ViewMode::SquareGrid } else { ViewMode::PhotoGrid },
+ _ => h.app.session.filter.flag = n.is_multiple_of(2).then_some(lightcraft_catalog::Flag::Pick),
+ }
+ h.step();
+ assert_as_made_afresh(&mut h, &format!("after step {step}"));
+ }
+}
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index 02f5bf08f..e53fa2525 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -1,4 +1,5 @@
# Lightroom parity checklist
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-16 · **Change:** minor (LR-VIEW-PHOTOGRID: the grid reads only the photos an import batch or an edit touched, not the whole list; earlier: LRC-PRINT-PAGE: Print Page Options) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-20 · **Change:** minor (LR-VIEW-ZOOM: only a full-size drag within 20 ms clears a slow-drag verdict) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
@@ -896,3 +897,4 @@ Latin stays upright. Advanced Japanese composition remains open. Regression cove
| 2026-10-14 | patch | LRC-LIB-CATALOG-IMPORT: reconciled with upstream phased progress, cancellation kinds, WAL-only import, translations and current progress tracking. Status and summary counts unchanged. |
| 2026-10-13 | minor | KEYC-COMPARE: `=` / `-` (also `+`) increase / decrease the grid thumbnail size (`view.thumbSizeUp` / `view.thumbSizeDown`, View menu), grids only; status unchanged (🟡) |
| 2026-10-16 | patch | LR-META-XMP: a TIFF or JPEG imported beside a raw of its stem reads its own `<file>.xmp` and takes nothing from the raw's `IMG_0001.xmp`, whether it arrives with the raw or after it (a stem sidecar belongs to one file: a raw first, then the first by name); status unchanged (✅) |
+| 2026-10-16 | minor | LR-VIEW-PHOTOGRID: when the photos shown change by those an edit touched (an import's batch, a capture time, a crop), the grid reads only those photos' dates and shapes again instead of every photo of the list (a 16-photo batch at 181,749 photos: grid frame 101 ms → 7 ms); status unchanged |
diff --git a/docs/whats-new.md b/docs/whats-new.md
index cfeed33ed..b42eb9dbc 100644
--- a/docs/whats-new.md
+++ b/docs/whats-new.md
@@ -24,6 +24,13 @@
another ratio (4 × 5, 2 × 3…) keeps it portrait, as in Lightroom, and a Custom ratio taller than wide gives a
portrait crop.
+## 2026-10-16
+
+### The photo grid keeps up with imports into a large library
+- While photos are imported into a large library, the grid takes in each batch as it arrives instead of reading
+ every photo of the view again: at about 180,000 photos a batch cost the window a tenth of a second, over and over
+ for as long as the import ran. Changing one photo's capture time or crop is quicker too.
+
## 2026-10-15
### Constrain Crop tightens the crop you see