Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++

Two GTX 1080s are a working PC: an 8 GB card starts Off only beside a bigger card, and a PC whose only NVIDIA cards are Pascal uses them on the CUDA 12 engine (#3655)

Niko12210351ecb11d02
diff --git a/apps/host/src/lib/gpu-roles.ts b/apps/host/src/lib/gpu-roles.ts
index 374e017c3..d1a4a1cd9 100644
--- a/apps/host/src/lib/gpu-roles.ts
+++ b/apps/host/src/lib/gpu-roles.ts
@@ -89,17 +89,20 @@ export function pickMain(cs: RoleCard[]): { main: RoleCard | null; why: MainWhy
export type OffWhy = 'cannot_run' | 'igpu' | 'small' | 'helper';
export interface Recommendation { roles: Roles; main: number | null; why: MainWhy; reasons: Record<number, MainWhy | OffWhy> }
-/** The best card is Main; every other card starts as Helper, EXCEPT a card with 8 GB or less, built-in graphics beside a real card, and a card the engine cannot run: those start Off. */
+/** The best card is Main; every other card starts as Helper, EXCEPT a card with 8 GB or less when a bigger card is there (or it has under 4 GB), built-in graphics beside a real card, and a card the engine cannot run: those start Off. */
export function recommend(cards: RoleCard[] | null | undefined, vendor?: string | null): Recommendation {
const cs = rows(cards, vendor);
const { main, why } = pickMain(cs);
const roles: Roles = {}, reasons: Recommendation['reasons'] = {};
+ // An 8 GB card is a poor Helper beside a bigger card, but a perfectly good one when 8 GB is all there is: two GTX 1080s are a working
+ // 16 GB pool (#3655). A card with 8 GB or less starts Off only when a bigger usable card is there, or when it is too small to help.
+ const hasBigger = cs.some(c => canRun(c) && !shares(c) && rnd(mem(c)) > OFF_AT_OR_BELOW_GB);
for (const c of cs) {
const i = c.index;
if (main && c === main) { roles[i] = 'main'; reasons[i] = why; }
else if (!canRun(c)) { roles[i] = 'off'; reasons[i] = 'cannot_run'; }
else if (shares(c) && main) { roles[i] = 'off'; reasons[i] = 'igpu'; }
- else if (rnd(mem(c)) <= OFF_AT_OR_BELOW_GB) { roles[i] = 'off'; reasons[i] = 'small'; }
+ else if (rnd(mem(c)) <= OFF_AT_OR_BELOW_GB && (hasBigger || mem(c) < MIN_CARD_GB)) { roles[i] = 'off'; reasons[i] = 'small'; }
else { roles[i] = 'helper'; reasons[i] = 'helper'; }
}
return { roles, main: main ? main.index : null, why, reasons };
diff --git a/apps/host/tests/native-gpu-roles.test.mjs b/apps/host/tests/native-gpu-roles.test.mjs
index 569b4e953..bed5e5588 100644
--- a/apps/host/tests/native-gpu-roles.test.mjs
+++ b/apps/host/tests/native-gpu-roles.test.mjs
@@ -74,3 +74,22 @@ test('roles that make no sense are refused with a plain line', async () => {
assert.match(nope.error, /detected graphics cards/);
} finally { await f.cleanup(); }
});
+
+test('"Tune this model" keeps a two-card role map exactly as the person set it, in the file and in the engine it starts (#3655)', async () => {
+ const f = nativeFixture();
+ try {
+ await f.control.refresh(true);
+ const path = join(f.repo, 'strata-iq2_xs.json');
+ const config = JSON.parse(readFileSync(path, 'utf8'));
+ Object.assign(config, { gpu: [0, 1], gpu_order: 'as_given', gpu_roles: { 0: 'helper', 1: 'main' }, gpu_cards: { 0: 'GTX 1080', 1: 'GTX 1080' } });
+ writeFileSync(path, JSON.stringify(config));
+ await f.control.refresh(true);
+ const tuned = await finishJob(f.control, f.control.operation('tune', { model: 'iq2_xs', profile: 'performance', calibrate: false }).id);
+ assert.equal(tuned.state, 'done', tuned.error);
+ const after = JSON.parse(readFileSync(path, 'utf8'));
+ for (const key of ['gpu', 'gpu_order', 'gpu_roles', 'gpu_cards']) assert.deepEqual(after[key], config[key], `${key} in the settings file is untouched by Tune`);
+ const started = written(f, tuned);
+ assert.deepEqual(started.gpu, [0, 1], 'and the engine Tune loads runs on both cards');
+ assert.deepEqual(started.gpu_roles, { 0: 'helper', 1: 'main' });
+ } finally { await f.cleanup(); }
+});
diff --git a/docs/MULTI_GPU.md b/docs/MULTI_GPU.md
index 5ebae7fe7..123654286 100644
--- a/docs/MULTI_GPU.md
+++ b/docs/MULTI_GPU.md
@@ -57,7 +57,7 @@ the picture reader. (Older versions of this page said "the first is the main one
**Recommended roles** (the same rule in the app, `strata launch` and setup; `strata_control/gpu_roles.py`): the faster card
is Main (speed is multiprocessors x max clock, the engine's own measure; cards within 5% are the same card, and the one with
more memory wins, then the lower number; two identical cards: the highest number is Main, so the engine order stays 0, 1 as it always was; a card with clearly more memory beats a faster one that is at least half as fast).
-Every other card starts as Helper, except a card with **8 GB or less** (Off), built-in graphics beside a card with memory of
+Every other card starts as Helper, except a card with **8 GB or less** when a bigger card is there (Off; with only 8 GB cards, say two GTX 1080, the second one is a Helper), built-in graphics beside a card with memory of
its own (Off) and a card the engine cannot run (Off). Every role is one click (the app), one key (`strata launch`: M, H, O;
R goes back to the recommendation) or one line (below).
@@ -89,7 +89,7 @@ as Main = the last card, Helper = the first, the rest Off. The recommendation it
recommended again; a card you add after choosing roles starts Off. Docker: `GPU_ROLES=1=main,0=helper` is passed as `--gpu-roles`.
**One rule for which cards count** (`strata_control/gpu_fit.py` keeps the memory arithmetic): not an integrated chip beside
-a real card, at least 4 GB of graphics memory to be listed, 8 GB or less starts Off. The arithmetic is the app's `fitOn`;
+a real card, at least 4 GB of graphics memory to be listed, 8 GB or less starts Off beside a bigger card. The arithmetic is the app's `fitOn`;
each extra card of a split costs an estimated 2 GB of its own buffers.
**Choosing the cards without roles** (at setup or at any start):
diff --git a/setup.py b/setup.py
index bf800d3c3..bd058e488 100644
--- a/setup.py
+++ b/setup.py
@@ -1663,7 +1663,7 @@ def choose_roles(a, found) -> list:
roles = dict(gpu_roles.recommend(cards)["roles"])
say()
say(" Strata recommends a role for each graphics card. Main does the last steps of every answer; a Helper holds part of the model;")
- say(" Off leaves the card alone (a card with 8 GB or less starts Off). Details: docs/MULTI_GPU.md.")
+ say(" Off leaves the card alone (a card with 8 GB or less starts Off beside a bigger card). Details: docs/MULTI_GPU.md.")
by = {c["index"]: c for c in cards}
for i in sorted(roles):
say(f" GPU {i + 1} {gpu_roles.short_name(by[i]):<22} {by[i]['vram_gb']:>4.0f} GB {roles[i].capitalize()}")
diff --git a/strata_control/gpu_roles.py b/strata_control/gpu_roles.py
index 33df9fe43..47438ddd0 100644
--- a/strata_control/gpu_roles.py
+++ b/strata_control/gpu_roles.py
@@ -107,12 +107,15 @@ def pick_main(cs: list[dict]) -> tuple[dict | None, str]:
def recommend(cards: list[dict], vendor: str | None = None) -> dict[str, Any]:
"""The recommended roles: {"roles": {index: role}, "main": index|None, "why": code, "reasons": {index: code}}.
- The best card is Main, every other card starts as Helper, EXCEPT a card with 8 GB or less, an integrated chip beside a card with memory of
+ The best card is Main, every other card starts as Helper, EXCEPT a card with 8 GB or less when a bigger card is there (or it has under 4 GB), an integrated chip beside a card with memory of
its own, and a card the engine cannot run: those start Off."""
cs = rows(cards, vendor)
main, why = pick_main(cs)
roles: dict[int, str] = {}
reasons: dict[int, str] = {}
+ # An 8 GB card is a poor Helper beside a bigger card, but a perfectly good one when 8 GB is all there is: two GTX 1080s are a working
+ # 16 GB pool (#3655). A card with 8 GB or less starts Off only when a bigger usable card is there, or when it is too small to help.
+ has_bigger = any(_can_run(c) and not _shares(c) and round(_mem(c)) > OFF_AT_OR_BELOW_GB for c in cs)
for c in cs:
i = _idx(c)
if main is not None and c is main:
@@ -121,7 +124,7 @@ def recommend(cards: list[dict], vendor: str | None = None) -> dict[str, Any]:
roles[i], reasons[i] = "off", "cannot_run"
elif _shares(c) and main is not None:
roles[i], reasons[i] = "off", "igpu"
- elif round(_mem(c)) <= OFF_AT_OR_BELOW_GB:
+ elif round(_mem(c)) <= OFF_AT_OR_BELOW_GB and (has_bigger or _mem(c) < gpu_fit.MIN_CARD_GB):
roles[i], reasons[i] = "off", "small"
else:
roles[i], reasons[i] = "helper", "helper"
diff --git a/tests/data/gpu_roles_vectors.json b/tests/data/gpu_roles_vectors.json
index 45c2eff12..23555b418 100644
--- a/tests/data/gpu_roles_vectors.json
+++ b/tests/data/gpu_roles_vectors.json
@@ -9,6 +9,8 @@
"igpu_only": [{"index": 0, "name": "AMD Radeon 780M", "vram_gb": 0, "integrated": true, "speed": 12}],
"bigger_slower": [{"index": 0, "name": "NVIDIA GeForce RTX 3090", "vram_gb": 24, "speed": 90}, {"index": 1, "name": "NVIDIA GeForce RTX 4070", "vram_gb": 12, "speed": 100}],
"small_second": [{"index": 0, "name": "NVIDIA GeForce RTX 4070 Ti", "vram_gb": 12, "speed": 100}, {"index": 1, "name": "NVIDIA GeForce RTX 3070", "vram_gb": 8, "speed": 70}],
+ "two_8gb": [{"index": 0, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8, "speed": 50}, {"index": 1, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8, "speed": 50}],
+ "tiny_second": [{"index": 0, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8, "speed": 50}, {"index": 1, "name": "NVIDIA GeForce GT 1030", "vram_gb": 2, "speed": 10}],
"cannot": [{"index": 0, "name": "NVIDIA GeForce GTX 1060", "vram_gb": 6, "usable": false, "problem": "too old"}, {"index": 1, "name": "NVIDIA GeForce RTX 4070 Ti", "vram_gb": 12, "speed": 100}],
"nospeed": [{"index": 0, "name": "NVIDIA GeForce RTX 3060", "vram_gb": 12}, {"index": 1, "name": "NVIDIA GeForce RTX 3090", "vram_gb": 24}]
},
@@ -21,6 +23,8 @@
{"hw": "igpu_only", "roles": {"0": "main"}, "main": 0, "why": "only"},
{"hw": "bigger_slower", "roles": {"0": "main", "1": "helper"}, "main": 0, "why": "memory"},
{"hw": "small_second", "roles": {"0": "main", "1": "off"}, "main": 0, "why": "faster"},
+ {"hw": "two_8gb", "roles": {"0": "helper", "1": "main"}, "main": 1, "why": "same"},
+ {"hw": "tiny_second", "roles": {"0": "main", "1": "off"}, "main": 0, "why": "only"},
{"hw": "cannot", "roles": {"0": "off", "1": "main"}, "main": 1, "why": "only"},
{"hw": "nospeed", "roles": {"0": "helper", "1": "main"}, "main": 1, "why": "memory"}
],
diff --git a/tests/terminal/test_make_guard.py b/tests/terminal/test_make_guard.py
index 0337f7464..cfa0e7e8f 100644
--- a/tests/terminal/test_make_guard.py
+++ b/tests/terminal/test_make_guard.py
@@ -147,6 +147,28 @@ class Decision(unittest.TestCase):
self.assertIn("another make", str(caught.exception))
+class Pascal(unittest.TestCase):
+ """#3655: a GTX 1080 (sm_61) is a working machine on the CUDA 12 engine; the CUDA 13 build has no code for it and is never chosen."""
+
+ FEED = [package("cuda", "cuda13", ("sm_75", "sm_86", "sm_89", "sm_120")),
+ feedmod._engine_package({"version": "0.1.47", "platform": WIN, "backend": "cuda", "variant": "cuda12", "min_driver": {"nvidia": "525.60"},
+ "archs": ["sm_60", "sm_61", "sm_70", "sm_75", "sm_80", "sm_86", "sm_89"], "min_runtime": None, "build_id": "b-12",
+ "format": "zip", "url": "e-12.zip", "size": 10, "sha256": "a" * 64, "manifest_sha256": "b" * 64,
+ "installed_bytes": 20, "notes": ""})]
+
+ def hardware(self, archs):
+ return {"platform": WIN, "backend": "cuda", "runtime": None, "nvidia_driver": "581.15", "cuda_archs": archs, "gfx": [], "gpu_names": []}
+
+ def test_two_gtx_1080_get_the_cuda_12_engine(self):
+ best, reasons = feedmod.select_engine(self.FEED, self.hardware(["sm_61", "sm_61"]))
+ self.assertEqual(best.variant, "cuda12")
+ self.assertTrue(any("cuda13" in r or "sm_75" in r for r in reasons), "the CUDA 13 build is refused for the card")
+
+ def test_a_newer_card_still_gets_the_newest_build(self):
+ best, _ = feedmod.select_engine(self.FEED, self.hardware(["sm_86"]))
+ self.assertEqual(best.variant, "cuda13")
+
+
class Host(unittest.TestCase):
def test_the_app_shows_the_sentence_not_the_no_engine_for_this_card_text(self):
text = (Path(__file__).resolve().parents[2] / "apps" / "host" / "server" / "updates.mjs").read_text(encoding="utf-8")
diff --git a/tools/strata_mcp.py b/tools/strata_mcp.py
index defaed0aa..1b63a0f47 100644
--- a/tools/strata_mcp.py
+++ b/tools/strata_mcp.py
@@ -922,6 +922,16 @@ class Strata:
amd = []
if not WIN and not amd and shutil.which("rocm-smi"):
amd = rocm_smi_gpus()
+ # A PC whose only NVIDIA cards are Pascal / Volta (two GTX 1080s) and that has no AMD card Strata can use: setup runs them with the
+ # CUDA 12 engine (old_gpus_opt_in), so the app must not call it "no supported graphics card" and start both cards Off (#3655).
+ # A PC with a newer card keeps recommending that one; naming an old card is still the opt-in.
+ try:
+ if S and nv and S.old_gpus_opt_in(nv, (), None, any(g.get("usable") for g in amd)):
+ for g in nv:
+ if S.sm60_card(g["arch"]) and g.get("problem") and "older than the RTX 20" in str(g["problem"]):
+ g["problem"], g["usable"], g["engine_variant"] = None, True, "cuda12"
+ except Exception: # noqa: BLE001 - the hardware page never breaks over this
+ pass
if any(g.get("usable") for g in nv):
for g in amd: # a Ryzen's integrated graphics beside an NVIDIA card: the engine runs on the NVIDIA card
if g.get("uma") and g.get("usable"):
diff --git a/tools/test_strata_mcp.py b/tools/test_strata_mcp.py
index 7716051ca..7b2292a7c 100644
--- a/tools/test_strata_mcp.py
+++ b/tools/test_strata_mcp.py
@@ -817,6 +817,42 @@ class MixedGraphics(unittest.TestCase):
with mock.patch.object(M.sys, "platform", "linux"), mock.patch.object(M, "WIN", False), mock.patch.object(S, "gpus", lambda: []), mock.patch.object(S, "amd_gpus", lambda: [dict(g) for g in igpu]), mock.patch.object(S, "amd_problem", lambda g: None):
self.assertTrue(s._hardware()["gpus"][0]["usable"])
+ def test_two_gtx_1080_are_a_working_pc_on_the_cuda_12_engine(self):
+ """#3655: Pascal cards were flagged 'not supported' and both started Off, so the app said no card was usable. When Pascal is all the PC has
+ (and no AMD card), setup runs them with the CUDA 12 engine, and the hardware report now says so; a newer card keeps the old behaviour."""
+ s = M.Strata(HERE.parent)
+ S = s.setup_module()
+ pascal = [{"index": 0, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8.0, "arch": "61", "driver": "581.15"},
+ {"index": 1, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8.0, "arch": "61", "driver": "581.15"}]
+ igpu = [{"index": 0, "name": "AMD Radeon(TM) Graphics", "vram_gb": 0.5, "arch": "gfx90c", "uma": True}]
+ patches = (mock.patch.object(M.sys, "platform", "linux"), mock.patch.object(M, "WIN", False),
+ mock.patch.object(S, "amd_gpus", lambda: [dict(g) for g in igpu]), mock.patch.object(S, "amd_problem", lambda g: "integrated graphics"),
+ mock.patch.dict(M.os.environ, {"STRATA_EXPERIMENTAL_SM60": ""}), mock.patch.object(S, "OLD_GPUS", None))
+ with mock.patch.object(S, "gpus", lambda: [dict(g) for g in pascal]):
+ for p in patches:
+ p.start()
+ try:
+ hw = s._hardware()
+ finally:
+ for p in reversed(patches):
+ p.stop()
+ nv = [g for g in hw["gpus"] if g["vendor"] == "nvidia"]
+ self.assertEqual([(g["usable"], g["problem"], g.get("engine_variant")) for g in nv], [(True, None, "cuda12")] * 2)
+ # a newer card in the PC: Pascal stays an opt-in, the ready-made engine is recommended
+ mixed = [{"index": 0, "name": "NVIDIA GeForce GTX 1080", "vram_gb": 8.0, "arch": "61", "driver": "581.15"},
+ {"index": 1, "name": "NVIDIA GeForce RTX 3060", "vram_gb": 12.0, "arch": "86", "driver": "581.15"}]
+ with mock.patch.object(S, "gpus", lambda: [dict(g) for g in mixed]):
+ for p in patches:
+ p.start()
+ try:
+ hw = s._hardware()
+ finally:
+ for p in reversed(patches):
+ p.stop()
+ by = {g["name"]: g for g in hw["gpus"] if g["vendor"] == "nvidia"}
+ self.assertFalse(by["NVIDIA GeForce GTX 1080"]["usable"])
+ self.assertTrue(by["NVIDIA GeForce RTX 3060"]["usable"])
+
def test_an_amd_card_the_installed_engine_has_no_code_for_is_not_usable(self):
"""#3203: the engine package lists its GPU code; a card outside it is flagged unusable with the plain reason, so no list offers it."""
status = {"usable": True, "engine": {"backend": "hip", "archs": ["gfx1200", "gfx1201"]}}