@@ -65,8 +65,12 @@ sd-cli -m model.safetensors -p "a cat" --backend "diffusion=cuda0&cuda1"
 ```
 
 The module's transformer blocks are then distributed across the listed devices
-in contiguous ranges sized proportionally to each device's free memory (minus a
-compute-buffer headroom of about 2 GiB per device), and the
+in contiguous ranges sized proportionally to each device's weight capacity: its
+free memory or its `--max-vram` budget, whichever is lower, minus a
+compute-buffer headroom of about 2 GiB. Every device therefore keeps the same
+fraction of its budget for the compute buffers of the blocks it runs. If the
+proportional ranges do not fit (very uneven block sizes), each device is filled
+in turn up to its capacity instead. The
 module's graphs are executed with a `ggml_backend_sched` that runs each block
 on the device holding its weights, copying the residual stream at the range
 boundaries. The first device in the list is the module's main device: it also
 
@@ -0,0 +1,86 @@
+// Standalone check of the layer-split range planner: g++ -std=c++17 -I src scripts/layer_split_ranges_test.cpp && ./a.out
+#include <cstdio>
+#include <cstdlib>
+
+#include "core/layer_split_ranges.h"
+
+static int failures = 0;
+#define CHECK(cond)                                                     \
+    do {                                                                \
+        if (!(cond)) {                                                  \
+            std::fprintf(stderr, "FAIL %s:%d %s\n", __FILE__, __LINE__, #cond); \
+            failures++;                                                 \
+        }                                                               \
+    } while (0)
+
+static bool contiguous(const sd::LayerSplitRangesResult& r) {
+    for (size_t i = 1; i < r.device_by_segment.size(); i++) {
+        if (r.device_by_segment[i] < r.device_by_segment[i - 1]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+int main() {
+    const int64_t MB = 1024ll * 1024;
+    // 54 equal segments, 10.98 GB total, two cards with 12.6 GB weight capacity each (16 GB card budget less headroom).
+    std::vector<int64_t> segs(54, (int64_t)(10.98 * 1024 * MB / 54));
+    std::vector<int64_t> caps = {12599 * MB, 12599 * MB};
+    auto fill                 = sd::plan_layer_split_ranges_fill_first(segs, caps);
+    CHECK(fill.ok);
+    CHECK(fill.bytes_by_device[1] == 0);  // the old plan: everything on card 0
+    auto prop = sd::plan_layer_split_ranges(segs, caps);
+    CHECK(prop.ok);
+    CHECK(!prop.used_fill_first);
+    CHECK(contiguous(prop));
+    CHECK(prop.device_by_segment.front() == 0 && prop.device_by_segment.back() == 1);
+    CHECK(std::llabs(prop.bytes_by_device[0] - prop.bytes_by_device[1]) <= segs[0]);
+
+    // Unequal capacities: shares follow the capacities.
+    caps = {4000 * MB, 12000 * MB};
+    prop = sd::plan_layer_split_ranges(segs, caps);
+    CHECK(prop.ok && contiguous(prop));
+    CHECK(prop.bytes_by_device[0] <= caps[0] && prop.bytes_by_device[1] <= caps[1]);
+    CHECK(prop.bytes_by_device[0] < prop.bytes_by_device[1]);
+
+    // Exactly full: proportional must still fit (falls back to fill-first if rounding misses).
+    std::vector<int64_t> four(4, 100);
+    caps = {200, 200};
+    prop = sd::plan_layer_split_ranges(four, caps);
+    CHECK(prop.ok && prop.bytes_by_device[0] == 200 && prop.bytes_by_device[1] == 200);
+
+    // Does not fit at all: failure names the last device.
+    caps = {150, 150};
+    prop = sd::plan_layer_split_ranges(four, caps);
+    CHECK(!prop.ok);
+    CHECK(prop.failed_device == 1);
+
+    // Uneven segment sizes where the proportional plan overflows: fill-first rescues it.
+    std::vector<int64_t> uneven = {10, 10, 10, 70};
+    caps                        = {30, 70};
+    prop                        = sd::plan_layer_split_ranges(uneven, caps);
+    CHECK(prop.ok);
+    CHECK(prop.bytes_by_device[0] == 30 && prop.bytes_by_device[1] == 70);
+
+    // Unknown capacity sentinel (no free-memory report): still splits evenly.
+    caps = {INT64_MAX / 4, INT64_MAX / 4};
+    prop = sd::plan_layer_split_ranges(segs, caps);
+    CHECK(prop.ok && prop.bytes_by_device[1] > 0);
+
+    // Zero-byte segments inherit the current device and never trigger a move.
+    std::vector<int64_t> zeros = {0, 50, 0, 50, 0};
+    caps                       = {60, 60};
+    prop                       = sd::plan_layer_split_ranges(zeros, caps);
+    CHECK(prop.ok && contiguous(prop) && prop.bytes_by_device[0] == 50 && prop.bytes_by_device[1] == 50);
+
+    // Single device: same as fill-first.
+    caps = {INT64_MAX / 4};
+    prop = sd::plan_layer_split_ranges(segs, caps);
+    CHECK(prop.ok && prop.bytes_by_device.size() == 1);
+
+    if (failures == 0) {
+        std::printf("layer_split_ranges_test: all checks passed\n");
+    }
+    return failures == 0 ? 0 : 1;
+}
@@ -7,6 +7,7 @@
 #include <unordered_set>
 #include <utility>
 
+#include "core/layer_split_ranges.h"
 #include "core/util.h"
 
 namespace sd {
@@ -84,14 +85,20 @@ namespace sd {
             if (dev != nullptr) {
                 ggml_backend_dev_memory(dev, &free_bytes, &total_bytes);
             }
-            if (free_bytes > 0) {
-                capacities[i] = std::max<int64_t>((int64_t)free_bytes - compute_headroom_bytes, 0);
-            }
             size_t limit_bytes = graph_cut_layer_split_backend_vram_limit(backend_vram_limits,
                                                                           i,
                                                                           primary_backend_vram_limit);
+            // The headroom comes off whichever bound applies: an explicit --max-vram budget also has to hold the
+            // compute buffers of the segments this device runs, so weights alone may not fill it.
+            int64_t bound = -1;
+            if (free_bytes > 0) {
+                bound = (int64_t)free_bytes;
+            }
             if (limit_bytes > 0) {
-                capacities[i] = std::min<int64_t>(capacities[i], (int64_t)limit_bytes);
+                bound = bound < 0 ? (int64_t)limit_bytes : std::min<int64_t>(bound, (int64_t)limit_bytes);
+            }
+            if (bound >= 0) {
+                capacities[i] = std::max<int64_t>(bound - compute_headroom_bytes, 0);
             }
         }
         return capacities;
@@ -151,27 +158,33 @@ namespace sd {
             return param_assignments.count(param) != 0;
         });
 
-        std::vector<ggml_backend_t> backend_by_segment(plan.segments.size(), split_backends[0]);
-        size_t current_backend = 0;
-        int64_t current_used   = 0;
-        for (size_t seg_idx = 0; seg_idx < plan.segments.size(); seg_idx++) {
-            int64_t bytes = segment_param_bytes[seg_idx];
-            while (!reuse_assignments && current_backend + 1 < split_backends.size() &&
-                   bytes > 0 &&
-                   current_used + bytes > backend_capacities[current_backend]) {
-                current_backend++;
-                current_used = 0;
-            }
-            if (!reuse_assignments && bytes > 0 && current_used + bytes > backend_capacities[current_backend]) {
+        LayerSplitRangesResult ranges;
+        if (!reuse_assignments) {
+            ranges = plan_layer_split_ranges(segment_param_bytes, backend_capacities);
+            if (!ranges.ok) {
                 LOG_ERROR("%s graph-cut layer split: segment %zu needs %.1f MB on %s, but only %.1f MB is available under current VRAM limits",
                           desc,
-                          seg_idx,
-                          (current_used + bytes) / (1024.0 * 1024.0),
-                          layer_split_backend_device_display_name(split_backends[current_backend]).c_str(),
-                          backend_capacities[current_backend] / (1024.0 * 1024.0));
+                          ranges.failed_segment,
+                          ranges.failed_need / (1024.0 * 1024.0),
+                          layer_split_backend_device_display_name(split_backends[ranges.failed_device]).c_str(),
+                          backend_capacities[ranges.failed_device] / (1024.0 * 1024.0));
                 return false;
             }
-            current_used += bytes;
+            for (size_t i = 0; i < split_backends.size(); i++) {
+                LOG_INFO("%s graph-cut layer split: %s weight capacity %.1f MB (%s)",
+                         desc,
+                         layer_split_backend_device_display_name(split_backends[i]).c_str(),
+                         backend_capacities[i] / (1024.0 * 1024.0),
+                         ranges.used_fill_first ? "fill-first plan, proportional plan did not fit" : "proportional plan");
+            }
+        }
+
+        std::vector<ggml_backend_t> backend_by_segment(plan.segments.size(), split_backends[0]);
+        size_t current_backend = 0;
+        for (size_t seg_idx = 0; seg_idx < plan.segments.size(); seg_idx++) {
+            if (!reuse_assignments) {
+                current_backend = ranges.device_by_segment[seg_idx];
+            }
 
             for (ggml_tensor* param : segment_params[seg_idx]) {
                 ggml_backend_t target_backend = split_backends[current_backend];
 
@@ -0,0 +1,124 @@
+#ifndef __SD_CORE_LAYER_SPLIT_RANGES_H__
+#define __SD_CORE_LAYER_SPLIT_RANGES_H__
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace sd {
+
+    struct LayerSplitRangesResult {
+        bool ok = false;
+        // Device index per segment (contiguous, non-decreasing).
+        std::vector<size_t> device_by_segment;
+        // Weight bytes placed on each device.
+        std::vector<int64_t> bytes_by_device;
+        // On failure: the segment that did not fit, the device it was tried on and the bytes that device would need.
+        size_t failed_segment = 0;
+        size_t failed_device  = 0;
+        int64_t failed_need   = 0;
+        // True when the proportional plan did not fit and the fill-first plan was used instead.
+        bool used_fill_first = false;
+    };
+
+    // Fill-first: each device takes segments until the next one would exceed its capacity.
+    inline LayerSplitRangesResult plan_layer_split_ranges_fill_first(const std::vector<int64_t>& segment_bytes,
+                                                                     const std::vector<int64_t>& capacities) {
+        LayerSplitRangesResult r;
+        r.device_by_segment.assign(segment_bytes.size(), 0);
+        r.bytes_by_device.assign(capacities.size(), 0);
+        if (capacities.empty()) {
+            return r;
+        }
+        size_t dev   = 0;
+        int64_t used = 0;
+        for (size_t s = 0; s < segment_bytes.size(); s++) {
+            const int64_t bytes = segment_bytes[s];
+            while (dev + 1 < capacities.size() && bytes > 0 && used + bytes > capacities[dev]) {
+                dev++;
+                used = 0;
+            }
+            if (bytes > 0 && used + bytes > capacities[dev]) {
+                r.failed_segment = s;
+                r.failed_device  = dev;
+                r.failed_need    = used + bytes;
+                return r;
+            }
+            used += bytes;
+            r.device_by_segment[s] = dev;
+            r.bytes_by_device[dev] += bytes;
+        }
+        r.ok = true;
+        return r;
+    }
+
+    // Contiguous ranges sized in proportion to each device's capacity, so every device keeps the same fraction of its
+    // budget free for the compute buffers of the segments it runs. A fill-first plan packs the main device up to its
+    // weight capacity and leaves its compute buffers no room; it is only used when the proportional plan does not fit.
+    inline LayerSplitRangesResult plan_layer_split_ranges(const std::vector<int64_t>& segment_bytes,
+                                                          const std::vector<int64_t>& capacities) {
+        LayerSplitRangesResult r;
+        r.device_by_segment.assign(segment_bytes.size(), 0);
+        r.bytes_by_device.assign(capacities.size(), 0);
+        if (capacities.empty()) {
+            return r;
+        }
+        double total = 0.0;
+        for (int64_t b : segment_bytes) {
+            total += (double)(b > 0 ? b : 0);
+        }
+        double capacity_sum = 0.0;
+        std::vector<double> caps(capacities.size(), 0.0);
+        for (size_t i = 0; i < capacities.size(); i++) {
+            // An unknown capacity (very large sentinel) counts as able to hold everything.
+            caps[i] = capacities[i] > 0 ? std::min((double)capacities[i], total) : 0.0;
+            capacity_sum += caps[i];
+        }
+        if (capacities.size() == 1 || total <= 0.0 || capacity_sum <= 0.0) {
+            return plan_layer_split_ranges_fill_first(segment_bytes, capacities);
+        }
+
+        // Cumulative byte boundary at which each device's range ends.
+        std::vector<double> boundary(capacities.size(), total);
+        double acc = 0.0;
+        for (size_t i = 0; i + 1 < capacities.size(); i++) {
+            acc += total * caps[i] / capacity_sum;
+            boundary[i] = acc;
+        }
+
+        size_t dev      = 0;
+        int64_t used    = 0;
+        double consumed = 0.0;
+        bool fits       = true;
+        for (size_t s = 0; s < segment_bytes.size(); s++) {
+            const int64_t bytes = segment_bytes[s];
+            if (bytes > 0) {
+                // Move on once this segment's midpoint lies past the current device's share, or it would not fit.
+                while (dev + 1 < capacities.size() &&
+                       (consumed + bytes * 0.5 > boundary[dev] || used + bytes > capacities[dev])) {
+                    dev++;
+                    used = 0;
+                }
+                if (used + bytes > capacities[dev]) {
+                    fits = false;
+                    break;
+                }
+            }
+            used += bytes;
+            consumed += (double)(bytes > 0 ? bytes : 0);
+            r.device_by_segment[s] = dev;
+            r.bytes_by_device[dev] += bytes;
+        }
+        if (fits) {
+            r.ok = true;
+            return r;
+        }
+        LayerSplitRangesResult fallback = plan_layer_split_ranges_fill_first(segment_bytes, capacities);
+        fallback.used_fill_first        = true;
+        return fallback;
+    }
+
+}  // namespace sd
+
+#endif  // __SD_CORE_LAYER_SPLIT_RANGES_H__