add Engine which clones papermario-dx inside the BuildEnvironment

src/main/java/app/BuildOutputDialog.java

···
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Frame;
+import java.io.File;
 import java.io.IOException;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
···
 import javax.swing.WindowConstants;
 import javax.swing.text.DefaultCaret;
 
-import app.build.BuildEnvironment;
-import app.build.BuildException;
-import app.build.BuildOutputListener;
-import app.build.BuildResult;
-import app.build.NixEnvironment;
-import app.build.WslNixOsEnvironment;
+import project.engine.BuildEnvironment;
+import project.engine.BuildException;
+import project.engine.BuildOutputListener;
+import project.engine.BuildResult;
 import net.miginfocom.swing.MigLayout;
 
 /**
···
 
 		// Create build environment on background thread
 		Environment.getExecutor().submit(() -> {
-			try {
-				if (Environment.isWindows()) {
-					buildEnv = new WslNixOsEnvironment();
-				}
-				else {
-					buildEnv = new NixEnvironment();
-				}
-
-				try {
-					buildEnv.configure(getOutputListener());
-				}
-				catch (IOException | BuildException e) {
-					SwingUtilities.invokeLater(() -> {
-						appendOutput("Configuration error: " + e.getMessage(), true);
-						handleBuildError(e);
-					});
-					return;
-				}
+			File projectDir = Environment.getProject().getDirectory();
+			buildEnv = Environment.getProject().getEngine().getBuildEnvironment();
 
-				buildEnv.buildAsync(getOutputListener()).thenAccept(result -> {
-					SwingUtilities.invokeLater(() -> handleBuildComplete(result));
-				}).exceptionally(ex -> {
-					SwingUtilities.invokeLater(() -> handleBuildError(ex));
-					return null;
-				});
+			try {
+				buildEnv.configure(projectDir, getOutputListener());
 			}
-			catch (BuildException e) {
+			catch (IOException | BuildException e) {
 				SwingUtilities.invokeLater(() -> {
-					if (!e.isSilent()) {
-						appendOutput("Build environment error: " + e.getMessage(), true);
-						handleBuildError(e);
-					}
-					else {
-						appendOutput(e.getMessage(), false);
-						handleBuildComplete(BuildResult.cancelled(java.time.Duration.ZERO));
-					}
+					appendOutput("Configuration error: " + e.getMessage(), true);
+					handleBuildError(e);
 				});
+				return;
 			}
+
+			buildEnv.buildAsync(projectDir, getOutputListener()).thenAccept(result -> {
+				SwingUtilities.invokeLater(() -> handleBuildComplete(result));
+			}).exceptionally(ex -> {
+				SwingUtilities.invokeLater(() -> handleBuildError(ex));
+				return null;
+			});
 		});
 	}
 

src/main/java/app/Directories.java

···
 
 	PROJ_STAR_ROD		(Root.PROJECT,					"/.starrod/"),
 	PROJ_CFG			(Root.PROJECT, PROJ_STAR_ROD,		"/cfg/"),
-	PROJ_THUMBNAIL		(Root.PROJECT,						"/thumbnail/"),
-	PROJ_SRC			(Root.PROJECT,					"/src/"),
-	PROJ_SRC_WORLD		(Root.PROJECT, PROJ_SRC,			"/world/"),
-	PROJ_SRC_STAGE		(Root.PROJECT, PROJ_SRC,			"/battle/common/stage/"),
-	PROJ_INCLUDE		(Root.PROJECT,					"/include/"),
-	PROJ_INCLUDE_MAPFS	(Root.PROJECT, PROJ_INCLUDE,		"/mapfs/");
+	PROJ_THUMBNAIL		(Root.PROJECT, PROJ_STAR_ROD,		"/thumbnail/"),
+
+	//=======================================================================================
+	// Directories relative to the current project's engine (papermario-dx)
+
+	ENGINE_SRC			(Root.ENGINE,					"/src/"),
+	ENGINE_SRC_WORLD		(Root.ENGINE, ENGINE_SRC,			"/world/"),
+	ENGINE_SRC_STAGE		(Root.ENGINE, ENGINE_SRC,			"/battle/common/stage/"),
+	ENGINE_INCLUDE		(Root.ENGINE,			 		"/include/"),
+	ENGINE_INCLUDE_MAPFS	(Root.ENGINE, ENGINE_INCLUDE,		"/mapfs/"),
+	ENGINE_ASSETS_US	(Root.ENGINE, 					"/assets/us/");
 
 	// @formatter:on
 	//=======================================================================================
···
 
 	private enum Root
 	{
-		NONE, DUMP, PROJECT, CONFIG, STATE
+		NONE, DUMP, PROJECT, CONFIG, STATE, ENGINE
 	}
 
 	private static String getRootPath(Root root)
···
 				return Environment.getUserConfigDir().getAbsolutePath();
 			case STATE:
 				return Environment.getUserStateDir().getAbsolutePath();
+			case ENGINE:
+				return Environment.getProject().getEngine().getDirectory().getAbsolutePath();
 
 		}
 		return null;

src/main/java/app/Environment.java

···
 import app.config.Options.Scope;
 import app.input.IOUtils;
 import project.Project;
+import project.ProjectListing;
 import project.ProjectManager;
 import project.Manifest;
 import project.ui.ProjectSwitcherDialog;
···
 import game.entity.EntityExtractor;
 import game.map.editor.ui.dialogs.ChooseDialogResult;
 import game.map.editor.ui.dialogs.DirChooser;
+import game.map.editor.ui.dialogs.OpenFileChooser;
 import game.message.font.FontManager;
 import util.Logger;
 import util.Priority;
···
 	private static File codeSource;
 
 	public static Config mainConfig = null;
-	public static Config projectConfig = null;
 
 	private static Project project = null;
 
···
 			}
 
 			try {
-				Project project = chooseProject();
-				if (project == null)
+				ProjectListing listing = chooseProject();
+				if (listing == null)
 					exit();
-				LoadingBar.show("Loading " + project.getName(), true);
-				boolean validProject = loadProject(project);
+				LoadingBar.show("Loading " + listing.getName(), true);
+				boolean validProject = loadProject(listing);
 				if (!validProject)
 					exit(1);
 			} catch (IOException | KdlParseException e) {
···
 		}
 	}
 
-	private static Project chooseProject() throws IOException, KdlParseException
+	private static ProjectListing chooseProject() throws IOException, KdlParseException
 	{
 		// Search current directory and its parents for a project manifest
 		File currentDir = new File(".");
 		while (currentDir != null) {
 			File projectDir = new File(currentDir, Manifest.FILENAME);
 			if (projectDir.isFile()) {
-				return new Project(projectDir);
+				return new ProjectListing(projectDir.getParentFile());
 			}
 			currentDir = currentDir.getParentFile();
 		}
···
 		return ProjectSwitcherDialog.showPrompt();
 	}
 
-	public static boolean loadProject(Project newProject) throws IOException
+	public static boolean loadProject(ProjectListing listing) throws IOException
 	{
-		project = newProject;
-
-		// TODO: get similar to classic
-		/*
-		// get US baserom
-		usBaseRom = new File(project.getDirectory(), FN_BASEROM);
-		if (!usBaseRom.exists()) {
-			showErrorMessage("Missing US Base ROM",
-				"Could not find US baserom for project. %n" +
-					"Star Rod requries one for asset extraction.");
+		try {
+			project = new Project(listing.getDirectory());
+		} catch (IOException | KdlParseException e) {
+			Logger.logError(e.getMessage());
+			showErrorMessage("Error Loading Project", "Failed to load project: %s", listing.getName());
 			return false;
 		}
-		*/
 
-		// save project dir
 		Directories.setProjectDirectory(project.getPath());
+		Directories.setDumpDirectory(project.getEngine().getDumpDir().getAbsolutePath());
 
-		reloadIcons();
+		// Asset stack (TODO: move to Project?)
+		assetDirectories = new ArrayList<>();
+		assetDirectories.add(project.getDirectory());
+		// ...dependencies...
+		assetDirectories.add(Directories.ENGINE_ASSETS_US.toFile());
 
-		ProjectDatabase.initialize();
-
-		// set dump dir
-		File dumpDir = new File(usBaseRom.getParentFile(), "/dump/");
-		Directories.setDumpDirectory(dumpDir.getAbsolutePath());
-
-		// dump if missing
-		if (!dumpDir.exists()) {
-			LoadingBar.show("Extracting Baserom");
-			Logger.log("Extracting assets from baserom");
-			Directories.createDumpDirectories();
-			EntityExtractor.extractAll();
-			FontManager.dump();
+		usBaseRom = project.getEngine().getBaseRom();
+		if (!ensureDumpExtracted()) {
+			return false;
 		}
 
-		AssetExtractor.extractAll();
+		reloadIcons();
+		ProjectDatabase.initialize();
 
-		// Record that this project was opened
 		ProjectManager.getInstance().recordProjectOpened(project);
-
 		return true;
 	}
 
···
 
 	public static ByteBuffer getBaseRomBuffer()
 	{
-		// lazy load
 		if (romBytes != null)
 			return romBytes;
 
+		if (usBaseRom == null || !usBaseRom.exists())
+			return null;
+
 		try {
 			romBytes = IOUtils.getDirectBuffer(usBaseRom).asReadOnlyBuffer();
 		}
···
 		return romBytes;
 	}
 
-	private static List<File> getAssetDirs(File directory, File splatFile) throws IOException
+	/**
+	 * Prompts the user to select a baserom file, validates it, and copies
+	 * it to the appropriate location.
+	 * @return the validated ROM file, or null if cancelled
+	 */
+	public static File promptForBaserom()
 	{
-		Map<String, Object> topLevelMap = new Yaml().load(new FileInputStream(splatFile));
+		OpenFileChooser chooser = new OpenFileChooser(
+			null, "Select Paper Mario (US) ROM", "N64 ROM", "z64", "n64", "v64");
+
+		if (chooser.prompt() != ChooseDialogResult.APPROVE)
+			return null;
+
+		File selected = chooser.getSelectedFile();
+		if (selected == null)
+			return null;
+
+		try {
+			File validated = RomValidator.validateROM(selected);
+			if (validated == null)
+				return null;
+
+			// Copy to target location
+			FileUtils.copyFile(validated, usBaseRom);
+			Logger.log("Baserom installed to " + usBaseRom.getAbsolutePath());
+
+			return usBaseRom;
+		}
+		catch (IOException e) {
+			Logger.printStackTrace(e);
+			showErrorMessage("ROM Copy Error", "Failed to copy ROM: %s", e.getMessage());
+			return null;
+		}
+	}
 
-		@SuppressWarnings("unchecked")
-		List<String> assetDirNames = (List<String>) topLevelMap.get("asset_stack");
+	/**
+	 * Ensures the dump directory is extracted. If it doesn't exist,
+	 * extracts from the baserom (prompting for the ROM if needed).
+	 * Sets usBaseRom and dumpPath as side effects when the user provides a ROM.
+	 * @return true if dump is available, false if user cancelled or extraction failed
+	 */
+	public static boolean ensureDumpExtracted() throws IOException
+	{
+		String dumpPath = Directories.getDumpPath();
 
-		File assetsDir = new File(directory, "assets");
+		if (dumpPath == null || !(new File(dumpPath).exists())) {
+			// Need baserom to create dump
+			if (usBaseRom == null || !usBaseRom.exists()) {
+				Logger.logError("Cannot extract dump: baserom not found");
+				return false;
+			}
 
-		List<File> assetDirectories = new ArrayList<>();
-		for (String dirName : assetDirNames) {
-			assetDirectories.add(new File(assetsDir, dirName));
+			Logger.log("Extracting assets");
+			Directories.createDumpDirectories();
+			EntityExtractor.extractAll();
+			FontManager.dump();
 		}
-		return assetDirectories;
+
+		AssetExtractor.extractAll();
+		return true;
 	}
 
 	public static boolean isWindows()

src/main/java/app/LoadingBar.java

···
 			setTitle("Initializing");
 
 			setMinimumSize(new Dimension(320, 64));
+			setMaximumSize(new Dimension(320, 64));
 			setLocationRelativeTo(null);
 			setUndecorated(true);
 			progressBar = new JProgressBar();

src/main/java/app/StarRodMain.java

···
 
 import javax.imageio.ImageIO;
 import javax.swing.AbstractButton;
+import javax.swing.BorderFactory;
 import javax.swing.ImageIcon;
 import javax.swing.JButton;
 import javax.swing.JLabel;
···
 
 import org.apache.commons.io.FilenameUtils;
 
-import app.build.BuildEnvironment;
-import app.build.BuildOutputListener;
-import app.build.BuildResult;
-import app.build.NixEnvironment;
-import app.build.WslNixOsEnvironment;
+import project.engine.BuildEnvironment;
+import project.engine.BuildOutputListener;
+import project.engine.BuildResult;
 import app.config.Options;
 import app.input.InvalidInputException;
 import app.pane.Dock;
···
 import assets.AssetManager;
 import assets.ExpectedAsset;
 import common.BaseEditor;
+import project.engine.Engine;
 import game.globals.editor.GlobalsEditor;
 import game.map.Map;
 import game.map.compiler.BuildException;
···
 import game.texture.editor.ImageEditor;
 import game.worldmap.WorldMapEditor;
 import net.miginfocom.swing.MigLayout;
+import project.Project;
 import util.Logger;
 import util.Priority;
 
···
 		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
 		setMinimumSize(new Dimension(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT));
 
-
-		// Display current project path (read-only, restart app to change projects)
-		JLabel projectPathLabel = new JLabel(Environment.getProjectDirectory().getAbsolutePath());
-		SwingUtils.setFontSize(projectPathLabel, 11);
+		// TODO: click this to change project
+		JLabel projectIdLabel = new JLabel(Environment.getProject().getManifest().getId());
+		SwingUtils.setFontSize(projectIdLabel, 11);
 
 		JButton mapEditorButton = new JButton("Map Editor");
 		trySetIcon(mapEditorButton, ExpectedAsset.ICON_MAP_EDITOR);
···
 		});
 		buttons.add(themesMenuButton);
 
-		// Extract Data button
-		JButton extractDataButton = new JButton("Extract Map Data");
-		trySetIcon(extractDataButton, ExpectedAsset.ICON_EXTRACT);
-		SwingUtils.setFontSize(extractDataButton, 12);
-		extractDataButton.addActionListener((e) -> {
-			action_extractMapData();
-		});
-		buttons.add(extractDataButton);
-
 		// Build Project button
 		JButton buildProjectButton = new JButton("Build Project");
 		trySetIcon(buildProjectButton, ExpectedAsset.ICON_GOLD);
···
 
 		// Left pane - buttons panel
 		JPanel leftPane = new JPanel(new MigLayout("fill, ins 8, wrap 1"));
-		leftPane.add(new JLabel("Project:"), "split 2");
-		leftPane.add(projectPathLabel, "pushx, growx, gapbottom 8, wrap");
 
 		JPanel buttonsPanel = new JPanel(new MigLayout("fillx, wrap 1, hidemode 3"));
 		buttonsPanel.add(mapEditorButton, "growx");
···
 		buttonsPanel.add(worldEditorButton, "growx");
 		buttonsPanel.add(imageEditorButton, "growx");
 		buttonsPanel.add(themesMenuButton, "growx");
-		buttonsPanel.add(extractDataButton, "growx");
 		buttonsPanel.add(openConfigDirButton, "growx");
 		buttonsPanel.add(openProjectDirButton, "growx");
 		buttonsPanel.add(buildProjectButton, "growx, gaptop 8");
···
 		verticalSplit.setDividerSize(4);
 		verticalSplit.setResizeWeight(1.0); // Give most space to top pane
 
+		// Status bar
+		JLabel statusBarLabel = new JLabel("Status bar");
+		statusBarLabel.setBorder(BorderFactory.createCompoundBorder(
+			BorderFactory.createMatteBorder(1, 0, 0, 0, UIManager.getColor("Separator.foreground")),
+			BorderFactory.createEmptyBorder(2, 8, 2, 8)
+		));
+		SwingUtils.setFontSize(statusBarLabel, 11);
+
 		// Layout
-		setLayout(new MigLayout("fill, ins 0"));
+		setLayout(new MigLayout("fill, ins 0, wrap"));
 		add(verticalSplit, "grow, push");
+		add(statusBarLabel, "growx, h 20!");
 
 		pack();
 		setLocationRelativeTo(null);
···
 		});
 	}
 
-	private void action_extractMapData()
-	{
-		new EditorWorker(() -> {
-			if (!Environment.projectConfig.getBoolean(Options.ExtractedMapData)) {
-				int choice = SwingUtils.getConfirmDialog()
-					.setTitle("Extraction Warning")
-					.setMessage("This action will modify the source files of almost every map.",
-						"Consider creating a backup or committing any changes before proceeding.",
-						"Are you ready to begin extracting?")
-					.setMessageType(JOptionPane.WARNING_MESSAGE)
-					.setOptionsType(JOptionPane.YES_NO_CANCEL_OPTION)
-					.choose();
-
-				if (choice == JOptionPane.YES_OPTION) {
-					Logger.log("Extracting map data...", Priority.MILESTONE);
-					Extractor.extractAll();
-
-					SwingUtils.getMessageDialog()
-						.setTitle("All Data Extracted")
-						.setMessage("Complete!")
-						.setMessageType(JOptionPane.PLAIN_MESSAGE)
-						.show();
-
-					Environment.projectConfig.setBoolean(Options.ExtractedMapData, true);
-					Environment.projectConfig.saveConfigFile();
-				}
-			}
-			else {
-				SwingUtils.getWarningDialog()
-					.setTitle("Data Already Extracted")
-					.setMessage("Map data has already been extracted for this project.")
-					.show();
-			}
-		});
-	}
-
 	private void action_buildProject()
 	{
 		BuildOutputDialog dialog = new BuildOutputDialog(this);
···
 					break;
 
 				case "-BUILDPROJECT":
-					BuildEnvironment env = null;
 					try {
-						if (Environment.isWindows()) {
-							env = new WslNixOsEnvironment();
-						}
-						else {
-							env = new NixEnvironment();
-						}
-
-						BuildResult result = env.configure(BuildOutputListener.toLogger());
-						if (result.isSuccess()) {
-							result = env.build(BuildOutputListener.toLogger());
-						}
-
-						if (!result.isSuccess()) {
-							throw new StarRodException("Build failed: " + result.getErrorMessage().orElse("unknown"));
-						}
-						Logger.log("ROM built: " + result.getOutputRom().get());
-					}
-					catch (app.build.BuildException e) {
-						if (!e.isSilent()) {
-							Logger.logError("Build environment error: " + e.getMessage());
-						}
-						else {
-							Logger.log(e.getMessage());
-						}
+						Environment.getProject().build();
 					}
-					catch (IOException e) {
-						Logger.logError("Build environment error: " + e.getMessage());
+					catch (Exception e) {
+						Logger.logError("Build failed: " + e.getMessage());
 					}
 					break;
 
···
 
 	private static final void trySetIcon(AbstractButton button, ExpectedAsset asset)
 	{
-		if (!(new File(Directories.getDumpPath())).exists()) {
+		if (Directories.getDumpPath() == null || !(new File(Directories.getDumpPath())).exists()) {
 			Logger.log("Dump directory could not be found.");
 			SwingUtils.addBorderPadding(button);
 			return;

src/main/java/app/build/BuildEnvironment.java

···
-package app.build;
-
-import java.io.IOException;
-import java.util.concurrent.CompletableFuture;
-
-/**
- * Interface for building Paper Mario decomp projects.
- * Implementations handle different build environments (native Nix, WSL+NixOS).
- */
-public interface BuildEnvironment
-{
-	/**
-	 * Returns a human-readable name for this environment type.
-	 */
-	String getName();
-
-	/**
-	 * Runs configure (./configure).
-	 * @param listener Callback for real-time build output
-	 * @return The result of the configure operation
-	 * @throws BuildException If the build environment is not properly set up
-	 * @throws IOException If an I/O error occurs
-	 */
-	BuildResult configure(BuildOutputListener listener) throws BuildException, IOException;
-
-	/**
-	 * Builds the project (ninja).
-	 * @param listener Callback for real-time build output
-	 * @return The result of the build operation
-	 * @throws BuildException If the build environment is not properly set up
-	 * @throws IOException If an I/O error occurs
-	 */
-	BuildResult build(BuildOutputListener listener) throws BuildException, IOException;
-
-	/**
-	 * Cleans the build directory (./configure --clean).
-	 * @param listener Callback for real-time build output
-	 * @return The result of the clean operation
-	 * @throws BuildException If the build environment is not properly set up
-	 * @throws IOException If an I/O error occurs
-	 */
-	BuildResult clean(BuildOutputListener listener) throws BuildException, IOException;
-
-	/**
-	 * Builds the project asynchronously.
-	 * @param listener Callback for real-time build output
-	 * @return A CompletableFuture that completes with the build result
-	 */
-	CompletableFuture<BuildResult> buildAsync(BuildOutputListener listener);
-
-	/**
-	 * Cancels any running build operation.
-	 * @return True if a build was cancelled, false if no build was running
-	 */
-	boolean cancel();
-
-	/**
-	 * Returns whether a build is currently in progress.
-	 */
-	boolean isBuilding();
-}

src/main/java/app/build/BuildException.java src/main/java/project/engine/BuildException.java

···
-package app.build;
+package project.engine;
 
 /**
  * Exception thrown when a build operation fails.

src/main/java/app/build/BuildOutputListener.java src/main/java/project/engine/BuildOutputListener.java

···
-package app.build;
+package project.engine;
 
 import util.Logger;
 
···
 	static BuildOutputListener toLogger()
 	{
 		return (line, isError) -> {
-			if (isError) {
-				Logger.logError(line);
-			}
-			else {
-				Logger.log(line);
-			}
+			Logger.log(line);
 		};
 	}
 

src/main/java/app/build/BuildResult.java src/main/java/project/engine/BuildResult.java

···
-package app.build;
+package project.engine;
 
 import java.io.File;
 import java.time.Duration;

src/main/java/app/build/NixEnvironment.java

···
-package app.build;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.concurrent.CompletableFuture;
-
-import app.BuildOutputDialog;
-import app.Environment;
-
-/**
- * Build environment implementation for native Nix (Linux/macOS).
- * Runs commands via `nix develop -c bash -c "<command>"`.
- */
-public class NixEnvironment implements BuildEnvironment
-{
-	private static final String ROM_PATH = "ver/us/build/papermario.z64";
-
-	private final ProcessRunner runner = new ProcessRunner();
-
-	@Override
-	public String getName()
-	{
-		return "Nix";
-	}
-
-	@Override
-	public BuildResult configure(BuildOutputListener listener) throws BuildException, IOException
-	{
-		validateEnvironment();
-		return runNixCommand("./configure", listener);
-	}
-
-	@Override
-	public BuildResult build(BuildOutputListener listener) throws BuildException, IOException
-	{
-		validateEnvironment();
-		ProcessRunner.ProcessResult result = runNixCommandRaw("NINJA_STATUS='" + BuildOutputDialog.NINJA_STATUS + "' ninja", listener);
-
-		if (result.wasCancelled()) {
-			return BuildResult.cancelled(result.getDuration());
-		}
-
-		File rom = new File(Environment.getProjectDirectory(), ROM_PATH);
-		if (result.isSuccess() && rom.exists()) {
-			return BuildResult.success(result.getExitCode(), result.getDuration(), rom);
-		}
-		else {
-			String error = result.getExitCode() == 0 ? "ROM file not found" : "Build failed with exit code " + result.getExitCode();
-			return BuildResult.failure(result.getExitCode(), result.getDuration(), error);
-		}
-	}
-
-	@Override
-	public BuildResult clean(BuildOutputListener listener) throws BuildException, IOException
-	{
-		validateEnvironment();
-		return runNixCommand("./configure --clean", listener);
-	}
-
-	@Override
-	public CompletableFuture<BuildResult> buildAsync(BuildOutputListener listener)
-	{
-		return CompletableFuture.supplyAsync(() -> {
-			try {
-				return build(listener);
-			}
-			catch (BuildException | IOException e) {
-				return BuildResult.failure(-1, java.time.Duration.ZERO, e.getMessage());
-			}
-		}, Environment.getExecutor());
-	}
-
-	@Override
-	public boolean cancel()
-	{
-		return runner.cancel();
-	}
-
-	@Override
-	public boolean isBuilding()
-	{
-		return runner.isRunning();
-	}
-
-	private void validateEnvironment() throws BuildException
-	{
-		// Check for nix binary
-		if (!isNixInstalled()) {
-			throw new BuildException(
-				"Nix is not installed. Please install Nix from https://nixos.org/download.html\n" +
-				"Run: curl -L https://nixos.org/nix/install | sh -s -- --daemon");
-		}
-
-		// Check for flake.nix in project directory
-		File projectDir = Environment.getProjectDirectory();
-		if (projectDir == null) {
-			throw new BuildException("No project directory is set");
-		}
-
-		File flakeFile = new File(projectDir, "flake.nix");
-		if (!flakeFile.exists()) {
-			throw new BuildException("No flake.nix found in project directory: " + projectDir.getAbsolutePath());
-		}
-	}
-
-	private boolean isNixInstalled()
-	{
-		try {
-			ProcessBuilder pb = new ProcessBuilder("which", "nix");
-			Process process = pb.start();
-			int exitCode = process.waitFor();
-			return exitCode == 0;
-		}
-		catch (IOException | InterruptedException e) {
-			return false;
-		}
-	}
-
-	private BuildResult runNixCommand(String command, BuildOutputListener listener) throws IOException
-	{
-		ProcessRunner.ProcessResult result = runNixCommandRaw(command, listener);
-
-		if (result.wasCancelled()) {
-			return BuildResult.cancelled(result.getDuration());
-		}
-		else if (result.isSuccess()) {
-			return BuildResult.success(result.getExitCode(), result.getDuration(), null);
-		}
-		else {
-			return BuildResult.failure(result.getExitCode(), result.getDuration(),
-				"Command failed with exit code " + result.getExitCode());
-		}
-	}
-
-	private ProcessRunner.ProcessResult runNixCommandRaw(String command, BuildOutputListener listener) throws IOException
-	{
-		File projectDir = Environment.getProjectDirectory();
-
-		String[] cmd = new String[] {
-			"nix", "develop", "-c", "bash", "-c", command
-		};
-
-		return runner.run(cmd, projectDir, listener);
-	}
-}

src/main/java/app/build/ProcessRunner.java src/main/java/project/engine/ProcessRunner.java

···
-package app.build;
+package project.engine;
 
 import java.io.BufferedReader;
 import java.io.File;

src/main/java/app/build/WslNixOsEnvironment.java src/main/java/project/engine/WslNixOsEnvironment.java

···
-package app.build;
+package project.engine;
 
 import java.io.BufferedReader;
 import java.io.File;
···
 		registerShutdownHook();
 	}
 
+	// --- Engine storage and git operations ---
+
+	private static final String WSL_ENGINE_BASE = "/home/nixos/star-rod/engine";
+
+	@Override
+	public File getEngineBaseDir()
+	{
+		return new File("\\\\" + "wsl$\\" + DISTRO_NAME + WSL_ENGINE_BASE.replace('/', '\\'));
+	}
+
+	@Override
+	public void gitCloneBare(String url, File targetDir, BuildOutputListener listener) throws IOException
+	{
+		String wslTarget = convertToWslPath(targetDir);
+		runWslGitCommand(null, listener, "clone", "--bare", url, wslTarget);
+	}
+
+	@Override
+	public void gitWorktreeAdd(File bareRepo, File worktreeDir, String ref, BuildOutputListener listener) throws IOException
+	{
+		String wslBareRepo = convertToWslPath(bareRepo);
+		String wslWorktree = convertToWslPath(worktreeDir);
+		runWslGitCommand(wslBareRepo, listener, "worktree", "add", wslWorktree, ref);
+	}
+
+	@Override
+	public void gitFetchAll(File repo, BuildOutputListener listener) throws IOException
+	{
+		runWslGitCommand(convertToWslPath(repo), listener, "fetch", "--all");
+	}
+
+	@Override
+	public void gitCheckout(File dir, String ref, BuildOutputListener listener) throws IOException
+	{
+		runWslGitCommand(convertToWslPath(dir), listener, "checkout", ref);
+	}
+
+	/**
+	 * Runs a git command inside WSL.
+	 * @param wslWorkingDir WSL-native path for working directory, or null
+	 * @param listener Callback for output
+	 * @param args git arguments (paths must already be WSL-native)
+	 */
+	private void runWslGitCommand(String wslWorkingDir, BuildOutputListener listener, String... args) throws IOException
+	{
+		int baseLen = 3; // wsl -d <distro>
+		if (wslWorkingDir != null)
+			baseLen += 2; // --cd <path>
+		baseLen += 1; // git
+
+		String[] cmd = new String[baseLen + args.length];
+		int i = 0;
+		cmd[i++] = "wsl";
+		cmd[i++] = "-d";
+		cmd[i++] = DISTRO_NAME;
+		if (wslWorkingDir != null) {
+			cmd[i++] = "--cd";
+			cmd[i++] = wslWorkingDir;
+		}
+		cmd[i++] = "git";
+		System.arraycopy(args, 0, cmd, i, args.length);
+
+		ProcessRunner.ProcessResult result = runner.run(cmd, null, listener);
+		if (!result.isSuccess()) {
+			throw new IOException("WSL git command failed with exit code " + result.getExitCode());
+		}
+	}
+
+	// --- Build operations ---
+
 	@Override
 	public String getName()
 	{
···
 	}
 
 	@Override
-	public BuildResult configure(BuildOutputListener listener) throws BuildException, IOException
+	public BuildResult configure(File projectDir, BuildOutputListener listener) throws BuildException, IOException
 	{
 		ensureDistroExists(listener);
-		return runWslCommand("./configure", listener);
+		return runWslCommand(projectDir, "./configure", listener);
 	}
 
 	@Override
-	public BuildResult build(BuildOutputListener listener) throws BuildException, IOException
+	public BuildResult build(File projectDir, BuildOutputListener listener) throws BuildException, IOException
 	{
 		ensureDistroExists(listener);
-		ProcessRunner.ProcessResult result = runWslCommandRaw("NINJA_STATUS='" + BuildOutputDialog.NINJA_STATUS + "' ./configure && ninja", listener);
+		ProcessRunner.ProcessResult result = runWslCommandRaw(projectDir, "NINJA_STATUS='" + BuildOutputDialog.NINJA_STATUS + "' ./configure && ninja", listener);
 
 		if (result.wasCancelled()) {
 			return BuildResult.cancelled(result.getDuration());
 		}
 
-		File rom = new File(Environment.getProjectDirectory(), ROM_PATH);
+		File rom = new File(projectDir, ROM_PATH);
 		if (result.isSuccess() && rom.exists()) {
 			return BuildResult.success(result.getExitCode(), result.getDuration(), rom);
 		}
···
 	}
 
 	@Override
-	public BuildResult clean(BuildOutputListener listener) throws BuildException, IOException
+	public BuildResult clean(File projectDir, BuildOutputListener listener) throws BuildException, IOException
 	{
 		ensureDistroExists(listener);
-		return runWslCommand("./configure --clean", listener);
+		return runWslCommand(projectDir, "./configure --clean", listener);
 	}
 
 	@Override
-	public CompletableFuture<BuildResult> buildAsync(BuildOutputListener listener)
+	public CompletableFuture<BuildResult> buildAsync(File projectDir, BuildOutputListener listener)
 	{
 		return CompletableFuture.supplyAsync(() -> {
 			try {
-				return build(listener);
+				return build(projectDir, listener);
 			}
 			catch (BuildException | IOException e) {
 				return BuildResult.failure(-1, java.time.Duration.ZERO, e.getMessage());
···
 	private String convertToWslPath(File windowsPath)
 	{
 		String absPath = windowsPath.getAbsolutePath();
+		// Convert WSL paths to local ones
+		if (absPath.startsWith("\\\\wsl$\\" + DISTRO_NAME + "\\")) {
+			String rest = absPath.substring(absPath.indexOf(DISTRO_NAME) + DISTRO_NAME.length() + 1).replace('\\', '/');
+			return rest.replace("\\", "/");
+		}
 		// Convert C:\foo\bar to /mnt/c/foo/bar
 		if (absPath.length() >= 2 && absPath.charAt(1) == ':') {
 			char driveLetter = Character.toLowerCase(absPath.charAt(0));
···
 		return absPath.replace('\\', '/');
 	}
 
-	private BuildResult runWslCommand(String command, BuildOutputListener listener) throws IOException
+	private BuildResult runWslCommand(File projectDir, String command, BuildOutputListener listener) throws IOException
 	{
-		ProcessRunner.ProcessResult result = runWslCommandRaw(command, listener);
+		ProcessRunner.ProcessResult result = runWslCommandRaw(projectDir, command, listener);
 
 		if (result.wasCancelled()) {
 			return BuildResult.cancelled(result.getDuration());
···
 		}
 	}
 
-	private ProcessRunner.ProcessResult runWslCommandRaw(String command, BuildOutputListener listener) throws IOException
+	private ProcessRunner.ProcessResult runWslCommandRaw(File projectDir, String command, BuildOutputListener listener) throws IOException
 	{
-		File projectDir = Environment.getProjectDirectory();
 		String wslPath = convertToWslPath(projectDir);
 
 		String[] cmd = new String[] {

src/main/java/game/ProjectDatabase.java

···
 		if (initialized)
 			return;
 
-		savedFlags = loadSavedVarNames(Directories.PROJ_INCLUDE.file("saved_flag_names.h"));
-		savedBytes = loadSavedVarNames(Directories.PROJ_INCLUDE.file("saved_byte_names.h"));
+		savedFlags = loadSavedVarNames(Directories.ENGINE_INCLUDE.file("saved_flag_names.h"));
+		savedBytes = loadSavedVarNames(Directories.ENGINE_INCLUDE.file("saved_byte_names.h"));
 
 		// TODO the following block takes a half-second at startup and could be optimized better
 		{
 			decompEnums = new CaseInsensitiveMap<>();
-			DecompEnum.addEnums(decompEnums, Directories.PROJ_INCLUDE.file("enums.h").getAbsolutePath());
-			DecompEnum.addEnums(decompEnums, Directories.PROJ_INCLUDE.file("effects.h").getAbsolutePath());
-			DecompEnum.addEnums(decompEnums, Directories.PROJ_SRC.file("battle/battle_names.h").getAbsolutePath());
-			DecompEnum.addEnums(decompEnums, Directories.PROJ_SRC.file("battle/stage_names.h").getAbsolutePath());
+			DecompEnum.addEnums(decompEnums, Directories.ENGINE_INCLUDE.file("enums.h").getAbsolutePath());
+			DecompEnum.addEnums(decompEnums, Directories.ENGINE_INCLUDE.file("effects.h").getAbsolutePath());
+			DecompEnum.addEnums(decompEnums, Directories.ENGINE_SRC.file("battle/battle_names.h").getAbsolutePath());
+			DecompEnum.addEnums(decompEnums, Directories.ENGINE_SRC.file("battle/stage_names.h").getAbsolutePath());
 		}
 
 		ESurfaceTypes = decompEnums.get("SurfaceType");

src/main/java/game/SimpleItem.java

···
 	{
 		ArrayList<SimpleItemTemplate> templates = new ArrayList<>();
 
-		File yamlFile = Directories.PROJ_SRC.file("item_table.yaml");
+		File yamlFile = Directories.ENGINE_SRC.file("item_table.yaml");
 		ArrayList<Object> itemList = YamlHelper.readAsList(yamlFile);
 		if (itemList == null)
 			return null;

src/main/java/game/entity/EntityInfo.java

···
 
 	public static void loadModels()
 	{
+		// Ensure dump is extracted (will prompt for baserom if needed)
+		if (!DUMP_ENTITY_SRC.toFile().exists()) {
+			try {
+				if (!Environment.ensureDumpExtracted())
+					return; // user cancelled baserom selection
+			}
+			catch (IOException e) {
+				Logger.logError("Failed to extract dump: " + e.getMessage());
+				Logger.printStackTrace(e);
+				return;
+			}
+		}
+
 		for (EntityType type : EntityType.values()) {
 			if (type.model != null)
 				type.model.freeTextures();

src/main/java/game/globals/editor/GlobalsData.java

···
 
 	private void loadItems()
 	{
-		File yamlFile = Directories.PROJ_SRC.file("item_table.yaml");
+		File yamlFile = Directories.ENGINE_SRC.file("item_table.yaml");
 		List<ItemRecord> itemList = ItemRecord.fromYAML(yamlFile);
 
 		items.clear();
···
 			item.saveBackup();
 		}
 
-		File yamlFile = Directories.PROJ_SRC.file("item_table.yaml");
+		File yamlFile = Directories.ENGINE_SRC.file("item_table.yaml");
 		ItemRecord.toYAML(yamlFile, itemList);
 
 		Logger.log("Saved item table");
···
 
 	private void loadMoves()
 	{
-		File yamlFile = Directories.PROJ_SRC.file("move_table.yaml");
+		File yamlFile = Directories.ENGINE_SRC.file("move_table.yaml");
 		List<MoveRecord> moveList = MoveRecord.fromYAML(yamlFile);
 
 		moves.clear();
···
 			move.saveBackup();
 		}
 
-		File yamlFile = Directories.PROJ_SRC.file("move_table.yaml");
+		File yamlFile = Directories.ENGINE_SRC.file("move_table.yaml");
 		MoveRecord.toYAML(yamlFile, moveList);
 
 		Logger.log("Saved moves table");

src/main/java/game/map/Map.java

···
 		}
 
 		areaName = "area_" + areaAffix;
-		projDir = Directories.PROJ_SRC_WORLD.file(areaName + "/" + name);
+		projDir = Directories.ENGINE_SRC_WORLD.file(areaName + "/" + name);
 	}
 
 	public String getName()
···
 	public void loadVarNames()
 	{
 		String areaHeaderName = String.format("%s/%s.h", areaName, areaAffix);
-		File areaHeader = Directories.PROJ_SRC_WORLD.file(areaHeaderName);
+		File areaHeader = Directories.ENGINE_SRC_WORLD.file(areaHeaderName);
 
 		areaByteNames.clear();
 		areaFlagNames.clear();
···
 		}
 
 		String mapHeaderName = String.format("%s/%s/%s.h", areaName, name, name);
-		File mapHeader = Directories.PROJ_SRC_WORLD.file(mapHeaderName);
+		File mapHeader = Directories.ENGINE_SRC_WORLD.file(mapHeaderName);
 
 		mapVarNames.clear();
 		mapFlagNames.clear();

src/main/java/game/map/compiler/CollisionCompiler.java

···
 		raf.writeInt(zoneHeaderOffset);
 		raf.close();
 
-		File headerFile = Directories.PROJ_INCLUDE_MAPFS.file(map.getName() + "_hit.h");
+		File headerFile = Directories.ENGINE_INCLUDE_MAPFS.file(map.getName() + "_hit.h");
 		try (PrintWriter pw = IOUtils.getBufferedPrintWriter(headerFile)) {
 			for (Collider c : map.colliderTree.getList()) {
 				pw.printf("#define %-23s 0x%X%n", "COLLIDER_" + c.getName(), c.getNode().getTreeIndex());

src/main/java/game/map/compiler/GeometryCompiler.java

···
 			throw new BuildException("Build failed: " + mapType + " size exceeds engine limit.\n" + breakdown);
 		}
 
-		File headerFile = Directories.PROJ_INCLUDE_MAPFS.file(map.getName() + "_shape.h");
+		File headerFile = Directories.ENGINE_INCLUDE_MAPFS.file(map.getName() + "_shape.h");
 		try (PrintWriter pw = IOUtils.getBufferedPrintWriter(headerFile)) {
 			for (Model mdl : map.modelTree.getList()) {
 				pw.printf("#define %-23s 0x%X%n", "MODEL_" + mdl.getName(), mdl.getNode().getTreeIndex());

src/main/java/game/map/scripts/extract/Extractor.java

···
 	{
 		LoadingBar.show("Extracting Map Data", Priority.IMPORTANT);
 
-		File f = Directories.PROJ_SRC_WORLD.toFile();
+		File f = Directories.ENGINE_SRC_WORLD.toFile();
 		File[] worldDirs = f.listFiles();
 		Arrays.sort(worldDirs);
 

src/main/java/game/map/scripts/extract/HeaderEntry.java

···
 		Environment.initialize();
 		LoadingBar.show("Testing Map Data");
 
-		File f = Directories.PROJ_SRC_WORLD.toFile();
+		File f = Directories.ENGINE_SRC_WORLD.toFile();
 		File[] worldDirs = f.listFiles();
 		Arrays.sort(worldDirs);
 		int mismatchCount = 0;
···
 
 	public static boolean test(String mapPath) throws IOException
 	{
-		File in = Directories.PROJ_SRC_WORLD.file(mapPath + "/generated.h");
-		File out = Directories.PROJ_SRC_WORLD.file(mapPath + "/test.h");
+		File in = Directories.ENGINE_SRC_WORLD.file(mapPath + "/generated.h");
+		File out = Directories.ENGINE_SRC_WORLD.file(mapPath + "/test.h");
 
 		List<HeaderEntry> entries = parseFile(in);
 

src/main/java/game/map/scripts/extract/StageExtractor.java

···
 		Environment.initialize();
 		LoadingBar.show("Extracting Stage Data");
 
-		File f = Directories.PROJ_SRC_STAGE.toFile();
+		File f = Directories.ENGINE_SRC_STAGE.toFile();
 		File[] areaDirs = f.listFiles();
 		Arrays.sort(areaDirs);
 

src/main/java/game/message/font/FontManager.java

···
 
 	public static void loadData() throws IOException
 	{
-		XmlReader xmr = new XmlReader(new File(DUMP_MSG_FONT.toFile(), "fonts.xml"));
+		// Ensure dump is extracted (will prompt for baserom if needed)
+		File fontsXml = new File(DUMP_MSG_FONT.toFile(), "fonts.xml");
+		if (!fontsXml.exists()) {
+			if (!Environment.ensureDumpExtracted())
+				return; // user cancelled baserom selection
+		}
+
+		XmlReader xmr = new XmlReader(fontsXml);
 
 		List<Element> fontElems = xmr.getTags(xmr.getRootElement(), TAG_FONT);
 		if (fontElems.size() != 4)

src/main/java/game/worldmap/WorldMapModder.java

···
 
 	public static List<WorldLocation> loadLocations() throws IOException
 	{
-		List<WorldLocation> locations = readXML(Directories.PROJ_SRC.file(Directories.FN_WORLD_MAP));
+		List<WorldLocation> locations = readXML(Directories.ENGINE_SRC.file(Directories.FN_WORLD_MAP));
 
 		HashMap<String, WorldLocation> locationMap = new HashMap<>();
 		for (WorldLocation loc : locations) {
···
 				loc.parentName = loc.parent.name;
 		}
 
-		writeXML(locations, Directories.PROJ_SRC.file(Directories.FN_WORLD_MAP));
+		writeXML(locations, Directories.ENGINE_SRC.file(Directories.FN_WORLD_MAP));
 	}
 
 	public static String stripPrefix(String s, String prefix)

src/main/java/project/JsonProjectRepository.java

···
 	}
 
 	@Override
-	public synchronized List<Project> getAllProjects()
+	public synchronized List<ProjectListing> getAllProjects()
 	{
 		List<ProjectData> dataList = loadProjectData();
-		List<Project> projects = new ArrayList<>();
+		List<ProjectListing> projects = new ArrayList<>();
 
-		// Convert to Project objects, filtering out invalid entries
+		// Convert to ProjectListing objects, filtering out invalid entries
 		Iterator<ProjectData> iter = dataList.iterator();
 		boolean modified = false;
 
···
 			ProjectData data = iter.next();
 
 			try {
-				projects.add(new Project(new File(data.path), data.lastOpened));
+				projects.add(new ProjectListing(new File(data.path), data.lastOpened));
 			} catch (IOException | KdlParseException e) {
 				Logger.logWarning("Ignoring invalid project: " + data.path);
 				iter.remove();
···
 	}
 
 	@Override
-	public synchronized void addProject(Project project)
+	public synchronized void addProject(ProjectListing listing)
 	{
 		List<ProjectData> dataList = loadProjectData();
 
 		// Remove existing entry with same path (will be re-added with new timestamp)
-		String absolutePath = project.getPath();
+		String absolutePath = listing.getPath();
 		dataList.removeIf(data -> data.path.equals(absolutePath));
 
 		// Add new entry
 		ProjectData newData = new ProjectData();
 		newData.path = absolutePath;
-		newData.lastOpened = project.getLastOpened();
+		newData.lastOpened = listing.getLastOpened();
 		dataList.add(0, newData); // Add to beginning (most recent)
 
 		saveProjectData(dataList);
 	}
 
 	@Override
-	public synchronized void removeProject(Project project)
+	public synchronized void removeProject(ProjectListing listing)
 	{
 		List<ProjectData> dataList = loadProjectData();
-		String absolutePath = project.getPath();
+		String absolutePath = listing.getPath();
 		dataList.removeIf(data -> data.path.equals(absolutePath));
 		saveProjectData(dataList);
 	}
 
 	@Override
-	public synchronized void updateLastOpened(Project project)
+	public synchronized void updateLastOpened(ProjectListing listing)
 	{
 		List<ProjectData> dataList = loadProjectData();
-		String absolutePath = project.getPath();
+		String absolutePath = listing.getPath();
 
 		for (ProjectData data : dataList) {
 			if (data.path.equals(absolutePath)) {

src/main/java/project/Manifest.java

···
 	private final File file;
 	private final KdlDocument doc;
 
-	public Manifest(Project project) throws IOException, KdlParseException {
-		file = new File(project.getPath(), FILENAME);
+	public Manifest(File directory) throws IOException, KdlParseException {
+		file = new File(directory, FILENAME);
 
 		if (!file.exists()) {
 			throw new IOException(FILENAME + " does not exist");
···
 
 		var parser = KdlParser.v2();
 		doc = parser.parse(Path.of(file.getAbsolutePath()));
+
+		if (!hasEngine())
+			throw new IOException(FILENAME + " is missing required 'engine' node");
 	}
 	public String toString() {
 		return "Manifest(" + file.getPath() + ")";
···
 			.findFirst()
 			.map(n -> n.arguments().get(0).value().toString())
 			.orElse(file.getParentFile().getName());
+	}
+
+	public String getId() {
+		return doc.nodes().stream()
+			.filter(n -> n.name().equals("id"))
+			.findFirst()
+			.map(n -> n.arguments().get(0).value().toString())
+			.orElse(null);
+	}
+
+	private boolean hasEngine() {
+		return doc.nodes().stream()
+			.anyMatch(n -> n.name().equals("engine"));
+	}
+
+	/**
+	 * Returns the engine ref (git ref to checkout).
+	 * Defaults to "main" if the ref property is omitted.
+	 */
+	public String getEngineRef() {
+		return doc.nodes().stream()
+			.filter(n -> n.name().equals("engine"))
+			.findFirst()
+			.map(n -> n.getProperty("ref")
+				.map(v -> v.value().toString())
+				.orElse("main"))
+			.orElse("main");
 	}
 }

src/main/java/project/Project.java

···
 import org.apache.commons.io.FileUtils;
 
 import dev.kdl.parse.KdlParseException;
+import project.engine.BuildException;
+import project.engine.Engine;
 
-public class Project implements Comparable<Project>
+/**
+ * A fully-loaded project with an initialized engine.
+ * Extends {@link ProjectListing} so it can be used anywhere a listing is expected.
+ */
+public class Project extends ProjectListing
 {
-	private final File directory;
-	private final long lastOpened; // TODO: move this, Comparable, and compareTo to a new class
-	private final Manifest manifest;
-
-	/** Loads a project from a directory. */
-	public Project(File path, long lastOpened) throws IOException, KdlParseException
-	{
-		if (!path.isDirectory())
-			throw new IllegalArgumentException("Project path must be a directory: " + path);
-		this.directory = path.getAbsoluteFile();
-		this.lastOpened = lastOpened;
-		this.manifest = new Manifest(this);
-	}
+	private final Engine engine;
 
-	/** Loads a project from a directory. */
+	/** Loads a project from a directory, initializing the engine. */
 	public Project(File path) throws IOException, KdlParseException
 	{
-		this(path, System.currentTimeMillis());
-	}
-
-	public String getPath()
-	{
-		return directory.getPath();
-	}
-
-	public File getDirectory()
-	{
-		return directory;
+		super(path);
+		try {
+			this.engine = Engine.forProject(this);
+		}
+		catch (BuildException e) {
+			throw new IOException("Failed to initialize engine: " + e.getMessage(), e);
+		}
 	}
 
-	public long getLastOpened()
+	public Engine getEngine()
 	{
-		return lastOpened;
-	}
-
-	public String getName()
-	{
-		return manifest.getName();
-	}
-
-	public Manifest getManifest()
-	{
-		return manifest;
+		return engine;
 	}
 
 	/** Creates a new project from a template. */
-	public static Project create(File path, String template, String id, String name) throws IOException, KdlParseException
+	public static ProjectListing create(File path, String template, String id, String name) throws IOException, KdlParseException
 	{
 		if (!path.exists())
 			path.mkdirs();
···
 		File manifestFile = new File(path, Manifest.FILENAME);
 		if (manifestFile.exists()) {
 			String content = FileUtils.readFileToString(manifestFile, "UTF-8");
-			content = content.replace("$PROJECT_ID", id);
-			content = content.replace("$PROJECT_NAME", name);
-			content = content.replace("$PROJECT_DESCRIPTION", "");
+			content = content.replace("$PROJECT_ID", '"' + id + '"');
+			content = content.replace("$PROJECT_NAME", '"' + name.replace('"', '\\') + '"');
+			content = content.replace("$PROJECT_DESCRIPTION", '"' + "An amazing mod of Paper Mario" + '"'); // TODO: ui
 			FileUtils.writeStringToFile(manifestFile, content, "UTF-8");
 		}
 
-		return new Project(path);
+		return new ProjectListing(path);
 	}
 
-	@Override
-	public int compareTo(Project other)
+	public void build()
 	{
-		// Sort by lastOpened descending (most recent first)
-		return Long.compare(other.lastOpened, this.lastOpened);
-	}
-
-	@Override
-	public boolean equals(Object obj)
-	{
-		if (this == obj)
-			return true;
-		if (obj == null || getClass() != obj.getClass())
-			return false;
-		Project other = (Project) obj;
-		return directory.equals(other.directory);
-	}
-
-	@Override
-	public int hashCode()
-	{
-		return directory.hashCode();
-	}
-
-	@Override
-	public String toString()
-	{
-		return getName() + " (" + directory.getAbsolutePath() + ")";
+		// TODO
 	}
 }

src/main/java/project/ProjectListing.java

···
+package project;
+
+import java.io.File;
+import java.io.IOException;
+
+import dev.kdl.parse.KdlParseException;
+
+/**
+ * Lightweight project metadata for display in the project switcher.
+ * Parses the manifest for name/path but does not initialize the engine.
+ */
+public class ProjectListing implements Comparable<ProjectListing>
+{
+	private final File directory;
+	private final long lastOpened;
+	private final Manifest manifest;
+
+	public ProjectListing(File path, long lastOpened) throws IOException, KdlParseException
+	{
+		if (!path.isDirectory())
+			throw new IllegalArgumentException("Project path must be a directory: " + path);
+		this.directory = path.getAbsoluteFile();
+		this.lastOpened = lastOpened;
+		this.manifest = new Manifest(this.directory);
+	}
+
+	public ProjectListing(File path) throws IOException, KdlParseException
+	{
+		this(path, System.currentTimeMillis());
+	}
+
+	public String getPath()
+	{
+		return directory.getPath();
+	}
+
+	public File getDirectory()
+	{
+		return directory;
+	}
+
+	public long getLastOpened()
+	{
+		return lastOpened;
+	}
+
+	public String getName()
+	{
+		return manifest.getName();
+	}
+
+	public Manifest getManifest()
+	{
+		return manifest;
+	}
+
+	@Override
+	public int compareTo(ProjectListing other)
+	{
+		// Sort by lastOpened descending (most recent first)
+		return Long.compare(other.lastOpened, this.lastOpened);
+	}
+
+	@Override
+	public boolean equals(Object obj)
+	{
+		if (this == obj)
+			return true;
+		if (!(obj instanceof ProjectListing other))
+			return false;
+		return directory.equals(other.directory);
+	}
+
+	@Override
+	public int hashCode()
+	{
+		return directory.hashCode();
+	}
+
+	@Override
+	public String toString()
+	{
+		return getName() + " (" + directory.getAbsolutePath() + ")";
+	}
+}

src/main/java/project/ProjectManager.java

···
 	 * Gets all recent projects, sorted by last opened (most recent first).
 	 * Invalid projects (non-existent paths) are automatically removed.
 	 */
-	public List<Project> getRecentProjects()
+	public List<ProjectListing> getRecentProjects()
 	{
 		return repository.getAllProjects();
 	}
···
 	/**
 	 * Records that a project was opened (adds or updates its timestamp).
 	 */
-	public void recordProjectOpened(Project project)
+	public void recordProjectOpened(ProjectListing listing)
 	{
-		repository.updateLastOpened(project);
+		repository.updateLastOpened(listing);
 	}
 
 	/**
 	 * Removes a project from the recent projects list.
 	 * Does NOT delete files from disk.
-	 * @param project The project to remove
 	 */
-	public void removeFromHistory(Project project)
+	public void removeFromHistory(ProjectListing listing)
 	{
-		repository.removeProject(project);
+		repository.removeProject(listing);
 	}
 
 	/**
 	 * Deletes a project from disk and removes it from the history.
-	 * @param project The project to delete
 	 * @return true if deletion was successful, false otherwise
 	 */
-	public boolean deleteFromDisk(Project project)
+	public boolean deleteFromDisk(ProjectListing listing)
 	{
-		File projectDir = new File(project.getPath());
+		File projectDir = new File(listing.getPath());
 
-		repository.removeProject(project);
+		repository.removeProject(listing);
 
 		try {
 			FileUtils.deleteDirectory(projectDir);

src/main/java/project/ProjectRepository.java

···
 {
 	/**
 	 * Gets all projects sorted by last opened (most recent first).
-	 * @return List of projects, or empty list if none exist
+	 * @return List of project listings, or empty list if none exist
 	 */
-	List<Project> getAllProjects();
+	List<ProjectListing> getAllProjects();
 
 	/**
 	 * Adds a project to the repository or updates its timestamp if it already exists.
-	 * @param project The project to add or update
+	 * @param listing The project listing to add or update
 	 */
-	void addProject(Project project);
+	void addProject(ProjectListing listing);
 
 	/**
 	 * Removes a project from the repository.
 	 */
-	void removeProject(Project project);
+	void removeProject(ProjectListing listing);
 
 	/**
 	 * Updates the last opened timestamp for a project.
-     */
-	void updateLastOpened(Project project);
+	 */
+	void updateLastOpened(ProjectListing listing);
 }

src/main/java/project/engine/BuildEnvironment.java

···
+package project.engine;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Interface for building Paper Mario decomp projects.
+ * Implementations handle different build environments (native Nix, WSL+NixOS).
+ */
+public interface BuildEnvironment
+{
+	// --- Engine storage and git operations ---
+
+	/**
+	 * Returns the base directory for engine storage (bare repo + worktrees),
+	 * as a host-side File that Java can use for file operations.
+	 */
+	File getEngineBaseDir();
+
+	/**
+	 * Clones a bare git repository.
+	 * @param url The repository URL
+	 * @param targetDir Host-side File for the bare repo destination
+	 * @param listener Callback for output
+	 * @throws IOException If the command fails
+	 */
+	void gitCloneBare(String url, File targetDir, BuildOutputListener listener) throws IOException;
+
+	/**
+	 * Creates a git worktree from a bare repository.
+	 * @param bareRepo Host-side File for the bare repo
+	 * @param worktreeDir Host-side File for the new worktree
+	 * @param ref Git ref to check out
+	 * @param listener Callback for output
+	 * @throws IOException If the command fails
+	 */
+	void gitWorktreeAdd(File bareRepo, File worktreeDir, String ref, BuildOutputListener listener) throws IOException;
+
+	/**
+	 * Fetches all remotes in a git repository.
+	 * @param repo Host-side File for the repo/worktree
+	 * @param listener Callback for output
+	 * @throws IOException If the command fails
+	 */
+	void gitFetchAll(File repo, BuildOutputListener listener) throws IOException;
+
+	/**
+	 * Checks out a git ref in a repository.
+	 * @param dir Host-side File for the repo/worktree
+	 * @param ref Git ref to check out
+	 * @param listener Callback for output
+	 * @throws IOException If the command fails
+	 */
+	void gitCheckout(File dir, String ref, BuildOutputListener listener) throws IOException;
+
+	// --- Build operations ---
+
+	/**
+	 * Returns a human-readable name for this environment type.
+	 */
+	String getName();
+
+	/**
+	 * Runs configure (./configure).
+	 * @param projectDir The project directory to build in
+	 * @param listener Callback for real-time build output
+	 * @return The result of the configure operation
+	 * @throws BuildException If the build environment is not properly set up
+	 * @throws IOException If an I/O error occurs
+	 */
+	BuildResult configure(File projectDir, BuildOutputListener listener) throws BuildException, IOException;
+
+	/**
+	 * Builds the project (ninja).
+	 * @param projectDir The project directory to build in
+	 * @param listener Callback for real-time build output
+	 * @return The result of the build operation
+	 * @throws BuildException If the build environment is not properly set up
+	 * @throws IOException If an I/O error occurs
+	 */
+	BuildResult build(File projectDir, BuildOutputListener listener) throws BuildException, IOException;
+
+	/**
+	 * Cleans the build directory (./configure --clean).
+	 * @param projectDir The project directory to clean
+	 * @param listener Callback for real-time build output
+	 * @return The result of the clean operation
+	 * @throws BuildException If the build environment is not properly set up
+	 * @throws IOException If an I/O error occurs
+	 */
+	BuildResult clean(File projectDir, BuildOutputListener listener) throws BuildException, IOException;
+
+	/**
+	 * Builds the project asynchronously.
+	 * @param projectDir The project directory to build in
+	 * @param listener Callback for real-time build output
+	 * @return A CompletableFuture that completes with the build result
+	 */
+	CompletableFuture<BuildResult> buildAsync(File projectDir, BuildOutputListener listener);
+
+	/**
+	 * Cancels any running build operation.
+	 * @return True if a build was cancelled, false if no build was running
+	 */
+	boolean cancel();
+
+	/**
+	 * Returns whether a build is currently in progress.
+	 */
+	boolean isBuilding();
+}

src/main/java/project/engine/Engine.java

···
+package project.engine;
+
+import java.io.File;
+import java.io.IOException;
+
+import app.Environment;
+import project.Project;
+import util.Logger;
+
+/**
+ * A checkout of papermario-dx that has been built, ready for modding.
+ *
+ * Also maintains a bare clone, so that each Engine can be a worktree of the bare repo.
+ * Engines may also be a submodule inside a project for users who want to modify the engine.
+ */
+public class Engine
+{
+	private static final String BARE_REPO_NAME = "papermario-dx.git";
+	private static final String REPO_URL = "https://github.com/bates64/papermario-dx.git";
+	private static final String BASEROM_PATH = "ver/us/baserom.z64";
+	private static final String DUMP_PATH = "ver/us/build/star-rod-dump";
+
+	private final File directory; // the worktree or submodule directory
+	private final String ref;
+	private final boolean isSubmodule;
+	private final BuildEnvironment buildEnv;
+
+	private Engine(File directory, String ref, boolean isSubmodule, BuildEnvironment buildEnv) throws IOException, BuildException
+	{
+		this.directory = directory;
+		this.ref = ref;
+		this.isSubmodule = isSubmodule;
+		this.buildEnv = buildEnv;
+
+		if (!isSubmodule) {
+			File bareRepo = getBareRepoDir();
+			if (!bareRepo.exists())
+				cloneBareRepo();
+
+			if (!directory.exists() || !isGitRepo(directory))
+				createWorktree();
+			else
+				checkoutRef();
+		}
+	}
+
+	// --- Factory ---
+
+	/**
+	 * Resolves and sets up the engine for a project.
+	 * If the engine uses a worktree, it will be cloned/checked out synchronously.
+	 */
+	public static Engine forProject(Project project) throws BuildException, IOException
+	{
+		BuildEnvironment buildEnv = createBuildEnvironment();
+		String ref = project.getManifest().getEngineRef();
+
+		// Check for submodule first
+		File submoduleDir = new File(project.getDirectory(), "papermario-dx");
+		if (isGitRepo(submoduleDir))
+			return new Engine(submoduleDir, ref, true, buildEnv);
+
+		// Worktree-based engine
+		File engineBase = buildEnv.getEngineBaseDir();
+
+		String projectId = project.getManifest().getId();
+		if (projectId == null || projectId.isEmpty())
+			projectId = project.getDirectory().getName();
+		File worktreeDir = new File(engineBase, "worktrees/" + projectId);
+
+		return new Engine(worktreeDir, ref, false, buildEnv);
+	}
+
+	private static BuildEnvironment createBuildEnvironment() throws BuildException
+	{
+		if (Environment.isWindows())
+			return new WslNixOsEnvironment();
+		return new NixEnvironment();
+	}
+
+	private File getBareRepoDir()
+	{
+		return new File(buildEnv.getEngineBaseDir(), BARE_REPO_NAME);
+	}
+
+	public File getDirectory()
+	{
+		return directory;
+	}
+
+	public File getBaseRom()
+	{
+		return new File(directory, BASEROM_PATH);
+	}
+
+	public File getDumpDir()
+	{
+		return new File(directory, DUMP_PATH);
+	}
+
+	public String getRef()
+	{
+		return ref;
+	}
+
+	public boolean isSubmodule()
+	{
+		return isSubmodule;
+	}
+
+	public BuildEnvironment getBuildEnvironment()
+	{
+		return buildEnv;
+	}
+
+	private void cloneBareRepo() throws IOException
+	{
+		buildEnv.gitCloneBare(REPO_URL, getBareRepoDir(), BuildOutputListener.toLogger());
+	}
+
+	private void createWorktree() throws IOException
+	{
+		buildEnv.gitWorktreeAdd(getBareRepoDir(), directory, ref, BuildOutputListener.toLogger());
+	}
+
+	private void checkoutRef() throws IOException
+	{
+		buildEnv.gitFetchAll(getBareRepoDir(), BuildOutputListener.toLogger());
+		buildEnv.gitCheckout(directory, ref, BuildOutputListener.toLogger());
+	}
+
+	// TODO: call this somewhere!
+	public BuildResult splitAssets() throws BuildException, IOException
+	{
+		return buildEnv.configure(directory, BuildOutputListener.toLogger());
+	}
+
+	private static boolean isGitRepo(File dir)
+	{
+		return dir.isDirectory() && (new File(dir, ".git").exists() || new File(dir, "HEAD").exists());
+	}
+}

src/main/java/project/engine/NixEnvironment.java

···
+package project.engine;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
+
+import app.BuildOutputDialog;
+import app.Environment;
+
+/**
+ * Build environment implementation for native Nix (Linux/macOS).
+ * Runs commands via `nix develop -c bash -c "<command>"`.
+ */
+public class NixEnvironment implements BuildEnvironment
+{
+	private static final String ROM_PATH = "ver/us/build/papermario.z64";
+
+	private final ProcessRunner runner = new ProcessRunner();
+
+	// --- Engine storage and git operations ---
+
+	@Override
+	public File getEngineBaseDir()
+	{
+		return new File(Environment.getUserStateDir(), "engine");
+	}
+
+	@Override
+	public void gitCloneBare(String url, File targetDir, BuildOutputListener listener) throws IOException
+	{
+		targetDir.getParentFile().mkdirs();
+		runGitCommand(null, listener, "clone", "--bare", url, targetDir.getAbsolutePath());
+	}
+
+	@Override
+	public void gitWorktreeAdd(File bareRepo, File worktreeDir, String ref, BuildOutputListener listener) throws IOException
+	{
+		worktreeDir.getParentFile().mkdirs();
+		runGitCommand(bareRepo, listener, "worktree", "add", worktreeDir.getAbsolutePath(), ref);
+	}
+
+	@Override
+	public void gitFetchAll(File repo, BuildOutputListener listener) throws IOException
+	{
+		runGitCommand(repo, listener, "fetch", "--all");
+	}
+
+	@Override
+	public void gitCheckout(File dir, String ref, BuildOutputListener listener) throws IOException
+	{
+		runGitCommand(dir, listener, "checkout", ref);
+	}
+
+	private void runGitCommand(File workingDir, BuildOutputListener listener, String... args) throws IOException
+	{
+		String[] cmd = new String[args.length + 1];
+		cmd[0] = "git";
+		System.arraycopy(args, 0, cmd, 1, args.length);
+		ProcessRunner.ProcessResult result = runner.run(cmd, workingDir, listener);
+		if (!result.isSuccess()) {
+			throw new IOException("Git command failed with exit code " + result.getExitCode());
+		}
+	}
+
+	// --- Build operations ---
+
+	@Override
+	public String getName()
+	{
+		return "Nix";
+	}
+
+	@Override
+	public BuildResult configure(File projectDir, BuildOutputListener listener) throws BuildException, IOException
+	{
+		validateEnvironment(projectDir);
+		return runNixCommand(projectDir, "./configure", listener);
+	}
+
+	@Override
+	public BuildResult build(File projectDir, BuildOutputListener listener) throws BuildException, IOException
+	{
+		validateEnvironment(projectDir);
+		ProcessRunner.ProcessResult result = runNixCommandRaw(projectDir, "NINJA_STATUS='" + BuildOutputDialog.NINJA_STATUS + "' ninja", listener);
+
+		if (result.wasCancelled()) {
+			return BuildResult.cancelled(result.getDuration());
+		}
+
+		File rom = new File(projectDir, ROM_PATH);
+		if (result.isSuccess() && rom.exists()) {
+			return BuildResult.success(result.getExitCode(), result.getDuration(), rom);
+		}
+		else {
+			String error = result.getExitCode() == 0 ? "ROM file not found" : "Build failed with exit code " + result.getExitCode();
+			return BuildResult.failure(result.getExitCode(), result.getDuration(), error);
+		}
+	}
+
+	@Override
+	public BuildResult clean(File projectDir, BuildOutputListener listener) throws BuildException, IOException
+	{
+		validateEnvironment(projectDir);
+		return runNixCommand(projectDir, "./configure --clean", listener);
+	}
+
+	@Override
+	public CompletableFuture<BuildResult> buildAsync(File projectDir, BuildOutputListener listener)
+	{
+		return CompletableFuture.supplyAsync(() -> {
+			try {
+				return build(projectDir, listener);
+			}
+			catch (BuildException | IOException e) {
+				return BuildResult.failure(-1, java.time.Duration.ZERO, e.getMessage());
+			}
+		}, Environment.getExecutor());
+	}
+
+	@Override
+	public boolean cancel()
+	{
+		return runner.cancel();
+	}
+
+	@Override
+	public boolean isBuilding()
+	{
+		return runner.isRunning();
+	}
+
+	private void validateEnvironment(File projectDir) throws BuildException
+	{
+		// Check for nix binary
+		if (!isNixInstalled()) {
+			throw new BuildException(
+				"Nix is not installed. Please install Nix from https://nixos.org/download.html\n" +
+				"Run: curl -L https://nixos.org/nix/install | sh -s -- --daemon");
+		}
+
+		File flakeFile = new File(projectDir, "flake.nix");
+		if (!flakeFile.exists()) {
+			throw new BuildException("No flake.nix found in project directory: " + projectDir.getAbsolutePath());
+		}
+	}
+
+	private boolean isNixInstalled()
+	{
+		try {
+			ProcessBuilder pb = new ProcessBuilder("which", "nix");
+			Process process = pb.start();
+			int exitCode = process.waitFor();
+			return exitCode == 0;
+		}
+		catch (IOException | InterruptedException e) {
+			return false;
+		}
+	}
+
+	private BuildResult runNixCommand(File projectDir, String command, BuildOutputListener listener) throws IOException
+	{
+		ProcessRunner.ProcessResult result = runNixCommandRaw(projectDir, command, listener);
+
+		if (result.wasCancelled()) {
+			return BuildResult.cancelled(result.getDuration());
+		}
+		else if (result.isSuccess()) {
+			return BuildResult.success(result.getExitCode(), result.getDuration(), null);
+		}
+		else {
+			return BuildResult.failure(result.getExitCode(), result.getDuration(),
+				"Command failed with exit code " + result.getExitCode());
+		}
+	}
+
+	private ProcessRunner.ProcessResult runNixCommandRaw(File projectDir, String command, BuildOutputListener listener) throws IOException
+	{
+		String[] cmd = new String[] {
+			"nix", "develop", "-c", "bash", "-c", command
+		};
+
+		return runner.run(cmd, projectDir, listener);
+	}
+}

src/main/java/project/ui/CreateProjectDialog.java

···
 import game.map.editor.ui.dialogs.DirChooser;
 import net.miginfocom.swing.MigLayout;
 import project.Project;
+import project.ProjectListing;
 import util.Logger;
 
 public class CreateProjectDialog extends JDialog
 {
-	private Project result = null;
+	private ProjectListing result = null;
 
 	private JTextField nameField;
 	private JTextField idField;
···
 	/**
 	 * Shows the dialog and returns the created project, or null if cancelled.
 	 */
-	public static Project showDialog(JFrame parent)
+	public static ProjectListing showDialog(JFrame parent)
 	{
 		CreateProjectDialog dialog = new CreateProjectDialog(parent);
 		dialog.setVisible(true);
···
 		add(nameField, "growx");
 
 		JLabel idLabel = new JLabel("ID");
-		JLabel idDesc = new JLabel("The internal name of your mod. Must be unique between all mods.");
+		JLabel idDesc = new JLabel("Unique internal identifier");
 		idDesc.setForeground(SwingUtils.getGrayTextColor());
 		SwingUtils.setFontSize(idDesc, 11);
 		add(idLabel, "split 2, gaptop 8");

src/main/java/project/ui/ProjectCellRenderer.java

···
 import javax.swing.SwingConstants;
 
 import app.SwingUtils;
-import project.Project;
+import project.ProjectListing;
 import net.miginfocom.swing.MigLayout;
 
 /**
  * Cell renderer for projects in the project list.
  * Displays project name (bold), path, and last opened time.
  */
-public class ProjectCellRenderer extends JPanel implements ListCellRenderer<Project>
+public class ProjectCellRenderer extends JPanel implements ListCellRenderer<ProjectListing>
 {
 	private final JLabel nameLabel;
 	private final JLabel pathLabel;
···
 
 	@Override
 	public Component getListCellRendererComponent(
-		JList<? extends Project> list,
-		Project project,
+		JList<? extends ProjectListing> list,
+		ProjectListing project,
 		int index,
 		boolean isSelected,
 		boolean cellHasFocus)

src/main/java/project/ui/ProjectSwitcherDialog.java

···
 import app.Themes.Theme;
 import app.config.Options;
 import dev.kdl.parse.KdlParseException;
-import project.Project;
+import project.ProjectListing;
 import project.ProjectManager;
 import game.map.editor.ui.dialogs.ChooseDialogResult;
 import game.map.editor.ui.dialogs.DirChooser;
···
 {
 	private final String TAB_PROJECTS = "Projects";
 
-	private JList<Project> list;
-	private DefaultListModel<Project> listModel;
-	private FilteredListModel<Project> filteredListModel;
+	private JList<ProjectListing> list;
+	private DefaultListModel<ProjectListing> listModel;
+	private FilteredListModel<ProjectListing> filteredListModel;
 	private JTextField filterTextField;
 	private JPopupMenu contextMenu;
 	private CardLayout cardLayout;
···
 	private final DirChooser dirChooser;
 
 	private final CountDownLatch latch = new CountDownLatch(1);
-	private Project selectedProject = null;
+	private ProjectListing selectedProject = null;
 
 	/**
-	 * Shows the project switcher and returns the selected project.
+	 * Shows the project switcher and returns the selected project listing.
 	 * Blocks until the user makes a selection or closes the window.
-	 * @return The selected project, or null if cancelled
+	 * @return The selected project listing, or null if cancelled
 	 */
-	public static Project showPrompt()
+	public static ProjectListing showPrompt()
 	{
 		ProjectSwitcherDialog window = new ProjectSwitcherDialog();
 		window.setVisible(true);
···
 		JPanel panel = new JPanel(new MigLayout("ins 16, fill, wrap"));
 
 		// Load projects
-		listModel = new DefaultListModel<>();
+		listModel = new DefaultListModel<ProjectListing>();
 		refreshProjectList();
 
 		// Create list
···
 		// Buttons
 		JButton createButton = new JButton("New Project");
 		createButton.addActionListener(e -> {
-			Project newProject = CreateProjectDialog.showDialog(this);
+			ProjectListing newProject = CreateProjectDialog.showDialog(this);
 			if (newProject != null) {
 				projectManager.recordProjectOpened(newProject);
 				refreshProjectList();
···
 	private void refreshProjectList()
 	{
 		listModel.clear();
-		List<Project> projects = projectManager.getRecentProjects();
-		for (Project project : projects) {
+		List<ProjectListing> projects = projectManager.getRecentProjects();
+		for (ProjectListing project : projects) {
 			listModel.addElement(project);
 		}
 	}
···
 	private void updateListFilter()
 	{
 		filteredListModel.setFilter(element -> {
-			Project project = (Project) element;
+			ProjectListing project = (ProjectListing) element;
 			String filterText = filterTextField.getText().toUpperCase();
 			String name = project.getName().toUpperCase();
 			String path = project.getPath().toUpperCase();
···
 
 	private void openSelectedProject()
 	{
-		Project selected = list.getSelectedValue();
+		ProjectListing selected = list.getSelectedValue();
 		if (selected == null) {
 			return;
 		}
···
 	{
 		if (dirChooser.prompt() == ChooseDialogResult.APPROVE) {
 			File selectedDir = dirChooser.getSelectedFile();
-			Project newProject;
+			ProjectListing newProject;
 			try {
-				newProject = new Project(selectedDir);
+				newProject = new ProjectListing(selectedDir);
 			} catch (IOException | KdlParseException e) {
 				Environment.showErrorMessage("Failed to open project", "The folder you selected is not a valid project: %s", e.getMessage());
 				return;
···
 
 	private void removeSelectedProject()
 	{
-		Project selected = list.getSelectedValue();
+		ProjectListing selected = list.getSelectedValue();
 		if (selected == null) {
 			return;
 		}
···
 
 	private void deleteSelectedProjectFromDisk()
 	{
-		Project selected = list.getSelectedValue();
+		ProjectListing selected = list.getSelectedValue();
 		if (selected == null) {
 			return;
 		}

src/main/resources/database/templates/blank/project.kdl

···
 description $PROJECT_DESCRIPTION
 license "CC0"
 
-engine version="0.0.0"
+engine ref="main"