@@ -821,6 +821,25 @@ eq("filter: deprecated hidden by default", passesFilters({ status: "deprecated"
   eq("engine: url round-trips", readState("?engine=unity", URL_DEF, { engine: ["any", ...Object.keys(EN)] }).engine, "unity");
   eq("engine: written to the url", stateQuery({ ...URL_DEF, engine: "godot" }, URL_DEF), "engine=godot");
   eq("engine: unknown value ignored", readState("?engine=cryengine", URL_DEF, { engine: ["any", ...Object.keys(EN)] }).engine, "any");
+  const { nativeEngines: ne, worksInEngine: wie, placementKey: pk } = await import("./search.mjs");
+  const on = (formats, engine) => passesFilters({ status: "active", formats }, { ...URL_DEF, engine });
+  eq("engine: godot hides an Unreal project", on(["Unreal"], "godot"), false);
+  eq("engine: godot hides an Unreal plugin with its C++", on(["unreal-plugin", "C++"], "godot"), false);
+  eq("engine: unity hides a Godot addon", on(["godot-addon"], "unity"), false);
+  eq("engine: unity hides a Godot project", on(["gdshader", "Godot"], "unity"), false);
+  eq("engine: unreal hides the Godot editor", on(["desktop-app", "Godot"], "unreal"), false);
+  eq("engine: godot hides a Unity-only entry", on(["Unity"], "godot"), false);
+  eq("engine: an addon stays native despite asset formats", ne({ formats: ["godot-addon", "gdextension", "EXR", "PNG"] }).join(), "godot");
+  eq("engine: a sound pack with a Godot demo is agnostic", on(["WAV", "Godot"], "unity"), true);
+  eq("engine: a multi-engine export is agnostic", ne({ formats: ["Unity", "Godot", "JSON", "PNG"] }).length, 0);
+  eq("engine: a pack for two engines stays under either", on(["Unity", "Unreal"], "unity"), true);
+  eq("engine: godot keeps Godot addons", on(["godot-addon"], "godot"), true);
+  eq("engine: no formats is agnostic", wie({}, "godot"), true);
+  eq("engine: an unknown engine hides nothing", wie({ formats: ["Unreal"] }, "pico-8"), true);
+  eq("engine: native format ranks first", er({ formats: ["unreal-plugin"] }, "unreal"), 0);
+  eq("placement: key changes with the engine", pk({ sort: "name", engine: "godot" }, { ranked: false, group: true, list: [] }) === pk({ sort: "name", engine: "unity" }, { ranked: false, group: true, list: [] }), false);
+  eq("placement: key ignores filters under a plain sort", pk({ sort: "name", engine: "any", q: "x" }, { ranked: false, group: false, list: [{ id: "a" }] }), pk({ sort: "name" }, { ranked: false, group: false, list: [] }));
+  eq("placement: a ranked key follows the list", pk({ sort: "name" }, { ranked: true, group: false, list: [{ id: "a" }, { id: "b" }] }), "rank:false:a,b");
 }
 eq("filter: commercial-only keeps varies", passesFilters({ status: "active", commercial: "varies" }, { ...URL_DEF, commercialOnly: true }), true);
 eq("filter: commercial-only drops unknown", passesFilters({ status: "active", commercial: "unknown" }, { ...URL_DEF, commercialOnly: true }), false);
@@ -1337,6 +1356,7 @@ eq("search: q from the URL is capped", readState(`?q=${"a".repeat(5000)}`, { q:
   eq("order: engine=godot puts godot-tagged entries first", ids([...E].sort(sorterFor({ sort: "verified", engine: "godot" }))), "acdb");
   eq("order: engine=unreal puts engine-locked entries first", ids([...E].sort(sorterFor({ sort: "name", engine: "unreal" }))), "dabc");
   eq("order: engineRank with an unknown engine is 0", engineRank(E[0], "pico-8"), 0);
+  eq("order: a ranked search breaks score ties by engine", ids(run({ engine: "unreal" }, { score: (e) => (e.id === "b" ? 0 : 1), hasQuery: true }).list), "dac");
   eq("order: SORTS.name ties nothing", SORTS.name(E[0], E[0]), 0);
 
   const filtered = run({ category: "audio" }, { passes: (e) => e.id !== "d" });
 
@@ -78,7 +78,7 @@ export function passesFilters(entry, state, formatGroups = {}) {
   if (state.noAttr && entry.attribution_required !== false) return false;
   if (state.perspective !== "any" && entry.camera_perspective !== state.perspective) return false;
   if (state.license !== "any" && entry.licenseFamily !== state.license) return false;
-  if (state.engine && state.engine !== "any" && entry.engine_lock && entry.engine_lock !== state.engine) return false;
+  if (state.engine && state.engine !== "any" && !worksInEngine(entry, state.engine)) return false;
   if (state.format !== "any") {
     const wanted = formatGroups[state.format]?.formats || [];
     if (!(entry.formats || []).some((f) => wanted.includes(f))) return false;
@@ -88,21 +88,57 @@ export function passesFilters(entry, state, formatGroups = {}) {
 
 /** Choice params: URL key -> state field. `allowed` supplies each field's legal values. */
 /**
- * The engine filter. An entry locked to another engine (engine_lock) is
- * hidden; entries tagged for the chosen engine sort first. Everything else
- * is engine-agnostic and stays listed.
+ * The engine filter. An entry is hidden when it only works in another
+ * engine: its licence is locked to one (engine_lock), or everything it
+ * ships is native to one (nativeEngines). Entries made for the chosen
+ * engine sort first. Everything else is engine-agnostic and stays listed.
+ *
+ * `formats` are the engine-native formats: a project, addon, plugin or
+ * shader that only that engine opens.
  */
 export const ENGINES = {
-  godot: { label: "Godot", tags: ["godot", "godot-4"] },
-  unity: { label: "Unity", tags: ["unity"] },
-  unreal: { label: "Unreal Engine", tags: ["unreal-engine", "unreal"] },
+  godot: { label: "Godot", tags: ["godot", "godot-4"], formats: ["Godot", "godot-addon", "gdextension", "gdshader"] },
+  unity: { label: "Unity", tags: ["unity"], formats: ["Unity"] },
+  unreal: { label: "Unreal Engine", tags: ["unreal-engine", "unreal"], formats: ["Unreal", "unreal-plugin"] },
 };
 
-/** 0 when an entry is made for `engine` (tagged for it or locked to it), else 1. */
+/**
+ * Formats that ride along with an engine-native one without making an entry
+ * portable: an Unreal plugin's C++ source, the Godot editor's desktop app.
+ */
+const ENGINE_COMPANION_FORMATS = new Set(["C++", "desktop-app"]);
+
+/**
+ * The engines an entry is native to, or [] when it is engine-agnostic.
+ * Plugins and addons (godot-addon, gdextension, unreal-plugin) make an
+ * entry native whatever else it lists, since the files only load in that
+ * engine. Otherwise an entry is native only when every format it lists
+ * belongs to an engine: [WAV, Godot] is a sound pack with a Godot demo,
+ * usable anywhere, while [gdshader, Godot] is a Godot project.
+ */
+export function nativeEngines(entry) {
+  const formats = entry.formats || [];
+  const engines = Object.keys(ENGINES).filter((k) => formats.some((f) => ENGINES[k].formats.includes(f)));
+  if (!engines.length) return [];
+  if (formats.some((f) => ["godot-addon", "gdextension", "unreal-plugin"].includes(f))) return engines;
+  const portable = formats.some((f) => !ENGINE_COMPANION_FORMATS.has(f) && !Object.values(ENGINES).some((e) => e.formats.includes(f)));
+  return portable ? [] : engines;
+}
+
+/** False when the entry only works in an engine other than `engine`: by licence (engine_lock) or by format. */
+export function worksInEngine(entry, engine) {
+  if (!ENGINES[engine]) return true;
+  if (entry.engine_lock && entry.engine_lock !== engine) return false;
+  const native = nativeEngines(entry);
+  return !native.length || native.includes(engine);
+}
+
+/** 0 when an entry is made for `engine` (tagged for it, native to it or locked to it), else 1. */
 export function engineRank(entry, engine) {
   const e = ENGINES[engine];
   if (!e) return 0;
   if (entry.engine_lock === engine) return 0;
+  if ((entry.formats || []).some((f) => e.formats.includes(f))) return 0;
   return (entry.tags || []).some((t) => e.tags.includes(t)) ? 0 : 1;
 }
 
@@ -161,11 +197,25 @@ export function computeResults(entries, state, { passes, score, hasQuery }) {
   for (const e of pool) counts.set(e.category, (counts.get(e.category) || 0) + 1);
   const list = state.category === "all" ? pool.slice() : pool.filter((e) => e.category === state.category);
   const ranked = state.sort === "name" && hasQuery;
-  if (ranked) list.sort((a, b) => scores.get(b.id) - scores.get(a.id) || SORTS.name(a, b));
-  else list.sort(sorterFor(state));
+  if (ranked) {
+    // Equal scores fall back to the name sort, engine picks first.
+    const tie = sorterFor({ ...state, sort: "name" });
+    list.sort((a, b) => scores.get(b.id) - scores.get(a.id) || tie(a, b));
+  } else list.sort(sorterFor(state));
   return { list, counts, total: pool.length, ranked };
 }
 
+/**
+ * When this key changes, app.js re-places every card. Under a plain sort
+ * the order of all cards depends only on the grouping, the sort and the
+ * engine (filters just toggle visibility); a ranked search reorders on every
+ * new result list.
+ */
+export function placementKey(state, { ranked, group, list }) {
+  if (ranked) return `rank:${group}:${list.map((e) => e.id).join(",")}`;
+  return `${group ? "group" : "flat"}:${state.sort}:${state.engine || "any"}`;
+}
+
 const CHOICES = [
   ["cat", "category"],
   ["sort", "sort"],
 
@@ -1,4 +1,4 @@
-import { closestEntries, computeResults as computeResultsFor, passesFilters as passes, queryTests as compileQuery, readState, scoreFields, searchFields, shouldGroup as shouldGroupFor, slugOf, sorterFor, SORTS, stateQuery, ENGINES } from "./search.js";
+import { closestEntries, computeResults as computeResultsFor, passesFilters as passes, placementKey, queryTests as compileQuery, readState, scoreFields, searchFields, shouldGroup as shouldGroupFor, slugOf, sorterFor, SORTS, stateQuery, ENGINES } from "./search.js";
 import { CARD_LIMIT, LIST_LIMIT, commercialLabel, entryCardHtml, escapeHtml, groupHeadingHtml, groupMoreHtml, PERSPECTIVE_LABELS } from "./cards.mjs";
 import { installViewToggles } from "./views.js";
 
@@ -415,11 +415,10 @@ import { installViewToggles } from "./views.js";
     if (!preview) ensureAllNodes();
     else ensurePreviewNodes(list);
 
-    // Under a plain sort the order of all nodes is fixed, so filtering only
-    // toggles visibility. A ranked search reorders on every change.
-    const key = ranked
-      ? `rank:${group}:${list.map((e) => e.id).join(",")}`
-      : `${group ? "group" : "flat"}:${state.sort}`;
+    // Under a plain sort the order of all nodes depends only on the sort
+    // and the engine, so filtering only toggles visibility. A ranked search
+    // reorders on every change (search.mjs placementKey).
+    const key = placementKey(state, { ranked, group, list });
     if (key !== placedKey) {
       placedKey = key;
       const shown = new Set(list.map((e) => e.id));
 
@@ -140,7 +140,7 @@ <h2 id="catalog-title">Catalog</h2>
                 <option value="any">Any</option>
               </select>
             </label>
-            <label class="check sort-field" title="Hides entries licensed for another engine only, and lists ones made for this engine first">
+            <label class="check sort-field" title="Hides projects, addons and plugins for another engine and assets licensed for one engine only, and lists ones made for this engine first">
               <span>Engine</span>
               <select id="engine">
                 <option value="any">Any</option>