diff --git a/editor/Assets/AssetBrowserView.axaml.cs b/editor/Assets/AssetBrowserView.axaml.cs
index 28900aaed..830a5e886 100644
--- a/editor/Assets/AssetBrowserView.axaml.cs
+++ b/editor/Assets/AssetBrowserView.axaml.cs
@@ -46,15 +46,31 @@ public AssetBrowserView() {
 
 		AssetBrowserViewModel? subscribed = null;
 		DataContextChanged += (_, _) => {
-			if (subscribed is not null) subscribed.PropertyChanged -= OnViewModelPropertyChanged;
+			if (subscribed is not null) {
+				subscribed.PropertyChanged -= OnViewModelPropertyChanged;
+				subscribed.ItemRevealed -= OnItemRevealed;
+			}
+
 			subscribed = DataContext as AssetBrowserViewModel;
-			if (subscribed is not null) subscribed.PropertyChanged += OnViewModelPropertyChanged;
+			if (subscribed is not null) {
+				subscribed.PropertyChanged += OnViewModelPropertyChanged;
+				subscribed.ItemRevealed += OnItemRevealed;
+			}
+
 			ApplyCardSize();
 		};
 	}
 
 	private AssetBrowserViewModel Vm => (AssetBrowserViewModel)DataContext!;
 
+	private void OnItemRevealed(object item) {
+		Avalonia.Threading.Dispatcher.UIThread.Post(() => {
+			var index = Vm.CurrentItems.IndexOf(item);
+			if (index < 0) return;
+			AssetRepeater.GetOrCreateElement(index).BringIntoView();
+		}, Avalonia.Threading.DispatcherPriority.Loaded);
+	}
+
 	private void OnSelectTemplateKey(object? sender, SelectTemplateEventArgs e) {
 		e.TemplateKey = e.DataContext is AssetFolder ? "folder" : "file";
 	}
diff --git a/editor/Assets/AssetBrowserViewModel.cs b/editor/Assets/AssetBrowserViewModel.cs
index d00672df4..1b03a1802 100644
--- a/editor/Assets/AssetBrowserViewModel.cs
+++ b/editor/Assets/AssetBrowserViewModel.cs
@@ -338,12 +338,18 @@ private void OnThumbnailUpdated(string uid) {
 
 	public new event PropertyChangedEventHandler? PropertyChanged;
 
+	public event Action<object>? ItemRevealed;
+
 	public void RevealAsset(string uid) {
 		foreach (var root in Folders)
 		foreach (var file in GetAllFiles(root)) {
 			if (file.Uid != uid) continue;
 			SearchText = "";
 			SelectedFolder = FindParentFolder(root, file);
+			var card = CurrentItems.OfType<AssetFile>().FirstOrDefault(f => f.Uid == uid);
+			if (card is null) return;
+			SelectItem(card, KeyModifiers.None);
+			ItemRevealed?.Invoke(card);
 			return;
 		}
 	}
diff --git a/editor/Assets/AssetDatabase.cs b/editor/Assets/AssetDatabase.cs
index 2542bb775..0721829de 100644
--- a/editor/Assets/AssetDatabase.cs
+++ b/editor/Assets/AssetDatabase.cs
@@ -48,11 +48,17 @@ public static bool IsUpToDate(string sourceVirtualPath, string hash) {
 	}
 
 	public static void UpdateArtworkDatabase(
-		string sourceVirtualPath, string hash, IEnumerable<string> outputUids) {
+		string sourceVirtualPath, string hash, IEnumerable<ArtworkOutput> artworkOutputs) {
 		var db = LoadArtworkDatabase();
 
 		var outputs = new JsonArray();
-		foreach (var uid in outputUids) outputs.Add(uid);
+		foreach (var output in artworkOutputs)
+			outputs.Add(new JsonObject {
+				["uid"] = output.Uid,
+				["name"] = output.Name,
+				["hash"] = output.Hash,
+				["uri"] = output.Uri
+			});
 
 		db[sourceVirtualPath] = new JsonObject {
 			["last_hash"] = hash,
@@ -62,6 +68,27 @@ public static void UpdateArtworkDatabase(
 		SaveArtworkDatabase(db);
 	}
 
+	public static IReadOnlyList<ArtworkOutput> GetArtworkOutputs(string sourceVirtualPath) {
+		if (LoadArtworkDatabase()[sourceVirtualPath] is not JsonObject entry) return [];
+		return ReadOutputs(entry);
+	}
+
+	private static List<ArtworkOutput> ReadOutputs(JsonObject entry) {
+		var result = new List<ArtworkOutput>();
+		if (entry["outputs"] is not JsonArray outputs) return result;
+
+		foreach (var node in outputs)
+			if (node is JsonObject obj && obj["uid"]?.GetValue<string>() is { } uid)
+				result.Add(new ArtworkOutput(uid, obj["name"]?.GetValue<string>() ?? "", obj["hash"]?.GetValue<string>(),
+					obj["uri"]?.GetValue<string>() ?? ""));
+			else if (node?.GetValue<string>() is { } legacyUid) {
+				var uri = TryResolve(legacyUid, out var path, out _) ? path : "";
+				result.Add(new ArtworkOutput(legacyUid, Path.GetFileName(uri), null, uri));
+			}
+
+		return result;
+	}
+
 	// full re-scan of all .meta files; writes one <db>.json per content database + core.json
 	public static void RebuildAssetDatabase(bool notifyListeners = true) {
 		var now = DateTime.UtcNow.ToString("o");
@@ -357,9 +384,8 @@ public static async Task Reimport(
 			return;
 		}
 
-		var uids = (entry["outputs"] as JsonArray)?
-			.Select(n => n!.GetValue<string>())
-			.ToList() ?? [];
+		var previous = ReadOutputs(entry);
+		var uids = previous.Select(o => o.Uid).ToList();
 
 		// find where the existing outputs live + the settings they were imported with
 		var (destDir, textureSection, psdSection, gltfSection, voxSection) = LocateOutputs(uids);
@@ -379,15 +405,10 @@ public static async Task Reimport(
 			_ => new TextureImporter(textureSettings)
 		};
 
-		var ctx = new ImportContext {
-			DestDir = destDir ?? ProjectContext.AssetsPath,
-			SourceVirtualPath = sourceVirtualPath,
-			ReuseUids = uids
-		};
-
 		log($"Reimporting {sourceVirtualPath}...");
-		var newUids = await importer.Import(realSource, ctx, log, progress);
-		UpdateArtworkDatabase(sourceVirtualPath, ComputeHash(realSource), newUids);
+		var outputs = await ArtworkImport.RunAsync(importer, realSource, sourceVirtualPath,
+			destDir ?? ProjectContext.AssetsPath, previous, log, progress);
+		UpdateArtworkDatabase(sourceVirtualPath, ComputeHash(realSource), outputs);
 		log("Reimport done.");
 	}
 
@@ -615,7 +636,8 @@ public static void RemoveArtworkOutputs(IEnumerable<string> uids) {
 			if (db[key] is not JsonObject entry) continue;
 			if (entry["outputs"] is not JsonArray outputs) continue;
 			for (var i = outputs.Count - 1; i >= 0; i--) {
-				if (outputs[i]?.GetValue<string>() is not { } output || !targets.Contains(output)) continue;
+				var output = outputs[i] is JsonObject record ? record["uid"]?.GetValue<string>() : outputs[i]?.GetValue<string>();
+				if (output is null || !targets.Contains(output)) continue;
 				outputs.RemoveAt(i);
 				changed = true;
 			}
diff --git a/editor/Assets/Importers/ArtworkImport.cs b/editor/Assets/Importers/ArtworkImport.cs
new file mode 100644
index 000000000..33ff12cb8
--- /dev/null
+++ b/editor/Assets/Importers/ArtworkImport.cs
@@ -0,0 +1,143 @@
+//
+// ArtworkImport.cs by Xein
+// 
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace editor.Assets.Importers;
+
+public sealed record ArtworkOutput(string Uid, string Name, string? Hash, string Uri);
+
+public static class ArtworkImport {
+	public static async Task<IReadOnlyList<ArtworkOutput>> RunAsync(
+		IAssetImporter importer, string realSource, string sourceVirtual, string destDir,
+		IReadOnlyList<ArtworkOutput> previous, Action<string> log, Action<double>? progress = null) {
+		var writes = new List<(string Uid, string Path)>();
+		using var scope = MetaFile.Capture(writes);
+
+		if (previous.Count == 0) {
+			var ctx = new ImportContext { DestDir = destDir, SourceVirtualPath = sourceVirtual };
+			await importer.Import(realSource, ctx, log, progress);
+			return Describe(Produced(writes, null));
+		}
+
+		var stageRoot = Path.Combine(ProjectContext.CachePath, "import_staging", Guid.NewGuid().ToString("N"));
+		// Named like the real folder
+		var stageDest = Path.Combine(stageRoot, new DirectoryInfo(destDir).Name);
+		Directory.CreateDirectory(stageDest);
+		try {
+			var ctx = new ImportContext { DestDir = stageDest, SourceVirtualPath = sourceVirtual };
+			await importer.Import(realSource, ctx, log, progress);
+			return Reconcile(Produced(writes, stageRoot), previous, stageDest, destDir, log);
+		} finally {
+			try {
+				Directory.Delete(stageRoot, true);
+			} catch {
+				/* the cache is disposable */
+			}
+		}
+	}
+
+	private static List<(string Uid, string Path)> Produced(List<(string Uid, string Path)> writes, string? root) {
+		var byUid = new Dictionary<string, string>();
+		foreach (var (uid, path) in writes) byUid[uid] = path;
+		return byUid
+			.Where(kv => File.Exists(kv.Value) && (root is null || kv.Value.StartsWith(root, StringComparison.OrdinalIgnoreCase)))
+			.Select(kv => (kv.Key, kv.Value))
+			.ToList();
+	}
+
+	private static IReadOnlyList<ArtworkOutput> Describe(IEnumerable<(string Uid, string Path)> produced) {
+		return produced.Select(p => Describe(p.Uid, p.Path)).ToList();
+	}
+
+	private static ArtworkOutput Describe(string uid, string realPath) {
+		return new ArtworkOutput(uid, Path.GetFileName(realPath), AssetDatabase.ComputeHash(realPath),
+			ProjectContext.ToVirtual(realPath) ?? realPath);
+	}
+
+	private static IReadOnlyList<ArtworkOutput> Reconcile(
+		List<(string Uid, string Path)> produced, IReadOnlyList<ArtworkOutput> previous,
+		string stageDest, string destDir, Action<string> log) {
+		var fresh = produced.Select(p => (p.Uid, p.Path, Name: Path.GetFileName(p.Path),
+			Hash: AssetDatabase.ComputeHash(p.Path))).ToList();
+
+		var free = previous.ToList();
+		var matches = new Dictionary<string, ArtworkOutput>();
+
+		void Match(Func<ArtworkOutput, (string Uid, string Path, string Name, string Hash), bool> same) {
+			foreach (var f in fresh) {
+				if (matches.ContainsKey(f.Uid)) continue;
+				var old = free.FirstOrDefault(o => same(o, f));
+				if (old is null) continue;
+				matches[f.Uid] = old;
+				free.Remove(old);
+			}
+		}
+
+		Match((o, f) => o.Hash == f.Hash);
+		Match((o, f) => string.Equals(o.Name, f.Name, StringComparison.OrdinalIgnoreCase));
+
+		foreach (var f in fresh) {
+			if (matches.ContainsKey(f.Uid)) continue;
+			var old = free.FirstOrDefault(o => o.Hash is null);
+			if (old is null) break;
+			matches[f.Uid] = old;
+			free.Remove(old);
+		}
+
+		var uidMap = matches.ToDictionary(m => m.Key, m => m.Value.Uid);
+		if (uidMap.Count > 0)
+			foreach (var file in Directory.EnumerateFiles(stageDest, "*", SearchOption.AllDirectories))
+				ReplaceUids(file, uidMap);
+
+		var outputs = new List<ArtworkOutput>();
+		var moved = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+		foreach (var f in fresh) {
+			string target;
+			if (matches.TryGetValue(f.Uid, out var old)) {
+				var uri = AssetDatabase.TryResolve(old.Uid, out var current, out _) ? current : old.Uri;
+				target = ProjectContext.Resolve(uri);
+			} else {
+				target = Path.Combine(destDir, Path.GetRelativePath(stageDest, f.Path));
+			}
+
+			var tags = MetaFile.ReadHeader(target)?.Tags;
+			Place(f.Path, target);
+			Place(f.Path + ".meta", target + ".meta");
+			if (tags is { Count: > 0 }) MetaFile.SetTags(target, tags);
+
+			moved.Add(f.Path);
+			moved.Add(f.Path + ".meta");
+			var uid = matches.TryGetValue(f.Uid, out var kept) ? kept.Uid : f.Uid;
+			outputs.Add(Describe(uid, target));
+			log($"{(kept is null ? "New" : "Replaced")} {ProjectContext.ToVirtual(target) ?? target}");
+		}
+
+		foreach (var file in Directory.EnumerateFiles(stageDest, "*", SearchOption.AllDirectories))
+			if (!moved.Contains(file))
+				Place(file, Path.Combine(destDir, Path.GetRelativePath(stageDest, file)));
+
+		return outputs;
+	}
+
+	private static void Place(string from, string to) {
+		if (!File.Exists(from)) return;
+		Directory.CreateDirectory(Path.GetDirectoryName(to)!);
+		File.Move(from, to, true);
+	}
+
+	private static void ReplaceUids(string file, IReadOnlyDictionary<string, string> uidMap) {
+		var bytes = File.ReadAllBytes(file);
+		if (Array.IndexOf(bytes, (byte)0, 0, Math.Min(bytes.Length, 8192)) >= 0) return;
+
+		var text = System.Text.Encoding.UTF8.GetString(bytes);
+		var changed = text;
+		foreach (var (from, to) in uidMap) changed = changed.Replace(from, to, StringComparison.Ordinal);
+		if (changed != text) File.WriteAllText(file, changed);
+	}
+}
diff --git a/editor/Assets/Importers/CompactImportWindowViewModel.cs b/editor/Assets/Importers/CompactImportWindowViewModel.cs
index 9507abfd8..e04550f98 100644
--- a/editor/Assets/Importers/CompactImportWindowViewModel.cs
+++ b/editor/Assets/Importers/CompactImportWindowViewModel.cs
@@ -127,9 +127,9 @@ private async Task ImportFile(string filePath, string? artworkDir, Action<string
 				return;
 			}
 
-			var ctx = new ImportContext { DestDir = destDir, SourceVirtualPath = sourceVirtual };
-			var uids = await importer.Import(realSourcePath, ctx, log, progress);
-			AssetDatabase.UpdateArtworkDatabase(sourceVirtual, hash, uids);
+			var outputs = await ArtworkImport.RunAsync(importer, realSourcePath, sourceVirtual, destDir,
+				AssetDatabase.GetArtworkOutputs(sourceVirtual), log, progress);
+			AssetDatabase.UpdateArtworkDatabase(sourceVirtual, hash, outputs);
 		} else {
 			log("Note: source outside project — reimport unavailable.");
 			var fakeVirtual = "artwork://" + Path.GetFileName(realSourcePath);
diff --git a/editor/Assets/Importers/ImportWindow.axaml b/editor/Assets/Importers/ImportWindow.axaml
index e216eec0f..81bce126f 100644
--- a/editor/Assets/Importers/ImportWindow.axaml
+++ b/editor/Assets/Importers/ImportWindow.axaml
@@ -540,6 +540,10 @@
 						                   StrokeWidth="2.5" />
 					</Button>
 				</Grid>
+				<CheckBox IsChecked="{Binding KeepFolderStructure}"
+				          IsVisible="{Binding !IsExternal}"
+				          Content="Keep folder structure"
+				          ToolTip.Tip="Recreates the artwork folders below the first folder the selected files share, with the destination standing in for that folder" />
 			</StackPanel>
 
 			<!-- Bottom buttons -->
diff --git a/editor/Assets/Importers/ImportWindowViewModel.cs b/editor/Assets/Importers/ImportWindowViewModel.cs
index 7c54ad2eb..bde1a3536 100644
--- a/editor/Assets/Importers/ImportWindowViewModel.cs
+++ b/editor/Assets/Importers/ImportWindowViewModel.cs
@@ -289,7 +289,7 @@ public partial class ImportWindowViewModel : ViewModelBase {
 	[ObservableProperty] private string m_externalSourcePath = string.Empty;
 
 	[ObservableProperty] private bool m_isExternal;
-
+	[ObservableProperty] private bool m_keepFolderStructure;
 	[ObservableProperty] private string m_locationPath = "assets://";
 	[ObservableProperty] private bool m_moveToArtwork = true;
 	[ObservableProperty] private string m_searchText = string.Empty;
@@ -486,10 +486,16 @@ private async Task ImportFromTree() {
 
 		var tasks = new List<LoaderTask>();
 
-		foreach (var file in freshFiles)
+		var baseDir = ProjectContext.Resolve(LocationPath);
+		var commonDir = KeepFolderStructure ? CommonDirectory(freshFiles) : null;
+		foreach (var file in freshFiles) {
+			var fileDir = commonDir is null
+				? baseDir
+				: Path.GetFullPath(Path.Combine(baseDir, Path.GetRelativePath(commonDir, Path.GetDirectoryName(file)!)));
 			tasks.Add(LoaderTask.DoWithProgress(
 				Path.GetFileName(file),
-				(log, progress) => ImportSingleFile(file, log, progress)));
+				(log, progress) => ImportSingleFile(file, fileDir, log, progress)));
+		}
 
 		foreach (var file in reimportFiles) {
 			var sourceVirtual = ProjectContext.ToVirtual(file);
@@ -523,7 +529,7 @@ private async Task ImportExternal() {
 
 		var task = LoaderTask.DoWithProgress(Path.GetFileName(realSourcePath), async (log, progress) => {
 			if (MoveToArtwork) {
-				await ImportSingleFile(realSourcePath, log, progress);
+				await ImportSingleFile(realSourcePath, ProjectContext.Resolve(LocationPath), log, progress);
 			} else {
 				// Import in-place without artwork-DB tracking
 				log("Note: source is outside the project — reimport won't be available.");
@@ -552,7 +558,8 @@ private void Cancel() {
 	}
 
 
-	private async Task ImportSingleFile(string realSourcePath, Action<string> log, Action<double>? progress = null) {
+	private async Task ImportSingleFile(
+		string realSourcePath, string destDir, Action<string> log, Action<double>? progress = null) {
 		try {
 			var sourceVirtual = ProjectContext.ToVirtual(realSourcePath)
 				?? throw new InvalidOperationException(
@@ -564,12 +571,10 @@ private async Task ImportSingleFile(string realSourcePath, Action<string> log, A
 				return;
 			}
 
-			var destDir = ProjectContext.Resolve(LocationPath);
-			var ext = Path.GetExtension(realSourcePath).ToLowerInvariant();
 			var importer = m_importers.First(i => i.CanHandle(realSourcePath));
-			var ctx = new ImportContext { DestDir = destDir, SourceVirtualPath = sourceVirtual };
-			var uids = await importer.Import(realSourcePath, ctx, log, progress);
-			AssetDatabase.UpdateArtworkDatabase(sourceVirtual, hash, uids);
+			var outputs = await ArtworkImport.RunAsync(importer, realSourcePath, sourceVirtual, destDir,
+				AssetDatabase.GetArtworkOutputs(sourceVirtual), log, progress);
+			AssetDatabase.UpdateArtworkDatabase(sourceVirtual, hash, outputs);
 			log("Done.");
 		} catch (Exception ex) {
 			log($"ERROR: {ex.Message}");
@@ -612,6 +617,24 @@ private static HashSet<string> LoadImportedFiles(string dbPath) {
 		return result;
 	}
 
+	private static string? CommonDirectory(IReadOnlyList<string> files) {
+		if (files.Count == 0) return null;
+		var common = Path.GetDirectoryName(files[0])!;
+		foreach (var file in files.Skip(1))
+			while (!IsInside(common, Path.GetDirectoryName(file)!)) {
+				var parent = Path.GetDirectoryName(common);
+				if (parent is null) return null;
+				common = parent;
+			}
+
+		return common;
+	}
+
+	private static bool IsInside(string folder, string path) {
+		var relative = Path.GetRelativePath(folder, path);
+		return relative == "." || (!relative.StartsWith("..", StringComparison.Ordinal) && !Path.IsPathRooted(relative));
+	}
+
 	private static (List<string> fresh, List<string> reimport) GetSelectedFiles(IEnumerable<ImportNodeViewModel> nodes) {
 		var fresh = new List<string>();
 		var reimport = new List<string>();
diff --git a/editor/Assets/MetaFile.cs b/editor/Assets/MetaFile.cs
index 3d57cade4..bb45ed18c 100644
--- a/editor/Assets/MetaFile.cs
+++ b/editor/Assets/MetaFile.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using Tomlyn;
 using Tomlyn.Model;
 using Tomlyn.Serialization;
@@ -62,7 +63,22 @@ public record AudioStringMetaSection : IMetaSection {
 }
 
 public static class MetaFile {
+	private static readonly AsyncLocal<List<(string Uid, string Path)>?> s_capture = new();
+
+	public static IDisposable Capture(List<(string Uid, string Path)> writes) {
+		s_capture.Value = writes;
+		return new CaptureScope();
+	}
+
+	private sealed class CaptureScope : IDisposable {
+		public void Dispose() {
+			s_capture.Value = null;
+		}
+	}
+
 	public static void Write(string outputAssetRealPath, MetaHeader header, params IMetaSection[] sections) {
+		s_capture.Value?.Add((header.Uid, outputAssetRealPath));
+
 		var tags = header.Tags ?? ReadHeader(outputAssetRealPath)?.Tags;
 		var dto = new MetaFileDto {
 			Uid = header.Uid,
diff --git a/editor/Components/Elements/AssetBox.cs b/editor/Components/Elements/AssetBox.cs
index f034decc9..27e1131a8 100644
--- a/editor/Components/Elements/AssetBox.cs
+++ b/editor/Components/Elements/AssetBox.cs
@@ -59,6 +59,8 @@ public sealed class AssetBox : TemplatedControl {
 
 	private readonly MenuItem m_selectItem;
 
+	private Border? m_pickerButton;
+
 	private string? m_displayName;
 
 	private bool m_hasAsset;
@@ -175,10 +177,17 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
 	protected override void OnPointerPressed(PointerPressedEventArgs e) {
 		base.OnPointerPressed(e);
 		if (!IsEnabled || !e.GetCurrentPoint(this).Properties.IsLeftButtonPressed) return;
-		OpenPicker();
+		var onButton = m_pickerButton is { } button && new Rect(button.Bounds.Size).Contains(e.GetPosition(button));
+		if (HasAsset && !onButton) ShowInBrowser();
+		else OpenPicker();
 		e.Handled = true;
 	}
 
+	protected override void OnApplyTemplate(TemplateAppliedEventArgs e) {
+		base.OnApplyTemplate(e);
+		m_pickerButton = e.NameScope.Find<Border>("PART_Button");
+	}
+
 	protected override void OnPointerEntered(PointerEventArgs e) {
 		base.OnPointerEntered(e);
 		HookKeys();
@@ -278,7 +287,9 @@ private async void OpenPicker() {
 	}
 
 	private void ShowInBrowser() {
-		if (!string.IsNullOrEmpty(Value)) AssetBrowserViewModel.Current?.RevealAsset(Value!);
+		if (string.IsNullOrEmpty(Value)) return;
+		MainWindowViewModel.Current?.ShowAssetBrowser();
+		AssetBrowserViewModel.Current?.RevealAsset(Value!);
 	}
 
 	private void Clear() {
diff --git a/editor/Engine/ToastEngine.cs b/editor/Engine/ToastEngine.cs
index 29efb46f1..0321729cc 100644
--- a/editor/Engine/ToastEngine.cs
+++ b/editor/Engine/ToastEngine.cs
@@ -625,10 +625,10 @@ public static void TestHaptic(string tomlText) {
 	private static partial void toast_pop_application();
 
 	[LibraryImport(EngineLib, StringMarshalling = StringMarshalling.Utf8)]
-	private static partial void toast_bake_asset(string uid, string outPath);
+	private static partial int toast_bake_asset(string uid, string outPath);
 
-	public static void BakeAsset(string uid, string outPath) {
-		if (IsEngineReady) toast_bake_asset(uid, outPath);
+	public static bool BakeAsset(string uid, string outPath) {
+		return IsEngineReady && toast_bake_asset(uid, outPath) != 0;
 	}
 
 	[LibraryImport(EngineLib, StringMarshalling = StringMarshalling.Utf8)]
diff --git a/editor/Git/GitLockGuard.cs b/editor/Git/GitLockGuard.cs
index 37d64c69e..48076ff69 100644
--- a/editor/Git/GitLockGuard.cs
+++ b/editor/Git/GitLockGuard.cs
@@ -8,15 +8,33 @@
 
 namespace editor.Git;
 
+public enum OpenLockKind {
+	None,
+	Mine,
+	Other
+}
+
+public readonly record struct OpenLockState(OpenLockKind Kind, string? Owner);
+
 public static class GitLockGuard {
 	private static GitService? Usable => GitService.Current is { IsAvailable: true, HasLfs: true } git ? git : null;
 
 	public static async Task LockOnOpenAsync(string realPath) {
-		if (Usable is not { } git) return;
-		if (git.GetLock(realPath) is not null || !git.IsLockable(realPath)) return;
+		await AcquireOnOpenAsync(realPath);
+	}
+
+	public static async Task<OpenLockState> AcquireOnOpenAsync(string realPath) {
+		if (Usable is not { } git || !git.IsLockable(realPath)) return default;
+
+		var held = git.GetLock(realPath);
+		if (held is null) {
+			var result = await git.LockAsync(realPath);
+			if (!result.Ok) Log.Warn($"Git: could not lock {Path.GetFileName(realPath)} on open ({result.Message})");
+			held = git.GetLock(realPath);
+		}
 
-		var result = await git.LockAsync(realPath);
-		if (!result.Ok) Log.Warn($"Git: could not lock {Path.GetFileName(realPath)} on open ({result.Message})");
+		if (held is null) return default;
+		return new OpenLockState(held.OwnedByMe ? OpenLockKind.Mine : OpenLockKind.Other, held.Owner);
 	}
 
 	public static async Task<LockedSaveChoice> CheckSaveAsync(string realPath) {
diff --git a/editor/Git/LockedFileModal.cs b/editor/Git/LockedFileModal.cs
index 6a18ff316..f946854dd 100644
--- a/editor/Git/LockedFileModal.cs
+++ b/editor/Git/LockedFileModal.cs
@@ -1,8 +1,4 @@
 using System.Threading.Tasks;
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Layout;
-using Avalonia.Media;
 using editor.Components.Modals;
 using Lucide.Avalonia;
 
@@ -15,71 +11,39 @@ public enum LockedSaveChoice {
 	SaveAs
 }
 
-public sealed class LockedFileModal : Window {
-	private LockedFileModal(string fileName, string owner) {
-		Title = "File locked";
-		Width = 480;
-		SizeToContent = SizeToContent.Height;
-		CanResize = false;
-		ShowInTaskbar = false;
-		WindowStartupLocation = WindowStartupLocation.CenterOwner;
-		Background = GitStatusStyle.Brush("Bg2");
-
-		var header = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 12 };
-		header.Children.Add(new LucideIcon {
-			Kind = LucideIconKind.Lock, Size = 28, StrokeWidth = 2.5,
-			Foreground = GitStatusStyle.Orange, VerticalAlignment = VerticalAlignment.Center
-		});
-		header.Children.Add(new TextBlock {
-			Text = $"This file is locked by {owner}",
-			FontSize = 16,
-			FontWeight = FontWeight.Bold,
-			VerticalAlignment = VerticalAlignment.Center,
-			TextWrapping = TextWrapping.Wrap,
-			MaxWidth = 380
-		});
-
-		var body = new TextBlock {
-			Text = $"{fileName} can't be saved while {owner} holds the lock. " +
-			       "Save your work as a new file, throw your changes away, or cancel and keep editing.",
-			Foreground = GitStatusStyle.Brush("TextMuted"),
-			TextWrapping = TextWrapping.Wrap
-		};
-
-		var buttons = new StackPanel {
-			Orientation = Orientation.Horizontal, Spacing = 8, HorizontalAlignment = HorizontalAlignment.Right
-		};
-		buttons.Children.Add(MakeButton("Cancel", null, null, LockedSaveChoice.Cancel));
-		buttons.Children.Add(MakeButton("Discard", LucideIconKind.Trash2, GitStatusStyle.Brush("Red"),
-			LockedSaveChoice.Discard));
-		buttons.Children.Add(MakeButton("Save As...", LucideIconKind.Save, null, LockedSaveChoice.SaveAs));
-
-		var root = new StackPanel { Spacing = 16, Margin = new Thickness(20) };
-		root.Children.Add(header);
-		root.Children.Add(body);
-		root.Children.Add(buttons);
-		Content = root;
+public static class LockedFileModal {
+	public static Task<LockedSaveChoice> ShowAsync(string fileName, string owner) {
+		return Show(new ModalConfig(
+			"File locked",
+			$"{fileName} is locked by {owner}.",
+			ModalButtons.OkNoCancel,
+			LucideIconKind.Lock,
+			OkLabel: "Save As",
+			NoLabel: "Discard",
+			OkIcon: LucideIconKind.Save,
+			NoIcon: LucideIconKind.Trash2), LockedSaveChoice.Discard, LockedSaveChoice.Cancel);
 	}
 
-	public static Task<LockedSaveChoice> ShowAsync(string fileName, string owner) {
-		var parent = ModalService.FindActiveWindow();
-		if (parent is null) return Task.FromResult(LockedSaveChoice.Cancel);
-		return new LockedFileModal(fileName, owner).ShowDialog<LockedSaveChoice>(parent);
+	public static Task<LockedSaveChoice> ShowOpenAsync(string fileName, string owner) {
+		return Show(new ModalConfig(
+			"File locked",
+			$"{fileName} is locked by {owner}.",
+			ModalButtons.OkNoCancel,
+			LucideIconKind.Lock,
+			OkLabel: "Save As",
+			NoLabel: "Open anyway",
+			OkIcon: LucideIconKind.Save,
+			NoIcon: LucideIconKind.FolderOpen), LockedSaveChoice.Proceed, LockedSaveChoice.Proceed);
 	}
 
-	private Button MakeButton(string text, LucideIconKind? icon, IBrush? iconBrush, LockedSaveChoice choice) {
-		var content = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6 };
-		if (icon is { } kind)
-			content.Children.Add(new LucideIcon { Kind = kind, Size = 14, StrokeWidth = 2.5, Foreground = iconBrush });
-		content.Children.Add(new TextBlock { Text = text });
+	private static async Task<LockedSaveChoice> Show(ModalConfig config, LockedSaveChoice no, LockedSaveChoice noWindow) {
+		var parent = ModalService.FindActiveWindow();
+		if (parent is null) return noWindow;
 
-		var button = new Button {
-			Content = content,
-			Background = GitStatusStyle.Brush("Bg4"),
-			CornerRadius = new CornerRadius(6),
-			Padding = new Thickness(14, 6)
+		return await new MessageModal(config).ShowDialog<bool?>(parent) switch {
+			true => LockedSaveChoice.SaveAs,
+			false => no,
+			_ => LockedSaveChoice.Cancel
 		};
-		button.Click += (_, _) => Close(choice);
-		return button;
 	}
 }
diff --git a/editor/VoxelEditor/VoxelEditorView.axaml b/editor/VoxelEditor/VoxelEditorView.axaml
index fb7611185..b7adb892d 100644
--- a/editor/VoxelEditor/VoxelEditorView.axaml
+++ b/editor/VoxelEditor/VoxelEditorView.axaml
@@ -15,7 +15,7 @@
 	      RowSpacing="8">
 		<!-- Top bar -->
 		<Grid Grid.Row="0"
-		      ColumnDefinitions="Auto,Auto,Auto,Auto,*,Auto,Auto,Auto,Auto"
+		      ColumnDefinitions="Auto,Auto,Auto,Auto,Auto,*,Auto,Auto,Auto,Auto"
 		      ColumnSpacing="8">
 			<StackPanel Grid.Column="0"
 			            Orientation="Horizontal">
@@ -120,11 +120,17 @@
 					<LucideIcon Kind="SquareDashed" Size="18" StrokeWidth="2.5" />
 				</ToggleButton>
 				<ToggleButton Classes="snapTool"
-				              CornerRadius="0,6,6,0"
+				              CornerRadius="0"
 				              ToolTip.Tip="Hammer View (Z)"
 				              IsChecked="{Binding FourUp}">
 					<LucideIcon Kind="LayoutGrid" Size="18" StrokeWidth="2.5" />
 				</ToggleButton>
+				<ToggleButton Classes="snapTool"
+				              CornerRadius="0,6,6,0"
+				              ToolTip.Tip="Snap to unit"
+				              IsChecked="{Binding SnapToUnit}">
+					<LucideIcon Kind="Magnet" Size="18" StrokeWidth="2.5" />
+				</ToggleButton>
 			</StackPanel>
 
 			<StackPanel Grid.Column="2"
@@ -158,10 +164,30 @@
 				</ToggleButton>
 			</StackPanel>
 
+			<StackPanel Grid.Column="3"
+			            Orientation="Horizontal">
+				<ToggleButton Classes="tool red camMode"
+				              CornerRadius="6,0,0,6"
+				              ToolTip.Tip="Free camera"
+				              Command="{Binding Workspace.SetEditorCameraModeCommand}"
+				              CommandParameter="Free"
+				              IsChecked="{Binding Workspace.CameraMode, Converter={StaticResource EnumEqualsConverter}, ConverterParameter=Free, Mode=OneWay}">
+					<LucideIcon Kind="Camera" Size="18" StrokeWidth="2.5" />
+				</ToggleButton>
+				<ToggleButton Classes="tool red camMode"
+				              CornerRadius="0,6,6,0"
+				              ToolTip.Tip="Orbit camera"
+				              Command="{Binding Workspace.SetEditorCameraModeCommand}"
+				              CommandParameter="Orbit"
+				              IsChecked="{Binding Workspace.CameraMode, Converter={StaticResource EnumEqualsConverter}, ConverterParameter=Orbit, Mode=OneWay}">
+					<LucideIcon Kind="Rotate3d" Size="18" StrokeWidth="2.5" />
+				</ToggleButton>
+			</StackPanel>
+
 			<ve:VoxelPalettePicker x:Name="PalettePicker"
-			                       Grid.Column="3" />
+			                       Grid.Column="4" />
 
-			<StackPanel Grid.Column="4"
+			<StackPanel Grid.Column="5"
 			            Orientation="Horizontal"
 			            Spacing="8"
 			            HorizontalAlignment="Right">
@@ -189,7 +215,7 @@
 				</Button>
 			</StackPanel>
 
-			<StackPanel Grid.Column="5"
+			<StackPanel Grid.Column="6"
 			            Orientation="Horizontal"
 			            Spacing="6"
 			            ToolTip.Tip="Script">
@@ -201,7 +227,7 @@
 				                   Value="{Binding DefaultScript, Mode=TwoWay}" />
 			</StackPanel>
 
-			<StackPanel Grid.Column="6"
+			<StackPanel Grid.Column="7"
 			            Orientation="Horizontal"
 			            Spacing="6"
 			            ToolTip.Tip="Fill mode new volumes get">
@@ -213,7 +239,7 @@
 				                  Options="{x:Static ve:VoxelEditorViewModel.FillModes}" />
 			</StackPanel>
 
-			<Button Grid.Column="7"
+			<Button Grid.Column="8"
 			        Classes="chev"
 			        CornerRadius="6"
 			        Command="{Binding BakeCommand}"
@@ -226,7 +252,7 @@
 				</StackPanel>
 			</Button>
 
-			<Button Grid.Column="8"
+			<Button Grid.Column="9"
 			        Classes="chev"
 			        CornerRadius="6"
 			        Command="{Binding SaveCommand}"
diff --git a/editor/VoxelEditor/VoxelEditorViewModel.cs b/editor/VoxelEditor/VoxelEditorViewModel.cs
index c49394720..ad74ee224 100644
--- a/editor/VoxelEditor/VoxelEditorViewModel.cs
+++ b/editor/VoxelEditor/VoxelEditorViewModel.cs
@@ -49,7 +49,8 @@ public partial class VoxelEditorViewModel : ObservableObject, IDisposable {
 	// Snapping in the VoxelEditor is always one voxel and a right angle
 	public const double VoxelSize = 0.1;
 	public const double RightAngle = 90.0;
-
+	public const int UnitVoxels = 10;
+	public const double UnitSize = VoxelSize * UnitVoxels;
 	public const string DrawBoxScript = "core://voxel_scripts/draw_box.lua";
 
 	private static ulong s_nextTransaction = 1 << 20;
@@ -68,6 +69,7 @@ public partial class VoxelEditorViewModel : ObservableObject, IDisposable {
 	[ObservableProperty] private bool m_showEdges;
 	[ObservableProperty] private bool m_fourUp;
 	[ObservableProperty] private bool m_showOthers;
+	[ObservableProperty] private bool m_snapToUnit;
 	[ObservableProperty] private int m_paletteId = 1;
 	[ObservableProperty] private string? m_defaultScript;
 	[ObservableProperty] private string m_defaultFillModeName = "Replace";
@@ -563,11 +565,19 @@ private void SendViewState() {
 		SendOverlays();
 		SendShowOthers();
 		Events.Send(new SetCoordinateSpace { World = false });
-		Events.Send(new SetSnapping { Kind = 0, Enabled = true, Value = (float)VoxelSize });
+		SendTranslateSnap();
 		Events.Send(new SetSnapping { Kind = 1, Enabled = true, Value = (float)RightAngle });
 		Events.Send(new SetSnapping { Kind = 2, Enabled = false, Value = (float)VoxelSize });
 	}
 
+	private void SendTranslateSnap() {
+		Events.Send(new SetSnapping { Kind = 0, Enabled = true, Value = (float)(SnapToUnit ? UnitSize : VoxelSize) });
+	}
+
+	partial void OnSnapToUnitChanged(bool value) {
+		if (OwnsEngine) SendTranslateSnap();
+	}
+
 	private void SendShowOthers() {
 		Events.Send(new SetShowOthers {
 			Show = ShowOthers && CanShowOthers,
diff --git a/editor/VoxelEditor/VoxelOrthoView.cs b/editor/VoxelEditor/VoxelOrthoView.cs
index 014f6cfde..cf871ba63 100644
--- a/editor/VoxelEditor/VoxelOrthoView.cs
+++ b/editor/VoxelEditor/VoxelOrthoView.cs
@@ -467,11 +467,12 @@ protected override void OnPointerPressed(PointerPressedEventArgs e) {
 		switch (editor.ActiveTool) {
 			case VoxelTool.Buildup or VoxelTool.Carve or VoxelTool.Paint:
 				m_drag = Drag.Box;
-				m_dragBox = (cell.Item1, cell.Item2, cell.Item1, cell.Item2);
+				m_dragBox = SnapBox(cell.Item1, cell.Item2, cell.Item1, cell.Item2);
 				break;
 			case VoxelTool.Split or VoxelTool.Slice:
 				m_drag = Drag.Cut;
-				m_cutLine = (point.Position, point.Position);
+				var cutStart = SnapPoint(point.Position);
+				m_cutLine = (cutStart, cutStart);
 				break;
 			case VoxelTool.Bucket:
 				BucketAt(editor, cell);
@@ -484,6 +485,27 @@ protected override void OnPointerPressed(PointerPressedEventArgs e) {
 		InvalidateVisual();
 	}
 
+	private int SnapStep => m_editor is { SnapToUnit: true } ? VoxelEditorViewModel.UnitVoxels : 1;
+
+	private int SnapEdge(int boundary) {
+		var step = SnapStep;
+		return step > 1 ? (int)Math.Round(boundary / (double)step) * step : boundary;
+	}
+
+	private (int H0, int V0, int H1, int V1) SnapBox(int h0, int v0, int h1, int v1) {
+		var step = SnapStep;
+		int Lo(int x) => step > 1 ? (int)Math.Floor(x / (double)step) * step : x;
+		int Hi(int x) => step > 1 ? ((int)Math.Floor(x / (double)step) + 1) * step - 1 : x;
+		return (Lo(Math.Min(h0, h1)), Lo(Math.Min(v0, v1)), Hi(Math.Max(h0, h1)), Hi(Math.Max(v0, v1)));
+	}
+
+	private Point SnapPoint(Point at) {
+		var step = SnapStep;
+		if (step <= 1) return at;
+		var (h, v) = ToVoxel(at);
+		return ToScreen(Math.Round(h / step) * step, Math.Round(v / step) * step);
+	}
+
 	private void StartSelectOrHandle(VoxelEditorViewModel editor, Point at, (int H, int V) cell) {
 		if (editor.SelectedPiece is { } selected) {
 			var rect = RectOf(selected);
@@ -544,14 +566,14 @@ protected override void OnPointerMoved(PointerEventArgs e) {
 			case Drag.Box: {
 				var (h, v) = ToVoxel(at);
 				var (h0, v0) = ToVoxel(m_pressed);
-				m_dragBox = (Math.Min((int)Math.Floor(h0), (int)Math.Floor(h)), Math.Min((int)Math.Floor(v0), (int)Math.Floor(v)),
-					Math.Max((int)Math.Floor(h0), (int)Math.Floor(h)), Math.Max((int)Math.Floor(v0), (int)Math.Floor(v)));
+				m_dragBox = SnapBox((int)Math.Floor(h0), (int)Math.Floor(v0), (int)Math.Floor(h), (int)Math.Floor(v));
 				break;
 			}
 			case Drag.Cut when m_cutLine is { } line:
-				m_cutLine = (line.A, at);
-				if (m_editor.ActiveTool is VoxelTool.Split or VoxelTool.Slice && Distance(line.A, at) > 4)
-					editor.PreviewCut(CutPlane(line.A, at));
+				var cutEnd = SnapPoint(at);
+				m_cutLine = (line.A, cutEnd);
+				if (m_editor.ActiveTool is VoxelTool.Split or VoxelTool.Slice && Distance(line.A, cutEnd) > 4)
+					editor.PreviewCut(CutPlane(line.A, cutEnd));
 				break;
 			case Drag.Move or Drag.EdgeMinH or Drag.EdgeMaxH or Drag.EdgeMinV or Drag.EdgeMaxV or Drag.Extrude
 				when m_dragPiece is { } piece:
@@ -570,19 +592,21 @@ private void UpdatePieceDrag(VoxelEditorViewModel editor, VoxelPieceInfo piece,
 		var dh = (int)Math.Round(h - ph);
 		var dv = (int)Math.Round(v - pv);
 		var (h0, v0, h1, v1) = BoxOf(piece);
+		var moveH = SnapEdge(h0 + dh) - h0;
+		var moveV = SnapEdge(v0 + dv) - v0;
 
 		var box = m_drag switch {
-			Drag.Move => (h0 + dh, v0 + dv, h1 + dh, v1 + dv),
-			Drag.EdgeMinH => (Math.Min(h0 + dh, h1), v0, h1, v1),
-			Drag.EdgeMaxH => (h0, v0, Math.Max(h1 + dh, h0), v1),
-			Drag.EdgeMinV => (h0, Math.Min(v0 + dv, v1), h1, v1),
-			Drag.EdgeMaxV => (h0, v0, h1, Math.Max(v1 + dv, v0)),
+			Drag.Move => (h0 + moveH, v0 + moveV, h1 + moveH, v1 + moveV),
+			Drag.EdgeMinH => (Math.Min(SnapEdge(h0 + dh), h1), v0, h1, v1),
+			Drag.EdgeMaxH => (h0, v0, Math.Max(SnapEdge(h1 + 1 + dh) - 1, h0), v1),
+			Drag.EdgeMinV => (h0, Math.Min(SnapEdge(v0 + dv), v1), h1, v1),
+			Drag.EdgeMaxV => (h0, v0, h1, Math.Max(SnapEdge(v1 + 1 + dv) - 1, v0)),
 			// Extrude grows a new box off the edge it was pulled from
 			Drag.Extrude => m_extrudeEdge switch {
-				0 => (h0 + Math.Min(dh, -1), v0, h0 - 1, v1),
-				1 => (h1 + 1, v0, h1 + Math.Max(dh, 1), v1),
-				2 => (h0, v0 + Math.Min(dv, -1), h1, v0 - 1),
-				_ => (h0, v1 + 1, h1, v1 + Math.Max(dv, 1))
+				0 => (Math.Min(SnapEdge(h0 + dh), h0 - 1), v0, h0 - 1, v1),
+				1 => (h1 + 1, v0, Math.Max(SnapEdge(h1 + 1 + dh) - 1, h1 + 1), v1),
+				2 => (h0, Math.Min(SnapEdge(v0 + dv), v0 - 1), h1, v0 - 1),
+				_ => (h0, v1 + 1, h1, Math.Max(SnapEdge(v1 + 1 + dv) - 1, v1 + 1))
 			},
 			_ => m_dragBox
 		};
diff --git a/editor/Workspace/MainWindowViewModel.cs b/editor/Workspace/MainWindowViewModel.cs
index 440c86f18..c413201d1 100644
--- a/editor/Workspace/MainWindowViewModel.cs
+++ b/editor/Workspace/MainWindowViewModel.cs
@@ -405,7 +405,8 @@ private async void OnEditorOpenRequested(AssetFile file) {
 		if (!AssetDatabase.TryResolve(uid, out var virtualPath, out _)) return;
 
 		// Opening a lockable asset nobody holds takes its lock
-		if (def is not ProjectSettingsAsset) await GitLockGuard.LockOnOpenAsync(ProjectContext.Resolve(virtualPath));
+		if (def is not ProjectSettingsAsset && def.EditorTool != "NodeEditor")
+			await GitLockGuard.LockOnOpenAsync(ProjectContext.Resolve(virtualPath));
 
 		var recoverPath = await AutosaveService.TryRecoverAsync(uid, virtualPath);
 
@@ -452,9 +453,10 @@ private async void OnEditorOpenRequested(AssetFile file) {
 		}
 	}
 
-	private async Task OpenWorkspaceFile(string uid, string virtualPath, string? recoverPath) {
+	private async Task OpenWorkspaceFile(string uid, string virtualPath, string? recoverPath, bool takeLock = true) {
 		var recoverVirtual = recoverPath is null ? null : ProjectContext.ToVirtual(recoverPath);
 
+		WorkspaceViewModel? opened = null;
 		LoadingPopup? popup = null;
 		if (App.MainWindow is { } owner) {
 			popup = new LoadingPopup($"Loading {Path.GetFileName(virtualPath)}");
@@ -462,15 +464,33 @@ private async Task OpenWorkspaceFile(string uid, string virtualPath, string? rec
 			await Avalonia.Threading.Dispatcher.UIThread.InvokeAsync(() => { }, Avalonia.Threading.DispatcherPriority.Render);
 		}
 
+		var lockTask = takeLock
+			? GitLockGuard.AcquireOnOpenAsync(ProjectContext.Resolve(virtualPath))
+			: Task.FromResult(default(OpenLockState));
+
 		try {
 			var ws = await WorkspaceViewModel.OpenFileAsync(m_toast, uid, virtualPath, recoverVirtual);
 			if (ws is null) return;
 			m_workspaces[ws.Handle] = m_dockFactory.AddWorkspace(ws);
 			SyncActiveWorkspace();
 			if (popup is not null) await WaitForEngineAsync(ws);
+			opened = ws;
 		} finally {
 			popup?.Close();
 		}
+
+		var held = await lockTask;
+		if (opened is null || held.Kind != OpenLockKind.Other) return;
+
+		switch (await LockedFileModal.ShowOpenAsync(Path.GetFileName(virtualPath), held.Owner ?? "someone else")) {
+			case LockedSaveChoice.Cancel:
+				opened.PendingClose = true; // skip the unsaved changes prompt
+				m_dockFactory.CloseDockable(opened);
+				break;
+			case LockedSaveChoice.SaveAs:
+				await opened.SaveAs();
+				break;
+		}
 	}
 
 	private async Task WaitForEngineAsync(WorkspaceViewModel ws) {
@@ -548,6 +568,13 @@ public void ShowToastZone(bool active) {
 		ToastZoneActive = active;
 	}
 
+	public void ShowAssetBrowser() {
+		if (m_toastZoneFactory.AssetBrowserVm is { } browser) m_toastZoneFactory.ShowTool(browser);
+		if (ToastZoneActive) return;
+		m_toastZonePinned = true;
+		ToastZoneActive = true;
+	}
+
 	public void PinToastZone() {
 		m_toastZonePinned = !m_toastZonePinned;
 		ToastZoneActive = m_toastZonePinned;
@@ -816,7 +843,6 @@ private async Task OpenNodeFile() {
 
 		if (!AssetDatabase.TryResolve(uid, out var virtualPath, out _)) return;
 
-		await GitLockGuard.LockOnOpenAsync(ProjectContext.Resolve(virtualPath));
 		var recoverPath = await AutosaveService.TryRecoverAsync(uid, virtualPath);
 		await OpenWorkspaceFile(uid, virtualPath, recoverPath);
 	}
@@ -829,7 +855,7 @@ public void ReopenWorkspaceFromDisk(WorkspaceViewModel workspace) {
 		Avalonia.Threading.Dispatcher.UIThread.Post(() => {
 			workspace.PendingClose = true; // skip the unsaved changes prompt
 			m_dockFactory.CloseDockable(workspace);
-			OpenWorkspaceFile(uid, virtualPath, null);
+			_ = OpenWorkspaceFile(uid, virtualPath, null, takeLock: false);
 		});
 	}
 
@@ -1145,6 +1171,7 @@ await Task.Run(() => {
 					var dest = Path.Combine(stageDir, rel);
 					Directory.CreateDirectory(Path.GetDirectoryName(dest)!);
 					File.Copy(srcFile, dest, true);
+										File.SetAttributes(dest, File.GetAttributes(dest) & ~FileAttributes.ReadOnly);
 				}
 			});
 
@@ -1162,7 +1189,8 @@ await Task.Run(() => {
 						var dest = Path.Combine(stageDir, rel.Replace('/', Path.DirectorySeparatorChar));
 						Directory.CreateDirectory(Path.GetDirectoryName(dest)!);
 						log($"    bake {rel}");
-						await Task.Run(() => ToastEngine.BakeAsset(uid, dest));
+						if (!await Task.Run(() => ToastEngine.BakeAsset(uid, dest)))
+							throw new Exception($"could not bake node {virtualPath}");
 					}
 			}
 
diff --git a/editor/Workspace/WorkspaceViewModel.cs b/editor/Workspace/WorkspaceViewModel.cs
index 5eb5a8b79..19d497c0e 100644
--- a/editor/Workspace/WorkspaceViewModel.cs
+++ b/editor/Workspace/WorkspaceViewModel.cs
@@ -547,14 +547,14 @@ public async Task<bool> ConfirmCloseAsync() {
 	public async Task<bool> Save(bool closing = false) {
 		if (RootUid is null) return false;
 
-		if (BackingUri is null) return await SaveAs(); // no path yet -> prompt the user
+		if (BackingUri is null) return await SaveAs(closing); // no path yet -> prompt the user
 
 		// Takes the lock on a lockable file or stops when someone else holds it
 		switch (await GitLockGuard.CheckSaveAsync(ProjectContext.Resolve(BackingUri))) {
 			case LockedSaveChoice.Cancel:
 				return false;
 			case LockedSaveChoice.SaveAs:
-				return await SaveAs();
+				return await SaveAs(closing);
 			case LockedSaveChoice.Discard:
 				DeleteAutosaves();
 				// When the tab is being closed anyway there is nothing to reload
@@ -569,7 +569,7 @@ public async Task<bool> Save(bool closing = false) {
 		return true;
 	}
 
-	public async Task<bool> SaveAs() {
+	public async Task<bool> SaveAs(bool closing = false) {
 		if (RootUid is null) return false;
 
 		var virtualPath = await App.Modals.ShowSaveFile(Title ?? "Unnamed Node");
@@ -595,6 +595,7 @@ public async Task<bool> SaveAs() {
 		DeleteAutosaves();
 		ProjectContext.RaiseAssetsChanged();
 		await GitLockGuard.LockOnOpenAsync(realPath); // Saving takes the lock
+		if (!closing) MainWindowViewModel.Current?.ReopenWorkspaceFromDisk(this);
 		return true;
 	}
 
diff --git a/engine/ffi/engine.h b/engine/ffi/engine.h
index 62d10a967..1901819aa 100644
--- a/engine/ffi/engine.h
+++ b/engine/ffi/engine.h
@@ -80,7 +80,7 @@ TOAST_C_API void toast_pop_application(void) NOEXCEPT;
  * @param uid 11-character UID string of the node asset
  * @param out_path Absolute filesystem path to write the binary .tnode to
  */
-TOAST_C_API void toast_bake_asset(const char* uid, const char* out_path) NOEXCEPT;
+TOAST_C_API int toast_bake_asset(const char* uid, const char* out_path) NOEXCEPT;
 
 /**
  * @brief Regenerates the schema's lua files
diff --git a/engine/src/toast/engine.cpp b/engine/src/toast/engine.cpp
index e51501530..6ab7dc87b 100644
--- a/engine/src/toast/engine.cpp
+++ b/engine/src/toast/engine.cpp
@@ -1290,32 +1290,41 @@ void toast_pop_application() noexcept {
 	toast::Engine::get()->popApplication();
 }
 
-void toast_bake_asset(const char* uid_str, const char* out_path) noexcept {
+auto toast_bake_asset(const char* uid_str, const char* out_path) noexcept -> int {
 	ZoneScoped;
 	if (!uid_str || !out_path) {
-		return;
+		return 0;
 	}
 	try {
 		const toast::UID uid(toast::UID::fromString(uid_str));
+		std::vector<uint8_t> bytes;
+
 		auto* asset = assets::AssetManager::get().load(uid);
-		if (!asset) {
-			TOAST_ERROR("Engine", "toast_bake_asset: could not load asset {}", uid_str);
-			return;
-		}
-		auto* prefab = dynamic_cast<assets::Prefab*>(asset);
-		if (!prefab) {
-			TOAST_WARN("Engine", "toast_bake_asset: asset {} is not a Prefab, skipping", uid_str);
-			return;
+		if (auto* prefab = dynamic_cast<assets::Prefab*>(asset)) {
+			bytes = prefab->serialize(assets::SaveMode::game);
+		} else {
+			TOAST_WARN("Editor", "toast_bake_asset: could not load node {}, baking the staged file instead", uid_str);
+			std::ifstream in(out_path, std::ios::binary);
+			if (!in.is_open()) {
+				TOAST_ERROR("Editor", "toast_bake_asset: cannot read staged file {}", out_path);
+				return 0;
+			}
+			const std::string text {std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>()};
+			in.close();
+			std::istringstream stream {text};
+			bytes = assets::Prefab(stream).serialize(assets::SaveMode::game);
 		}
-		const auto bytes = prefab->serialize(assets::SaveMode::game);
+
 		std::ofstream out(out_path, std::ios::binary | std::ios::trunc);
 		if (!out.is_open()) {
-			TOAST_ERROR("Engine", "toast_bake_asset: cannot open output path {}", out_path);
-			return;
+			TOAST_ERROR("Editor", "toast_bake_asset: cannot open output path {}", out_path);
+			return 0;
 		}
 		out.write(reinterpret_cast<const char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
-		TOAST_TRACE("Engine", "Baked asset {} → {}", uid_str, out_path);
-	} catch (const std::exception& e) { TOAST_ERROR("Engine", "toast_bake_asset: {}", e.what()); }
+		TOAST_TRACE("Editor", "Baked asset {} → {}", uid_str, out_path);
+		return out.good() ? 1 : 0;
+	} catch (const std::exception& e) { TOAST_ERROR("Editor", "toast_bake_asset: {}", e.what()); }
+	return 0;
 }
 
 auto toast_generate_data_schema_stubs(const char* out_path) noexcept -> int {
diff --git a/engine/src/toast/world/workspace.cpp b/engine/src/toast/world/workspace.cpp
index 937e94355..1d22172a4 100644
--- a/engine/src/toast/world/workspace.cpp
+++ b/engine/src/toast/world/workspace.cpp
@@ -1169,7 +1169,12 @@ void Workspace::gizmoApplySizeDrag(float delta) {
 	// Volumes grow a whole voxel at a time and the negative faces move the corner
 	if (auto volume = m_focused_node.as<VoxelVolume>(); volume.exists()) {
 		const int32_t start = static_cast<int32_t>(m_gizmo_drag_start_size[axis]);
-		const int32_t next = std::max(start + static_cast<int32_t>(std::lround(delta * sign / voxel::k_voxel_size)), 1);
+		int32_t step = 1;
+		if (m_translate_snap.enabled && m_translate_snap.value > 0.0001f) {
+			step = std::max<int32_t>(1, static_cast<int32_t>(std::lround(m_translate_snap.value / voxel::k_voxel_size)));
+		}
+		const auto grown = static_cast<int32_t>(std::lround(delta * sign / (voxel::k_voxel_size * static_cast<float>(step)))) * step;
+		const int32_t next = std::max(start + grown, 1);
 		glm::ivec3 size = volume->sizeVoxels();
 		size[axis] = next;
 		volume->setSizeVoxels(size);
@@ -1888,7 +1893,8 @@ void Workspace::eventSubscriptions() {
 			m_history->commit();
 		}
 		const UID saved_uid = assets::AssetManager::resolveURI(e.uri).value_or(node == m_root_node ? m_handle : UID(0));
-		assets::Prefab prefab(*node, saved_uid);
+		const UID origin = node == m_root_node ? node->m_source_prefab.uid() : UID(0);
+		assets::Prefab prefab(*node, origin.data() != 0 ? origin : saved_uid);
 		auto bytes = prefab.serialize(assets::SaveMode::editor);
 		completed.success = assets::AssetManager::get().saveBytes(e.uri, bytes);
 		if (completed.success) {
diff --git a/engine/src/toast/world/workspace.hpp b/engine/src/toast/world/workspace.hpp
index b6c268cfa..5e84bd511 100644
--- a/engine/src/toast/world/workspace.hpp
+++ b/engine/src/toast/world/workspace.hpp
@@ -222,6 +222,8 @@ class TOAST_API Workspace : public INodeOwner {
 		float plane = 0.0f;          ///< Where along axis the mouse ray is cut to find the rectangle
 		int32_t sign = 1;            ///< Which way is out of the face
 		int32_t depth = 1;
+		int32_t snap_plane = 1;
+		int32_t snap_depth = 1;
 		glm::ivec3 anchor {0};
 		glm::ivec3 current {0};
 		glm::ivec3 face_min {std::numeric_limits<int32_t>::min()};    ///< Extrude keeps the footprint on its face
diff --git a/engine/src/toast/world/workspace_voxel.cpp b/engine/src/toast/world/workspace_voxel.cpp
index 0e1726399..a05a36f7f 100644
--- a/engine/src/toast/world/workspace_voxel.cpp
+++ b/engine/src/toast/world/workspace_voxel.cpp
@@ -218,6 +218,15 @@ auto Workspace::voxelToolShape() -> ProceduralVoxel* {
 auto Workspace::VoxelToolState::box() const -> std::pair<glm::ivec3, glm::ivec3> {
 	glm::ivec3 min = glm::min(anchor, current);
 	glm::ivec3 max = glm::max(anchor, current);
+	if (snap_plane > 1) {
+		for (int a = 0; a < 3; ++a) {
+			if (a == axis) {
+				continue;
+			}
+			min[a] = static_cast<int32_t>(std::floor(static_cast<double>(min[a]) / snap_plane)) * snap_plane;
+			max[a] = ((static_cast<int32_t>(std::floor(static_cast<double>(max[a]) / snap_plane)) + 1) * snap_plane) - 1;
+		}
+	}
 	const int32_t first = depth > 0 ? surface + sign : surface;
 	const int32_t last = depth > 0 ? first + (sign * (depth - 1)) : first - (sign * (-depth - 1));
 	min[axis] = std::min(first, last);
@@ -257,6 +266,15 @@ auto Workspace::voxelWrapInGroup(Box<Node> node, std::string_view name) -> Box<N
 
 namespace {
 
+template<typename S>
+[[nodiscard]]
+auto voxelSnapStep(const S& snap) -> int32_t {
+	if (!snap.enabled || snap.value <= 0.0001f) {
+		return 1;
+	}
+	return std::max<int32_t>(1, static_cast<int32_t>(std::lround(snap.value / voxel::k_voxel_size)));
+}
+
 struct BoxEntry {
 	glm::vec3 point;
 	int axis = 0;
@@ -369,6 +387,8 @@ void Workspace::voxelToolMouseMove() {
 		}
 
 		tool.phase = VoxelToolState::Phase::face;
+		tool.snap_plane = 1;
+		tool.snap_depth = voxelSnapStep(m_translate_snap);
 		tool.extrude_source = piece->uid();
 		tool.axis = entry->axis;
 		tool.sign = entry->sign;
@@ -443,14 +463,15 @@ void Workspace::voxelToolMouseMove() {
 		const float denominator = c - (b * b);
 		if (std::abs(denominator) > 1e-6f) {
 			const float along = ((b * glm::dot(local.direction, w)) - (c * glm::dot(line, w))) / denominator;
-			const auto layers = static_cast<int32_t>(std::lround(along));
+			const int32_t step = tool.snap_depth;
+			const auto layers = static_cast<int32_t>(std::lround(along / static_cast<float>(step))) * step;
 			if (tool.tool == k_tool_extrude) {
 				// Pulling out grows a new box, pushing in carves one
-				tool.depth = layers >= 0 ? std::max(1, layers) : std::min(-1, layers);
+				tool.depth = layers >= 0 ? std::max(step, layers) : std::min(-step, layers);
 			} else if (tool.tool == k_tool_buildup) {
-				tool.depth = std::max(1, layers);
+				tool.depth = std::max(step, layers);
 			} else {
-				tool.depth = std::min(-1, layers);
+				tool.depth = std::min(-step, layers);
 			}
 		}
 	}
@@ -679,8 +700,10 @@ auto Workspace::voxelToolMouseButton(uint32_t button, bool pressed, int mods) ->
 		m_voxel_tool.plane = 0.0f;
 		m_voxel_tool.anchor = *ground;
 	}
+	m_voxel_tool.snap_plane = voxelSnapStep(m_translate_snap);
+	m_voxel_tool.snap_depth = m_voxel_tool.snap_plane;
 	m_voxel_tool.current = m_voxel_tool.anchor;
-	m_voxel_tool.depth = tool == k_tool_buildup ? 1 : -1;
+	m_voxel_tool.depth = (tool == k_tool_buildup ? 1 : -1) * m_voxel_tool.snap_depth;
 	m_voxel_tool.dragging = true;
 	m_voxel_tool.phase = VoxelToolState::Phase::box;