diff --git a/CMakeLists.txt b/CMakeLists.txt
index a79ce9a..153f683 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -89,6 +89,8 @@ endif()
 
 # --- core library ----------------------------------------------------------
 add_library(trellis_core STATIC
+  src/trellis_debug.cpp
+  src/trellis_sched.cpp
   src/trellis_model.cpp
   src/dit.cpp
   src/flow_runner.cpp
@@ -263,6 +265,10 @@ add_executable(trellis-smoke src/smoke_test.cpp)
 target_link_libraries(trellis-smoke PRIVATE trellis_core)
 set_target_properties(trellis-smoke PROPERTIES BUILD_RPATH "${GGML_RPATH}")
 
+add_executable(trellis-devices src/list_devices.cpp)
+target_link_libraries(trellis-devices PRIVATE trellis_core)
+set_target_properties(trellis-devices PROPERTIES BUILD_RPATH "${GGML_RPATH}")
+
 add_executable(trellis-decode-replay src/decode_replay.cpp)
 target_link_libraries(trellis-decode-replay PRIVATE trellis_core)
 set_target_properties(trellis-decode-replay PROPERTIES BUILD_RPATH "${GGML_RPATH}")
diff --git a/README.md b/README.md
index 6336599..1f2b744 100644
--- a/README.md
+++ b/README.md
@@ -118,6 +118,13 @@ The most useful ones:
 | `--atlas PX` | UV atlas size (default 2048 @1024 / 1024 @512) |
 | `--box-uv` | voxel-native 6-way box projection instead of the default xatlas unwrap (O(faces), faster, looser packing) |
 | `--seed N` | RNG seed |
+| `--steps N` | flow sampler steps (default 12; lower values are useful for backend bring-up) |
+| `--backend NAME` | select a registered ggml backend explicitly, such as `HTP`, `Vulkan`, or `CPU` |
+| `--threads N` | CPU threads (defaults to the detected hardware thread count) |
+| `--sched on\|off` | enable multi-backend scheduling; automatic for the partial-coverage HTP backend |
+| `--vulkan-fallback` | with HTP, try Vulkan before the CPU for unsupported operations |
+| `--fa-fast` / `--fa-f32` | select fast F16 or BF16/F32 FlashAttention accumulation |
+| `--verbose` | graph timings and progress heartbeats for long-running stages |
 | `--require-gpu` | fail instead of falling back to the (very slow, RAM-hungry) CPU path |
 
 The postprocess matches the reference pipeline op for op (see
@@ -132,8 +139,8 @@ inpaint port, and exported as a GLB with smooth normals and **lossy-WebP texture
 (`EXT_texture_webp`; PNG fallback when built with `-DTRELLIS_WEBP=OFF`). Output
 quality is at parity with the reference CUDA postprocess on identical inputs.
 
-`TRELLIS_DBG_*` environment variables toggle developer debug logging only; no
-behavior-driving environment variables remain — use the flags above.
+Prefer the CLI flags above. The corresponding `TRELLIS_*` environment variables remain
+available for test binaries and backwards-compatible automation.
 
 ### trellis-server
 
@@ -193,7 +200,10 @@ The 1024 cascade runs on a 16 GB card thanks to **FlashAttention with padded K/V
 the sparse-structure stage, and at the HR token count (≈53k) ggml's tiled FA NaN'd on
 the unpadded last key-tile — zero-padding K/V to a 256 multiple + BF16 fixes both.
 f16 compute is the default and matches torch (`--f32` forces f32; `--no-fa` restores
-the plain-softmax path for A/B testing).
+the plain-softmax path for A/B testing). On the Qualcomm HTP backend, FlashAttention
+defaults to F16 K/V and fast accumulation after a 12-step quality gate showed a 3.53x
+end-to-end speedup with identical sparse voxels; `--fa-f32` restores BF16 K/V + F32
+accumulation. Other backends retain BF16/F32 by default (`--fa-fast` forces the HTP mode).
 
 Every neural component is validated against PyTorch (the `trellis-test-*` binaries +
 `tools/ref_*.py`): SS sampler matches torch to rel 4.3e-3 (exact voxel match), DiT
@@ -264,6 +274,35 @@ See `.github/workflows/release.yml` for the exact flags the release binaries use
 6.0/6.1/7.0); the standalone installers select it automatically for devices such
 as the Tesla P100.
 
+### Windows ARM64 and Qualcomm HTP
+
+The native ARM64 helper configures clang for Windows-on-ARM and can build CPU, Vulkan,
+or Hexagon variants. For HTP, install the Hexagon SDK using the official
+[llama.cpp Windows Snapdragon guide](https://github.com/ggml-org/llama.cpp/blob/master/docs/backend/snapdragon/windows.md).
+The trimmed `hexagon-sdk-v6.6.0.0-arm64-wos.tar.xz` package described there is sufficient;
+extract it anywhere and pass the directory containing `hexagon_sdk.json` to
+`-HexagonSdk`:
+
+```powershell
+scripts\build-arm64.ps1 -Backend cpu
+scripts\build-arm64.ps1 -Backend vulkan
+scripts\build-arm64.ps1 -Backend hexagon -HexagonSdk C:\Qualcomm\Hexagon_SDK\6.6.0.0
+```
+
+Windows requires the generated HTP Ops libraries and catalog to be signed with a trusted
+certificate before the NPU driver will load them. The linked guide documents the required
+driver, certificate, test-signing, and `HEXAGON_HTP_CERT` setup.
+
+List registered devices with `trellis-devices --init`. A typical NPU run uses:
+
+```powershell
+build-arm64-hexagon\trellis-cli.exe input.png output.glb `
+  --models models\q4 --backend HTP --sched on --verbose
+```
+
+Add `--vulkan-fallback` when the same build includes Vulkan and unsupported HTP operations
+should prefer the GPU over the CPU.
+
 ## Layout
 
 ```
diff --git a/include/flow_runner.h b/include/flow_runner.h
index 970b412..3d904e7 100644
--- a/include/flow_runner.h
+++ b/include/flow_runner.h
@@ -1,5 +1,6 @@
 // Flow-DiT runner (dense grid or sparse voxel) + FlowEuler guidance-interval sampler.
 #pragma once
+#include <memory>
 #include <vector>
 #include <array>
 #include <functional>
@@ -14,6 +15,7 @@ typedef struct ggml_gallocr* ggml_gallocr_t;
 
 namespace trellis {
 struct Model;
+class GraphExec;
 
 struct SamplerParams {
     int   steps             = 12;
@@ -38,11 +40,14 @@ class DitRunner {
     int N() const { return N_; }
 private:
     const Model& m_; DiTParams p_; int N_, Lc_;
-    ggml_context* ctx_ = nullptr; ggml_cgraph* g_ = nullptr; ggml_gallocr_t alloc_ = nullptr;
+    ggml_context* ctx_ = nullptr; ggml_cgraph* g_ = nullptr;
+    // Owns graph allocation and execution for both direct and scheduled backends.
+    std::unique_ptr<GraphExec> exec_;
     ggml_tensor *gh0_, *gtf_, *gcond_, *gcos_, *gsin_, *gout_;
     std::vector<float> rcos_, rsin_;   // re-uploaded each forward (gallocr may reuse input buffers)
     std::map<std::string, ggml_tensor*> inter_;   // [dbg] named intermediates for NaN localization
     bool dbg_nan_ = false, dbg_done_ = false;
+    int  n_fwd_ = 0;
 };
 
 // Dense factory: RoPE from R^3 grid (ij meshgrid, z fastest). N = R^3.
diff --git a/include/trellis_args.h b/include/trellis_args.h
index ffbc9c6..0a400aa 100644
--- a/include/trellis_args.h
+++ b/include/trellis_args.h
@@ -9,8 +9,10 @@ namespace trellis {
 // binaries (which don't parse args) keep their historical TRELLIS_* behavior.
 extern bool g_sparse_cast_f32;  // defined in sparse.cpp        (TRELLIS_F32)
 extern bool g_no_fa;            // defined in dit.cpp           (TRELLIS_NOFA)
+extern int  g_fa_fast;          // defined in dit.cpp: -1 auto/env, 0 BF16/F32, 1 F16/fast
 extern bool g_require_gpu;      // defined in trellis_model.cpp (TRELLIS_REQUIRE_GPU)
 extern int  g_cpu_threads;      // defined in trellis_model.cpp (TRELLIS_THREADS)
+extern std::string g_backend;   // defined in trellis_model.cpp (TRELLIS_BACKEND)
 
 // Every knob for one TRELLIS.2 image->3D run. Resolved as default -> environment
 // (the historical TRELLIS_* / GSS / GSH names) -> CLI flag, with the CLI winning.
@@ -24,6 +26,11 @@ struct TrellisParams {
     std::string host   = "127.0.0.1";                           // trellis-server only
     int      port = 8080;                                       // trellis-server only
     int      gpu  = 0;                                          // >=0 GPU index, <0 CPU
+    std::string backend;        // force a ggml backend by name ("Vulkan", "HTP",
+                                // "CPU", ...); empty = auto-select. --gpu N then indexes
+                                // within that backend's devices.
+    int threads = 0;            // CPU backend thread count; 0 = auto (all cores).
+                                // ggml's own default is GGML_DEFAULT_N_THREADS == 4.
     uint32_t seed = 0;
 
     bool cascade    = true;     // 1024 cascade (default); --res 512 selects the light path
@@ -51,8 +58,8 @@ struct TrellisParams {
     int  webp     = -1;         // GLB texture encoding: -1 auto (WebP if built with it), 1 on, 0 off (PNG)
     bool f32      = false;      // f32 sparse-conv compute
     bool no_fa    = false;      // disable FlashAttention (manual softmax)
+    int  fa_fast  = -1;         // FA precision: -1 auto (fast on HTP), 0 BF16/F32, 1 F16/fast
     bool require_gpu = false;   // refuse CPU fallback if no GPU is usable
-    int  threads  = 0;          // CPU backend thread count; 0 = all cores
     float gss = 7.5f;           // sparse-structure guidance strength
     float gsh = 7.5f;           // shape-SLAT guidance strength
     bool voxply = false;        // dump out/myvox.ply              (debug)
@@ -60,6 +67,17 @@ struct TrellisParams {
     bool dump_bg = false;       // also write the bg-removal cutout as <out>_cutout.png
     bool bg_only = false;       // background removal only: write the cutout and skip the rest
 
+    int  steps    = 0;          // flow sampler steps; 0 = model default (12). Lowering this
+                                //   trades output quality for turnaround and is meant for
+                                //   backend bring-up: a CPU and an NPU run at the same low
+                                //   step count are still directly comparable to each other.
+    int  sched = -1;            // multi-backend scheduler: -1 auto (on unless the primary
+                                // backend is the CPU), 0 off, 1 on. Required for partial
+                                // op-coverage accelerators like the Hexagon NPU.
+    int  vulkan_fallback = -1;   // add Vulkan between HTP and CPU: -1 environment/default,
+                                // 0 disabled, 1 enabled
+    bool verbose = false;       // --verbose: per-stage timings, graph shapes, and a
+                                // heartbeat while a backend compute is in flight
     bool help = false;          // --help requested
 
     // 512 -> light single-res path; 1024/1536 -> cascade with that HR target.
diff --git a/include/trellis_debug.h b/include/trellis_debug.h
new file mode 100644
index 0000000..cd9cf09
--- /dev/null
+++ b/include/trellis_debug.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "ggml.h"
+#include "ggml-backend.h"
+
+#include <chrono>
+#include <string>
+
+namespace trellis {
+
+// --verbose / TRELLIS_VERBOSE=1 enables graph timings and progress heartbeats.
+bool verbose();
+void set_verbose(bool v);
+
+// Scoped wall-clock timer. Logs "<label>: <n> ms" on destruction when verbose().
+class ScopedTimer {
+public:
+    explicit ScopedTimer(std::string label);
+    ~ScopedTimer();
+    double ms() const;
+
+private:
+    std::string                                    label_;
+    std::chrono::steady_clock::time_point          t0_;
+};
+
+// Instrumented graph execution for a single backend or scheduler.
+ggml_status compute_graph(ggml_backend_t backend, ggml_cgraph* graph, const char* label);
+ggml_status compute_graph_sched(ggml_backend_sched_t sched, ggml_cgraph* graph, const char* label);
+
+// Log a graph's shape (node/leaf counts, and the op histogram at verbose level 2).
+void log_graph(const char* label, const ggml_cgraph* graph);
+
+}  // namespace trellis
diff --git a/include/trellis_model.h b/include/trellis_model.h
index 54313cd..7b7bec1 100644
--- a/include/trellis_model.h
+++ b/include/trellis_model.h
@@ -11,6 +11,7 @@ struct ggml_context;
 struct gguf_context;
 struct ggml_backend;
 struct ggml_backend_buffer;
+struct ggml_backend_sched;
 
 namespace trellis {
 
@@ -20,7 +21,15 @@ struct Model {
     gguf_context*         gguf   = nullptr;  // KV metadata + tensor table
     ggml_context*         meta   = nullptr;  // owns the ggml_tensor structs
     ggml_backend*         backend = nullptr; // where weights live
-    ggml_backend_buffer*  buffer = nullptr;  // the weight buffer
+    ggml_backend_buffer*  buffer = nullptr;  // weights in the backend's default buffer
+    // Optional backend-specific buffer for repacked quantized matrix weights.
+    ggml_backend_buffer*  buffer_repack = nullptr;
+    ggml_context*         ctx_host   = nullptr;   // owns the tensors in `buffer`
+    ggml_context*         ctx_repack = nullptr;   // owns the tensors in `buffer_repack`
+    // Multi-backend scheduler over [backend, ...fallbacks]. Non-null only when the
+    // primary backend has partial op coverage (e.g. the Hexagon NPU), in which case every
+    // graph runs through it so unsupported ops land on a backend that can execute them.
+    ggml_backend_sched*   sched  = nullptr;
     std::map<std::string, ggml_tensor*> tensors;
     std::string arch;          // general.architecture
     std::string config_json;   // trellis.config_json (raw model config)
diff --git a/include/trellis_sched.h b/include/trellis_sched.h
new file mode 100644
index 0000000..554ee1c
--- /dev/null
+++ b/include/trellis_sched.h
@@ -0,0 +1,78 @@
+#pragma once
+
+#include "ggml.h"
+#include "ggml-alloc.h"
+#include "ggml-backend.h"
+
+namespace trellis {
+
+struct Model;
+
+// Multi-backend execution.
+//
+// trellis historically ran every graph with ggml_backend_graph_compute() on a single
+// backend, which requires that backend to support *every* op in the graph. That holds for
+// CUDA and Vulkan, whose op coverage is near-complete. It does not hold for the Qualcomm
+// Hexagon NPU: the HTP skel implements a subset of ops and rejects tensors larger than
+// VTCM, and with no scheduler those ops are simply never executed -- the run reports
+// "dsp-rsp: UNKNOWN" and continues with undefined data until the DSP queue desynchronizes.
+//
+// ggml_backend_sched assigns each node to a backend that actually supports it, keeping
+// weight-consuming ops on the backend that owns the weights and inserting copies where a
+// node has to run elsewhere. That is what makes partial-coverage accelerators usable.
+//
+// Mode: -1 auto (on unless the primary backend is the CPU, which needs no fallback),
+//        0 off (legacy single-backend path), 1 on.
+void set_sched_mode(int mode);
+
+// Add Vulkan between an HTP primary and the CPU catch-all. Mode -1 uses the
+// TRELLIS_VULKAN_FALLBACK environment fallback, 0 disables it, and 1 enables it.
+void set_vulkan_fallback_mode(int mode);
+
+bool sched_enabled_for(ggml_backend_t primary);
+
+// Fallback backends shared process-wide. Created on demand, never freed; they outlive the
+// per-stage Models that borrow them.
+ggml_backend_t fallback_cpu_backend();
+
+// Build a scheduler for a freshly loaded model's backend, or nullptr when the single
+// backend path is sufficient. Called by Model::load; the Model owns the result.
+ggml_backend_sched_t make_sched(ggml_backend_t primary);
+
+// Applies --threads / TRELLIS_THREADS to a CPU backend. Defined in trellis_model.cpp;
+// declared here because the scheduler's CPU fallback needs it too -- a fallback stuck on
+// ggml's 4-thread default would quietly become the bottleneck.
+void tune_cpu_threads(ggml_backend_t b);
+
+// Allocation + execution strategy for one graph.
+//
+// Both paths follow the same contract, which mirrors what the call sites already did:
+//   GraphExec ex(m);
+//   ex.alloc(graph);                       // must precede input uploads
+//   ggml_backend_tensor_set(input, ...);   // graph tensors exist only after alloc
+//   ex.compute(graph, "label");
+class GraphExec {
+public:
+    explicit GraphExec(const Model& m);
+    ~GraphExec();
+
+    GraphExec(const GraphExec&)            = delete;
+    GraphExec& operator=(const GraphExec&) = delete;
+
+    // Allocate a graph. Call again only when the graph itself changes.
+    bool alloc(ggml_cgraph* graph);
+
+    ggml_status compute(ggml_cgraph* graph, const char* label);
+
+    // Bytes of compute buffer, for the existing [stage-alloc] diagnostics.
+    size_t buffer_size() const;
+
+    bool uses_sched() const { return sched_ != nullptr; }
+
+private:
+    ggml_backend_t       backend_ = nullptr;
+    ggml_gallocr_t       galloc_  = nullptr;   // single-backend path
+    ggml_backend_sched_t sched_   = nullptr;   // borrowed from the Model
+};
+
+}  // namespace trellis
diff --git a/scripts/build-arm64.ps1 b/scripts/build-arm64.ps1
new file mode 100644
index 0000000..ea18bf7
--- /dev/null
+++ b/scripts/build-arm64.ps1
@@ -0,0 +1,201 @@
+<#
+.SYNOPSIS
+  Native Windows-on-ARM64 build of trellis.cpp.
+
+.DESCRIPTION
+  ggml refuses MSVC for ARM CPU kernels (src/ggml-cpu/CMakeLists.txt:105), so this
+  builds with clang using the GNU-style driver targeting arm64-pc-windows-msvc --
+  the same approach upstream llama.cpp uses for Windows ARM64.
+
+  By default ggml probes the local CPU and falls back to -mcpu=native on Windows.
+  Pass -Arch to disable native detection and target an explicit, redistributable
+  ARM architecture instead.
+
+.EXAMPLE
+  scripts\build-arm64.ps1 -Backend cpu
+  scripts\build-arm64.ps1 -Backend vulkan
+  scripts\build-arm64.ps1 -Backend hexagon -HexagonSdk C:\Qualcomm\Hexagon_SDK\6.4.0.0
+#>
+[CmdletBinding()]
+param(
+    [ValidateSet('cpu', 'vulkan', 'hexagon')]
+    [string]$Backend = 'cpu',
+
+    [string]$BuildDir = '',
+
+    # Empty = let ggml probe the CPU itself. Its probe actually *runs* test programs
+    # (check_cxx_source_runs), so it verifies features rather than trusting -mcpu=native,
+    # which over-reports. Pass an explicit arch (e.g. 'armv8.7-a+dotprod+i8mm+fp16') to
+    # pin it instead -- needed for redistributable builds.
+    [string]$Arch = '',
+
+    [string]$HexagonSdk = $env:HEXAGON_SDK_ROOT,
+
+    [int]$Jobs = 0,
+
+    [switch]$Clean,
+
+    # Extra -D flags passed straight to cmake, e.g. -ExtraArgs '-DGGML_VULKAN_DEBUG=ON'
+    [string[]]$ExtraArgs = @()
+)
+
+$ErrorActionPreference = 'Stop'
+
+# A shell started before the Vulkan SDK was installed will not have VULKAN_SDK in its
+# process environment, so fall back to the machine-level value and then to a scan.
+function Resolve-VulkanSdk {
+    if ($env:VULKAN_SDK -and (Test-Path $env:VULKAN_SDK)) { return }
+    $machine = [Environment]::GetEnvironmentVariable('VULKAN_SDK', 'Machine')
+    if ($machine -and (Test-Path $machine)) { $env:VULKAN_SDK = $machine; return }
+    $found = Get-ChildItem 'C:\VulkanSDK' -Directory -ErrorAction SilentlyContinue |
+             Sort-Object Name -Descending | Select-Object -First 1
+    if ($found) { $env:VULKAN_SDK = $found.FullName; return }
+    throw "Vulkan SDK not found. Install the Windows ARM64 SDK from https://sdk.lunarg.com/"
+}
+
+$repo = Split-Path -Parent $PSScriptRoot
+if (-not $BuildDir) { $BuildDir = Join-Path $repo "build-arm64-$Backend" }
+$repo = [IO.Path]::GetFullPath($repo).TrimEnd('\')
+$BuildDir = [IO.Path]::GetFullPath($BuildDir)
+if ($Jobs -le 0) { $Jobs = [Environment]::ProcessorCount }
+
+# ---- locate Visual Studio ---------------------------------------------------
+$vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
+if (-not (Test-Path $vswhere)) { throw "vswhere.exe not found; is Visual Studio installed?" }
+$vsroot = & $vswhere -latest -products * -property installationPath
+if (-not $vsroot) { throw "no Visual Studio installation found" }
+
+$vcvarsall = Join-Path $vsroot 'VC\Auxiliary\Build\vcvarsall.bat'
+if (-not (Test-Path $vcvarsall)) { throw "vcvarsall.bat not found under $vsroot" }
+
+# ---- import the arm64 developer environment into this session ---------------
+Write-Host "[build] importing arm64 developer environment" -ForegroundColor Cyan
+$envDump = cmd /c "`"$vcvarsall`" arm64 >nul 2>&1 && set"
+if ($LASTEXITCODE -ne 0) { throw "vcvarsall.bat arm64 failed" }
+foreach ($line in $envDump) {
+    if ($line -match '^([^=]+)=(.*)$') { Set-Item -Path "Env:\$($Matches[1])" -Value $Matches[2] }
+}
+
+# VS ships cmake/ninja but does not put them on PATH.
+$cmakeDir = Join-Path $vsroot 'Common7\IDE\CommonExtensions\Microsoft\CMake'
+$env:PATH = "$cmakeDir\CMake\bin;$cmakeDir\Ninja;$env:PATH"
+
+if (-not (Get-Command cl.exe -ErrorAction SilentlyContinue)) {
+    throw "cl.exe not on PATH. Install the 'MSVC v14.x - C++ ARM64/ARM64EC build tools' component."
+}
+
+# ---- locate clang -----------------------------------------------------------
+$clang = $null
+foreach ($c in @(
+        (Join-Path $vsroot 'VC\Tools\Llvm\ARM64\bin\clang.exe'),
+        (Join-Path $vsroot 'VC\Tools\Llvm\bin\clang.exe'),
+        (Join-Path $vsroot 'VC\Tools\Llvm\x64\bin\clang.exe'),
+        'C:\Program Files\LLVM\bin\clang.exe')) {
+    if (Test-Path $c) { $clang = $c; break }
+}
+if (-not $clang) {
+    $onPath = Get-Command clang.exe -ErrorAction SilentlyContinue
+    if ($onPath) { $clang = $onPath.Source }
+}
+if (-not $clang) {
+    throw @"
+clang not found. ggml cannot build its ARM CPU backend with MSVC.
+Install either:
+  * VS component  Microsoft.VisualStudio.Component.VC.Llvm.Clang, or
+  * standalone LLVM for Windows-on-ARM  (winget install LLVM.LLVM)
+"@
+}
+$clangxx = Join-Path (Split-Path $clang) 'clang++.exe'
+if (-not (Test-Path $clangxx)) { $clangxx = $clang }
+Write-Host "[build] clang: $clang" -ForegroundColor Cyan
+
+# ---- backend-specific cmake arguments --------------------------------------
+$cmakeArgs = @(
+    '-B', $BuildDir,
+    '-G', 'Ninja',
+    '-DCMAKE_BUILD_TYPE=Release',
+    "-DCMAKE_C_COMPILER=$($clang -replace '\\','/')",
+    "-DCMAKE_CXX_COMPILER=$($clangxx -replace '\\','/')",
+    '-DCMAKE_C_COMPILER_TARGET=arm64-pc-windows-msvc',
+    '-DCMAKE_CXX_COMPILER_TARGET=arm64-pc-windows-msvc',
+    '-DGGML_OPENMP=OFF'
+)
+
+if ($Arch) {
+    $cmakeArgs += '-DGGML_NATIVE=OFF'
+    $cmakeArgs += "-DGGML_CPU_ARM_ARCH=$Arch"
+} else {
+    # ggml will warn "ARM -march/-mcpu not found" because its probe reads /dev/null,
+    # which does not exist on Windows. Harmless: it falls back to -mcpu=native and the
+    # per-feature checks that follow are real runtime tests.
+    $cmakeArgs += '-DGGML_NATIVE=ON'
+}
+
+switch ($Backend) {
+    'cpu' { }
+    'vulkan' {
+        Resolve-VulkanSdk
+        $cmakeArgs += '-DGGML_VULKAN=ON'
+    }
+    'hexagon' {
+        if (-not $HexagonSdk) {
+            throw "Hexagon SDK path not given. Pass -HexagonSdk <path> or set HEXAGON_SDK_ROOT."
+        }
+        if (-not (Test-Path $HexagonSdk)) { throw "Hexagon SDK not found at: $HexagonSdk" }
+
+        # The trimmed Windows-on-Snapdragon SDK records the compiler path in
+        # hexagon_sdk.json. The SDK's top-level CMake also expects PREBUILT_LIB_DIR
+        # before ggml configures its per-DSP external projects.
+        $sdkConfig = Join-Path $HexagonSdk 'hexagon_sdk.json'
+        if (-not (Test-Path $sdkConfig)) { throw "hexagon_sdk.json not found under: $HexagonSdk" }
+        $sdkMetadata = Get-Content -LiteralPath $sdkConfig -Raw | ConvertFrom-Json
+        $toolsInfo = $sdkMetadata.root.tools.info |
+                     Where-Object name -EQ 'Hexagon Tools' |
+                     Select-Object -First 1
+        if (-not $toolsInfo.path) { throw "Hexagon Tools path not found in: $sdkConfig" }
+        $hexagonTools = Join-Path $HexagonSdk $toolsInfo.path
+        if (-not (Test-Path $hexagonTools)) { throw "Hexagon Tools not found at: $hexagonTools" }
+
+        # Vulkan alongside Hexagon: ops the NPU cannot take fall back to Adreno
+        # rather than all the way to the CPU.
+        if ($env:VULKAN_SDK) { $cmakeArgs += '-DGGML_VULKAN=ON' }
+        $cmakeArgs += '-DGGML_HEXAGON=ON'
+        $cmakeArgs += "-DHEXAGON_SDK_ROOT=$($HexagonSdk -replace '\\','/')"
+        $cmakeArgs += "-DHEXAGON_TOOLS_ROOT=$($hexagonTools -replace '\\','/')"
+        $cmakeArgs += '-DPREBUILT_LIB_DIR=toolv19_v81'
+    }
+}
+
+$cmakeArgs += $ExtraArgs
+
+if ($Clean -and (Test-Path $BuildDir)) {
+    $insideRepo = $BuildDir.StartsWith($repo + [IO.Path]::DirectorySeparatorChar,
+                                       [StringComparison]::OrdinalIgnoreCase)
+    $buildLeaf = Split-Path -Leaf $BuildDir
+    if (-not $insideRepo -or -not $buildLeaf.StartsWith('build-')) {
+        throw "refusing to clean unexpected build directory: $BuildDir"
+    }
+    Write-Host "[build] removing $BuildDir" -ForegroundColor Yellow
+    Remove-Item -LiteralPath $BuildDir -Recurse -Force
+}
+
+Push-Location $repo
+# cmake and ninja write progress and warnings to stderr. Under $ErrorActionPreference =
+# 'Stop' PowerShell turns any native stderr line into a terminating NativeCommandError,
+# which aborts the build on a harmless warning. Judge these by exit code instead.
+$prevEAP = $ErrorActionPreference
+$ErrorActionPreference = 'Continue'
+try {
+    Write-Host "[build] configure ($Backend) -> $BuildDir" -ForegroundColor Cyan
+    & cmake @cmakeArgs
+    if ($LASTEXITCODE -ne 0) { throw "cmake configure failed ($LASTEXITCODE)" }
+
+    Write-Host "[build] compiling with $Jobs jobs" -ForegroundColor Cyan
+    & cmake --build $BuildDir -j $Jobs
+    if ($LASTEXITCODE -ne 0) { throw "build failed ($LASTEXITCODE)" }
+
+    Write-Host "[build] done -> $BuildDir" -ForegroundColor Green
+} finally {
+    $ErrorActionPreference = $prevEAP
+    Pop-Location
+}
diff --git a/scripts/fetch-models.ps1 b/scripts/fetch-models.ps1
new file mode 100644
index 0000000..f662487
--- /dev/null
+++ b/scripts/fetch-models.ps1
@@ -0,0 +1,102 @@
+<#
+.SYNOPSIS
+  Download the TRELLIS.2 GGUF weights.
+
+.DESCRIPTION
+  install/install.ps1 fetches weights, but it is bundled with an x64-only runtime
+  download. This does just the weights, so it works on ARM64 where we build the
+  runtime ourselves.
+
+  Downloads are resumable: an interrupted run can simply be re-run, and files that
+  already match the published size are skipped.
+
+.EXAMPLE
+  scripts\fetch-models.ps1 -Quant q4
+  scripts\fetch-models.ps1 -Quant q8 -Dest D:\trellis-models
+#>
+[CmdletBinding()]
+param(
+    # "" = f16 (~16.5 GB), q8 (~9.5 GB), q4 (~6 GB)
+    [ValidateSet('', 'q8', 'q4')]
+    [string]$Quant = 'q4',
+
+    [string]$Dest = ''
+)
+
+$ErrorActionPreference = 'Stop'
+
+$repo = Split-Path -Parent $PSScriptRoot
+if (-not $Dest) { $Dest = Join-Path $repo "models\$(if ($Quant) { $Quant } else { 'f16' })" }
+
+$base = 'https://huggingface.co/ilintar/trellis2-gguf/resolve/main'
+$path = if ($Quant) { "$Quant/" } else { '' }
+
+$models = @(
+    'birefnet.gguf', 'dinov3.gguf',
+    'ss_flow.gguf', 'ss_dec.gguf',
+    'shape_flow_512.gguf', 'shape_flow_1024.gguf', 'shape_dec.gguf',
+    'tex_flow_512.gguf', 'tex_flow_1024.gguf', 'tex_dec.gguf'
+)
+
+New-Item -ItemType Directory -Force -Path $Dest | Out-Null
+Write-Host "[fetch] quant: $(if ($Quant) { $Quant } else { 'f16' })   dest: $Dest" -ForegroundColor Cyan
+
+# HF serves these LFS files from a CDN redirect, and the redirect response's own
+# Content-Length (a few dozen bytes) is NOT the file size. The real size comes from
+# HF's X-Linked-Size header. Returns -1 when the size cannot be established, in which
+# case the caller skips size verification rather than guessing.
+function Get-RemoteSize([string]$url) {
+    try {
+        $r = Invoke-WebRequest -Uri $url -Method Head -UseBasicParsing -MaximumRedirection 5
+        foreach ($h in @('X-Linked-Size', 'Content-Length')) {
+            if ($r.Headers.Keys -contains $h) {
+                $v = [int64](@($r.Headers[$h])[0])
+                if ($v -gt 1MB) { return $v }     # anything smaller is a redirect/pointer body
+            }
+        }
+    } catch { }
+    return -1
+}
+
+$total = 0L
+foreach ($m in $models) {
+    $url = "$base/$path$m"
+    $out = Join-Path $Dest $m
+
+    $remote = Get-RemoteSize $url
+    if (Test-Path $out) {
+        $have = (Get-Item $out).Length
+        if ($remote -gt 0 -and $have -eq $remote) {
+            Write-Host "[fetch] skip $m ($([math]::Round($have/1MB)) MB, already complete)" -ForegroundColor DarkGray
+            $total += $have
+            continue
+        }
+        if ($remote -lt 0 -and $have -gt 1MB) {
+            Write-Warning "cannot confirm remote size for $m; keeping existing $([math]::Round($have/1MB)) MB file (delete it to force a re-download)"
+            $total += $have
+            continue
+        }
+        Write-Host "[fetch] re-downloading $m (have $have, want $remote)" -ForegroundColor Yellow
+        Remove-Item $out -Force
+    }
+
+    $sizeNote = if ($remote -gt 0) { "$([math]::Round($remote/1MB)) MB" } else { 'unknown size' }
+    Write-Host "[fetch] $m ($sizeNote)" -ForegroundColor Cyan
+
+    # BITS is resumable and does not buffer the whole body in memory the way
+    # Invoke-WebRequest does -- which matters for the 2 GB+ flow models.
+    try {
+        Start-BitsTransfer -Source $url -Destination $out -Description "trellis $m" -ErrorAction Stop
+    } catch {
+        Write-Warning "BITS failed for $m ($($_.Exception.Message)); falling back to Invoke-WebRequest"
+        Invoke-WebRequest -Uri $url -OutFile $out -UseBasicParsing
+    }
+
+    $got = (Get-Item $out).Length
+    if ($remote -gt 0 -and $got -ne $remote) {
+        throw "size mismatch for ${m}: got $got, expected $remote"
+    }
+    $total += $got
+}
+
+Write-Host "[fetch] done -- $([math]::Round($total/1GB, 2)) GB in $Dest" -ForegroundColor Green
diff --git a/src/birefnet.cpp b/src/birefnet.cpp
index 8ab8a76..8d76dd8 100644
--- a/src/birefnet.cpp
+++ b/src/birefnet.cpp
@@ -2,6 +2,8 @@
 // roll / attention mask are precomputed on the host as gather/scatter index arrays + an additive
 // mask, applied via ggml_get_rows. Validated against tools/ref_birefnet.py dumps.
 #include "birefnet.h"
+#include "trellis_debug.h"
+#include "trellis_sched.h"
 #include "deform_conv.h"
 #include "trellis_model.h"
 #include "ggml.h"
@@ -33,17 +35,12 @@ static std::vector<std::vector<float>> run_graph(const Model& m, ggml_context* c
                       std::vector<std::pair<T*, const void*>> ins, size_t nodes = 16384) {
     ggml_cgraph* g = ggml_new_graph_custom(c, nodes, false);
     for (T* o : outs) { ggml_set_output(o); ggml_build_forward_expand(g, o); }
-    ggml_gallocr_t a = ggml_gallocr_new(ggml_backend_get_default_buffer_type(m.backend));
-    if (!ggml_gallocr_alloc_graph(a, g)) throw std::runtime_error("birefnet alloc");
-    if (getenv("TRELLIS_DBG_ALLOC"))
-        fprintf(stderr, "      [birefnet-alloc] %-48s nodes=%d buffer=%.3f GB\n",
-                outs.empty() ? "" : ggml_get_name(outs.front()), ggml_graph_n_nodes(g),
-                ggml_gallocr_get_buffer_size(a, 0) / 1e9);
+    trellis::GraphExec ex(m);
+    if (!ex.alloc(g)) throw std::runtime_error("birefnet alloc");
     for (auto& [t, d] : ins) ggml_backend_tensor_set(t, d, 0, ggml_nbytes(t));
-    if (ggml_backend_graph_compute(m.backend, g) != GGML_STATUS_SUCCESS) throw std::runtime_error("birefnet compute");
+    if (ex.compute(g, "birefnet") != GGML_STATUS_SUCCESS) throw std::runtime_error("birefnet compute");
     std::vector<std::vector<float>> r;
-    for (T* o : outs) r.push_back(tensor_to_f32(o));
-    ggml_gallocr_free(a);
+    for (T* o : outs) r.push_back(tensor_to_f32(o));   // read before ex releases the buffers
     return r;
 }
 
diff --git a/src/deform_conv_vk.cpp b/src/deform_conv_vk.cpp
index 380f0ea..f7cf885 100644
--- a/src/deform_conv_vk.cpp
+++ b/src/deform_conv_vk.cpp
@@ -66,6 +66,29 @@ std::mutex g_mu;
 
 #define VKCHK(x) do { if ((x) != VK_SUCCESS) return false; } while (0)
 
+// A translation layer such as Mesa Dozen (Vulkan-on-D3D12) enumerates the *same*
+// physical GPU as the native driver, reporting the same device type and the same
+// device-local heap size. A type+heap heuristic therefore cannot separate them, and on
+// a tie the later-enumerated one wins -- which on Snapdragon sent BiRefNet's deformable
+// conv through D3D12 emulation instead of the native Adreno driver. ggml's own device
+// selection deprioritizes these by driver ID; mirror that here.
+bool is_translation_layer(VkPhysicalDevice pd, const VkPhysicalDeviceProperties& props) {
+    if (props.apiVersion < VK_API_VERSION_1_2) return false;   // driverID needs 1.2
+    VkPhysicalDeviceDriverProperties drv{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES};
+    VkPhysicalDeviceProperties2 p2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2};
+    p2.pNext = &drv;
+    vkGetPhysicalDeviceProperties2(pd, &p2);
+    switch (drv.driverID) {
+#ifdef VK_DRIVER_ID_MESA_DOZEN
+        case VK_DRIVER_ID_MESA_DOZEN:  return true;   // Vulkan on D3D12
+#endif
+#ifdef VK_DRIVER_ID_MOLTENVK
+        case VK_DRIVER_ID_MOLTENVK:    return true;   // Vulkan on Metal
+#endif
+        default:                       return false;
+    }
+}
+
 bool pick_device() {
     uint32_t n = 0;
     if (vkEnumeratePhysicalDevices(g.instance, &n, nullptr) != VK_SUCCESS || n == 0) return false;
@@ -82,9 +105,12 @@ bool pick_device() {
         // as a huge device-local heap and would win a size-only heuristic while being
         // CPU-slow. Rank real GPUs first; tie-break by device-local heap size.
         if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) continue;
-        int rank = props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU   ? 3
-                 : props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU ? 2
-                 : props.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU    ? 1 : 0;
+        // Any native GPU outranks a translation layer, but the layer still ranks above
+        // nothing so it remains usable when it is the only device present.
+        int rank = is_translation_layer(pd, props)                              ? 0
+                 : props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU     ? 4
+                 : props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU   ? 3
+                 : props.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU      ? 2 : 1;
 
         uint32_t qn = 0;
         vkGetPhysicalDeviceQueueFamilyProperties(pd, &qn, nullptr);
diff --git a/src/dinov3.cpp b/src/dinov3.cpp
index 41bfd50..5d1adf7 100644
--- a/src/dinov3.cpp
+++ b/src/dinov3.cpp
@@ -1,5 +1,7 @@
 #include "dinov3.h"
 #include "trellis_model.h"
+#include "trellis_debug.h"
+#include "trellis_sched.h"
 #include "ggml.h"
 #include "ggml-backend.h"
 #include "ggml-alloc.h"
@@ -103,14 +105,14 @@ std::vector<float> dinov3_encode(const Model& m, const std::vector<float>& chw,
 
     ggml_cgraph* g = ggml_new_graph_custom(c, 16384, false);
     ggml_build_forward_expand(g, x);
-    ggml_gallocr_t alloc = ggml_gallocr_new(ggml_backend_get_default_buffer_type(m.backend));
-    if (!ggml_gallocr_alloc_graph(alloc, g)) throw std::runtime_error("dinov3: alloc failed");
+    trellis::GraphExec ex(m);
+    if (!ex.alloc(g)) throw std::runtime_error("dinov3: alloc failed");
     ggml_backend_tensor_set(img,  chw.data(), 0, chw.size() * 4);
     ggml_backend_tensor_set(gcos, rcos.data(), 0, rcos.size() * 4);
     ggml_backend_tensor_set(gsin, rsin.data(), 0, rsin.size() * 4);
-    if (ggml_backend_graph_compute(m.backend, g) != GGML_STATUS_SUCCESS) throw std::runtime_error("dinov3: compute failed");
+    if (ex.compute(g, "dinov3") != GGML_STATUS_SUCCESS) throw std::runtime_error("dinov3: compute failed");
     std::vector<float> out = tensor_to_f32(x);   // [D, Ntok] ggml -> flat d + D*tok
-    ggml_gallocr_free(alloc); ggml_free(c);
+    ggml_free(c);
     return out;
 }
 
diff --git a/src/dit.cpp b/src/dit.cpp
index bc0c413..adc4682 100644
--- a/src/dit.cpp
+++ b/src/dit.cpp
@@ -1,8 +1,10 @@
 #include "dit.h"
 #include "trellis_model.h"
 #include "ggml.h"
+#include "ggml-backend.h"
 
 #include <algorithm>
+#include <cctype>
 #include <cmath>
 #include <cstdlib>
 #include <string>
@@ -17,6 +19,7 @@ static bool g_cast_f32 = false;   // set per build_dit_dense call
 // Bounds the peak regardless of Lq, which is what made FA necessary in the first place.
 static constexpr int64_t kAttnChunkBytes = 1024ll * 1024 * 1024;
 bool g_no_fa = false;             // --no-fa; set by trellis_run
+int  g_fa_fast = -1;              // auto backend/env; CLI/server may resolve to 0 or 1
 
 static T* lin(ggml_context* c, const Model& m, const std::string& p, T* x) {
     T* w = m.get(p + ".weight");
@@ -84,7 +87,17 @@ static T* build_pad_mask(ggml_context* c, int64_t Lk_real, int64_t Lq) {
 }
 
 // SDPA over heads. q:[hd,nh,Lq]  k,v:[hd,nh,Lk] -> [d_model, Lq].  `mask`: optional [Lk_pad,Lq] F16.
-static T* sdpa(ggml_context* c, T* q, T* k, T* v, int d_model, T* mask = nullptr) {
+static bool model_backend_is_htp(const Model& m) {
+    const char* name = m.backend ? ggml_backend_name(m.backend) : nullptr;
+    const std::string backend = name ? name : "";
+    return backend.size() >= 3 &&
+           std::tolower((unsigned char)backend[0]) == 'h' &&
+           std::tolower((unsigned char)backend[1]) == 't' &&
+           std::tolower((unsigned char)backend[2]) == 'p';
+}
+
+static T* sdpa(ggml_context* c, const Model& m, T* q, T* k, T* v,
+               int d_model, T* mask = nullptr) {
     const float scale = 1.0f / std::sqrt((float)q->ne[0]);
     // FlashAttention: a fused, tiled SDPA that never materialises the [Lk,Lq,nh] score
     // matrix — O(N) memory instead of O(N^2). That score buffer is exactly what OOMs the
@@ -118,10 +131,15 @@ static T* sdpa(ggml_context* c, T* q, T* k, T* v, int d_model, T* mask = nullptr
     // --no-fa falls back to the exact chunked path (correct on any backend, ~2.7x slower).
     const bool no_fa = g_no_fa;
     if (!no_fa) {
-        // TRELLIS_FA_FAST=1: F16 K/V + default (F16) accumulation — the shapes
-        // the Vulkan coopmat FA shaders are specialized for. A/B only: F16 K/V
-        // can overflow on HR activations (the reason BF16+F32 is the default).
-        static const bool fa_fast = std::getenv("TRELLIS_FA_FAST") != nullptr;
+        // Fast mode uses F16 K/V + the backend's default accumulation. It is the HTP
+        // default after the 12-step res512 gate showed a 3.53x end-to-end speedup with
+        // identical sparse voxels and 1.5% decoded-voxel drift. Other backends retain
+        // BF16 K/V + F32 accumulation unless explicitly forced. Test binaries that do
+        // not enter trellis_run keep the historical TRELLIS_FA_FAST environment switch.
+        const bool fa_fast = g_fa_fast >= 0 ? g_fa_fast != 0
+                           : std::getenv("TRELLIS_FA_F32") ? false
+                           : std::getenv("TRELLIS_FA_FAST") ? true
+                           : model_backend_is_htp(m);
         const int64_t KQ_STRIDE = 256;
         auto prep_kv = [&](T* x) {                              // -> [hd, Lk_pad, nh] BF16
             T* p = ggml_cont(c, ggml_permute(c, x, 0, 2, 1, 3));   // [hd, Lk, nh] F32
@@ -202,7 +220,7 @@ static T* self_attn(ggml_context* c, const Model& m, const std::string& pre, T*
     k = rms_gamma(c, k, gamma32(c, m, pre + ".k_rms_norm.gamma"), p.rms_eps);
     q = apply_rope(c, q, cos, sin);
     k = apply_rope(c, k, cos, sin);
-    return lin(c, m, pre + ".to_out", sdpa(c, q, k, v, p.d_model, mask));
+    return lin(c, m, pre + ".to_out", sdpa(c, m, q, k, v, p.d_model, mask));
 }
 
 static T* cross_attn(ggml_context* c, const Model& m, const std::string& pre, T* h, T* cond,
@@ -220,7 +238,7 @@ static T* cross_attn(ggml_context* c, const Model& m, const std::string& pre, T*
     T* k = pick(0); T* v = pick(1);
     q = rms_gamma(c, q, gamma32(c, m, pre + ".q_rms_norm.gamma"), p.rms_eps);
     k = rms_gamma(c, k, gamma32(c, m, pre + ".k_rms_norm.gamma"), p.rms_eps);
-    return lin(c, m, pre + ".to_out", sdpa(c, q, k, v, p.d_model, mask));
+    return lin(c, m, pre + ".to_out", sdpa(c, m, q, k, v, p.d_model, mask));
 }
 
 // x*(1+scale)+shift, scale/shift: [d_model] broadcast over L
diff --git a/src/flow_runner.cpp b/src/flow_runner.cpp
index 0b5ad9e..85d84b2 100644
--- a/src/flow_runner.cpp
+++ b/src/flow_runner.cpp
@@ -1,5 +1,7 @@
 #include "flow_runner.h"
 #include "trellis_model.h"
+#include "trellis_debug.h"
+#include "trellis_sched.h"
 #include "ggml.h"
 #include "ggml-backend.h"
 #include "ggml-alloc.h"
@@ -46,34 +48,65 @@ DitRunner::DitRunner(const Model& m, const DiTParams& p, int N, int n_cond,
     gcos_ = ggml_new_tensor_4d(ctx_, GGML_TYPE_F32, 1, half, 1, N_); ggml_set_input(gcos_);
     gsin_ = ggml_new_tensor_4d(ctx_, GGML_TYPE_F32, 1, half, 1, N_); ggml_set_input(gsin_);
     dbg_nan_ = std::getenv("TRELLIS_DBG_NAN") != nullptr;
-    gout_ = build_dit_dense(ctx_, m_, p_, gh0_, gtf_, gcond_, gcos_, gsin_, dbg_nan_ ? &inter_ : nullptr);
-    g_ = ggml_new_graph_custom(ctx_, 32768, false);
-    ggml_build_forward_expand(g_, gout_);
-    ggml_set_output(gout_);
-    if (dbg_nan_) for (auto& [nm, t] : inter_) { ggml_build_forward_expand(g_, t); ggml_set_output(t); }
-    alloc_ = ggml_gallocr_new(ggml_backend_get_default_buffer_type(m_.backend));
-    if (!ggml_gallocr_alloc_graph(alloc_, g_)) throw std::runtime_error("DitRunner: alloc failed");
+    {
+        ScopedTimer _t("dit.build_graph");
+        gout_ = build_dit_dense(ctx_, m_, p_, gh0_, gtf_, gcond_, gcos_, gsin_, dbg_nan_ ? &inter_ : nullptr);
+        g_ = ggml_new_graph_custom(ctx_, 32768, false);
+        ggml_build_forward_expand(g_, gout_);
+        ggml_set_output(gout_);
+        if (dbg_nan_) for (auto& [nm, t] : inter_) { ggml_build_forward_expand(g_, t); ggml_set_output(t); }
+    }
+    log_graph("dit.graph", g_);
+    {
+        ScopedTimer _t("dit.alloc_graph");
+        exec_ = std::make_unique<GraphExec>(m_);
+        if (!exec_->alloc(g_)) throw std::runtime_error("DitRunner: alloc failed");
+    }
     rcos_ = rcos; rsin_ = rsin;   // keep; re-upload each forward (gallocr reuses input buffers across runs)
 }
 
 DitRunner::~DitRunner() {
-    if (alloc_) ggml_gallocr_free(alloc_);
     if (ctx_)   ggml_free(ctx_);
 }
 
 std::vector<float> DitRunner::forward(const std::vector<float>& xt, float t_scaled, const float* cond) {
     std::vector<float> tf; timestep_embedding(t_scaled, tf);
-    ggml_backend_tensor_set(gh0_,  xt.data(), 0, xt.size() * 4);
-    ggml_backend_tensor_set(gtf_,  tf.data(), 0, tf.size() * 4);
-    ggml_backend_tensor_set(gcond_, cond,     0, (size_t)p_.d_cond * Lc_ * 4);
-    ggml_backend_tensor_set(gcos_, rcos_.data(), 0, rcos_.size() * 4);   // re-upload (buffers reused across runs)
-    ggml_backend_tensor_set(gsin_, rsin_.data(), 0, rsin_.size() * 4);
-    if (ggml_backend_graph_compute(m_.backend, g_) != GGML_STATUS_SUCCESS)
+    // The graph and scheduler assignment are reused across every flow step; only inputs change.
+    {
+        ScopedTimer _t("dit.upload");
+        ggml_backend_tensor_set(gh0_,  xt.data(), 0, xt.size() * 4);
+        ggml_backend_tensor_set(gtf_,  tf.data(), 0, tf.size() * 4);
+        ggml_backend_tensor_set(gcond_, cond,     0, (size_t)p_.d_cond * Lc_ * 4);
+        ggml_backend_tensor_set(gcos_, rcos_.data(), 0, rcos_.size() * 4);   // re-upload (buffers reused across runs)
+        ggml_backend_tensor_set(gsin_, rsin_.data(), 0, rsin_.size() * 4);
+    }
+    if (exec_->compute(g_, "dit.forward") != GGML_STATUS_SUCCESS)
         throw std::runtime_error("DitRunner: compute failed");
-    std::vector<float> outv = tensor_to_f32(gout_);
+    std::vector<float> outv;
+    { ScopedTimer _t("dit.readback"); outv = tensor_to_f32(gout_); }
     size_t out_bad = 0; for (float x : outv) if (!std::isfinite(x)) out_bad++;
     // Dump the per-layer breakdown for the FIRST forward whose OUTPUT goes NaN (the failing low-t
     // step), not just the very first forward (which is clean) — that's where to look for the cause.
+    if (verbose()) {
+        double mn = 0, mx = 0, sum = 0, sq = 0;
+        size_t bad = 0;
+        for (size_t i = 0; i < outv.size(); ++i) {
+            const float x = outv[i];
+            if (!std::isfinite(x)) { bad++; continue; }
+            if (i == 0 || x < mn) mn = x;
+            if (i == 0 || x > mx) mx = x;
+            sum += x; sq += (double) x * x;
+        }
+        const double n    = (double) (outv.size() - bad);
+        const double mean = n > 0 ? sum / n : 0.0;
+        const double std  = n > 0 ? std::sqrt(std::max(0.0, sq / n - mean * mean)) : 0.0;
+        fprintf(stderr, "      [dit-fwd %2d] t=%.3f mean=%.4f std=%.4f min=%.3f max=%.3f nan/inf=%zu"
+                        "  out=%p buf=%s\n",
+                n_fwd_++, t_scaled, mean, std, mn, mx, bad,
+                (void*) gout_->data,
+                gout_->buffer ? ggml_backend_buffer_name(gout_->buffer) : "(none)");
+    }
+
     if (dbg_nan_ && !dbg_done_ && out_bad > 0) {
         dbg_done_ = true;
         fprintf(stderr, "      [dit-nan] *** first NaN forward: t_scaled=%.2f  out_nan=%zu/%zu ***\n",
diff --git a/src/list_devices.cpp b/src/list_devices.cpp
new file mode 100644
index 0000000..67ae1ea
--- /dev/null
+++ b/src/list_devices.cpp
@@ -0,0 +1,78 @@
+// Enumerate registered ggml devices and optionally initialize them.
+
+#include "ggml-backend.h"
+
+#include <cstdio>
+#include <cstddef>
+#include <string_view>
+
+static const char* dev_type_name(enum ggml_backend_dev_type t) {
+    switch (t) {
+        case GGML_BACKEND_DEVICE_TYPE_CPU:   return "CPU";
+        case GGML_BACKEND_DEVICE_TYPE_GPU:   return "GPU";
+        case GGML_BACKEND_DEVICE_TYPE_IGPU:  return "IGPU";
+        case GGML_BACKEND_DEVICE_TYPE_ACCEL: return "ACCEL";
+        case GGML_BACKEND_DEVICE_TYPE_META:  return "META";
+        default:                             return "?";
+    }
+}
+
+static double to_mib(size_t bytes) {
+    return (double) bytes / (1024.0 * 1024.0);
+}
+
+int main(int argc, char** argv) {
+    const bool probe = (argc > 1 && std::string_view(argv[1]) == "--init");
+    bool init_failed = false;
+
+    printf("registered backends: %zu\n", ggml_backend_reg_count());
+    for (size_t i = 0; i < ggml_backend_reg_count(); ++i) {
+        ggml_backend_reg_t reg = ggml_backend_reg_get(i);
+        printf("  [%zu] %-12s  devices: %zu\n", i, ggml_backend_reg_name(reg),
+               ggml_backend_reg_dev_count(reg));
+    }
+
+    const size_t n = ggml_backend_dev_count();
+    printf("\ndevices: %zu\n", n);
+
+    for (size_t i = 0; i < n; ++i) {
+        ggml_backend_dev_t d = ggml_backend_dev_get(i);
+        if (!d) {
+            printf("\n  device %zu\n    unavailable (backend initialization failed)\n", i);
+            init_failed = true;
+            continue;
+        }
+
+        ggml_backend_dev_props p{};
+        ggml_backend_dev_get_props(d, &p);
+
+        printf("\n  device %zu\n", i);
+        printf("    name        : %s\n", ggml_backend_dev_name(d));
+        printf("    description : %s\n", ggml_backend_dev_description(d));
+        printf("    type        : %s\n", dev_type_name(ggml_backend_dev_type(d)));
+        printf("    backend reg : %s\n", ggml_backend_reg_name(ggml_backend_dev_backend_reg(d)));
+        printf("    memory      : %.0f MiB free / %.0f MiB total\n",
+               to_mib(p.memory_free), to_mib(p.memory_total));
+        printf("    caps        : async=%d host_buffer=%d from_host_ptr=%d events=%d\n",
+               p.caps.async, p.caps.host_buffer, p.caps.buffer_from_host_ptr, p.caps.events);
+
+        // Actually bringing the device up is the real test -- registration alone does
+        // not prove the driver/firmware path works (notably for Hexagon, where the HTP
+        // skel has to load onto the DSP).
+        if (probe) {
+            ggml_backend_t b = ggml_backend_dev_init(d, nullptr);
+            if (b) {
+                printf("    init        : OK (%s)\n", ggml_backend_name(b));
+                ggml_backend_free(b);
+            } else {
+                printf("    init        : FAILED\n");
+                init_failed = true;
+            }
+        }
+    }
+
+    if (!probe) {
+        printf("\n(pass --init to also try bringing each device up)\n");
+    }
+    return init_failed ? 1 : 0;
+}
diff --git a/src/shape_decoder.cpp b/src/shape_decoder.cpp
index 2aea89f..fe8b5a1 100644
--- a/src/shape_decoder.cpp
+++ b/src/shape_decoder.cpp
@@ -1,4 +1,6 @@
 #include "shape_decoder.h"
+#include "trellis_debug.h"
+#include "trellis_sched.h"
 #include "sparse.h"
 #include "trellis_model.h"
 #include "ggml.h"
@@ -36,16 +38,15 @@ static std::vector<float> run1(const Model& m, ggml_context* c, T* out,
     ggml_set_output(out);
     ggml_cgraph* g = ggml_new_graph_custom(c, kGraphNodes, false);
     ggml_build_forward_expand(g, out);
-    ggml_gallocr_t a = ggml_gallocr_new(ggml_backend_get_default_buffer_type(m.backend));
-    if (!ggml_gallocr_alloc_graph(a, g)) throw std::runtime_error("shape_dec alloc");
+    trellis::GraphExec ex(m);
+    if (!ex.alloc(g)) throw std::runtime_error("shape_dec alloc");
     if (getenv("TRELLIS_DBG_ALLOC"))
         fprintf(stderr, "      [stage-alloc] nodes=%d  gallocr buffer = %.2f GB\n",
-                ggml_graph_n_nodes(g), ggml_gallocr_get_buffer_size(a, 0) / 1e9);
+                ggml_graph_n_nodes(g), ex.buffer_size() / 1e9);
     for (auto& [t, d] : ins) ggml_backend_tensor_set(t, d, 0, ggml_nbytes(t));
-    if (ggml_backend_graph_compute(m.backend, g) != GGML_STATUS_SUCCESS) throw std::runtime_error("shape_dec compute");
+    if (ex.compute(g, "shape_decode") != GGML_STATUS_SUCCESS) throw std::runtime_error("shape_dec compute");
     mem_probe("run1 computed (pre-readback)");
     std::vector<float> r = tensor_to_f32(out);
-    ggml_gallocr_free(a);
     mem_probe("run1 freed (post-readback)");
     return r;
 }
diff --git a/src/sparse.cpp b/src/sparse.cpp
index 1a0b57b..1637478 100644
--- a/src/sparse.cpp
+++ b/src/sparse.cpp
@@ -1,5 +1,7 @@
 #include "sparse.h"
 #include "trellis_model.h"
+#include "trellis_debug.h"
+#include "trellis_sched.h"
 #include "ggml.h"
 #include "ggml-backend.h"
 #include "ggml-alloc.h"
@@ -144,12 +146,12 @@ namespace {
 // RAM for structs only (~370 B each), so budget generously rather than risk GGML_ASSERT.
 static constexpr size_t kGraphNodes = 65536;
 struct GraphRun {
-    const Model& m; ggml_context* c; ggml_gallocr_t alloc = nullptr;
-    GraphRun(const Model& mm) : m(mm) {
+    const Model& m; ggml_context* c; trellis::GraphExec ex;
+    GraphRun(const Model& mm) : m(mm), ex(mm) {
         size_t meta = ggml_tensor_overhead() * kGraphNodes + ggml_graph_overhead_custom(kGraphNodes, false) + (1 << 20);
         c = ggml_init({ meta, nullptr, true });
     }
-    ~GraphRun() { if (alloc) ggml_gallocr_free(alloc); ggml_free(c); }
+    ~GraphRun() { ggml_free(c); }
     // `roots` are extra nodes to expand: writes into a preallocated `out` via ggml_cpy are
     // not reachable from `out` itself (nothing produces it), so they must be rooted explicitly.
     std::vector<float> run(ggml_tensor* out, const std::vector<std::pair<ggml_tensor*, const void*>>& inputs,
@@ -158,13 +160,12 @@ struct GraphRun {
         ggml_cgraph* g = ggml_new_graph_custom(c, kGraphNodes, false);
         for (ggml_tensor* r : roots) ggml_build_forward_expand(g, r);
         ggml_build_forward_expand(g, out);
-        alloc = ggml_gallocr_new(ggml_backend_get_default_buffer_type(m.backend));
-        if (!ggml_gallocr_alloc_graph(alloc, g)) throw std::runtime_error("c2s: alloc failed");
+        if (!ex.alloc(g)) throw std::runtime_error("c2s: alloc failed");
         if (getenv("TRELLIS_DBG_ALLOC"))
             fprintf(stderr, "      [c2s-alloc] nodes=%d  gallocr buffer = %.2f GB\n",
-                    ggml_graph_n_nodes(g), ggml_gallocr_get_buffer_size(alloc, 0) / 1e9);
+                    ggml_graph_n_nodes(g), ex.buffer_size() / 1e9);
         for (auto& [t, data] : inputs) ggml_backend_tensor_set(t, data, 0, ggml_nbytes(t));
-        if (ggml_backend_graph_compute(m.backend, g) != GGML_STATUS_SUCCESS) throw std::runtime_error("c2s: compute failed");
+        if (ex.compute(g, "sparse.c2s") != GGML_STATUS_SUCCESS) throw std::runtime_error("c2s: compute failed");
         return tensor_to_f32(out);
     }
 };
diff --git a/src/ss_decoder.cpp b/src/ss_decoder.cpp
index 29d0c0b..9c4e422 100644
--- a/src/ss_decoder.cpp
+++ b/src/ss_decoder.cpp
@@ -1,5 +1,7 @@
 #include "ss_decoder.h"
 #include "trellis_model.h"
+#include "trellis_debug.h"
+#include "trellis_sched.h"
 #include "ggml.h"
 #include "ggml-backend.h"
 #include "ggml-alloc.h"
@@ -54,12 +56,12 @@ static Seg run_seg(const Model& m, const std::vector<float>& in_host,
     T* out = build(c, in); ggml_set_output(out);
     ggml_cgraph* g = ggml_new_graph_custom(c, 8192, false);
     ggml_build_forward_expand(g, out);
-    ggml_gallocr_t alloc = ggml_gallocr_new(ggml_backend_get_default_buffer_type(m.backend));
-    if (!ggml_gallocr_alloc_graph(alloc, g)) throw std::runtime_error("ss_dec: alloc failed");
+    trellis::GraphExec ex(m);
+    if (!ex.alloc(g)) throw std::runtime_error("ss_dec: alloc failed");
     ggml_backend_tensor_set(in, in_host.data(), 0, in_host.size() * 4);
-    if (ggml_backend_graph_compute(m.backend, g) != GGML_STATUS_SUCCESS) throw std::runtime_error("ss_dec: compute failed");
+    if (ex.compute(g, "ss_decode") != GGML_STATUS_SUCCESS) throw std::runtime_error("ss_dec: compute failed");
     Seg s; s.data = tensor_to_f32(out);
-    ggml_gallocr_free(alloc); ggml_free(c);
+    ggml_free(c);
     return s;
 }
 
diff --git a/src/trellis_args.cpp b/src/trellis_args.cpp
index 60fa075..9025296 100644
--- a/src/trellis_args.cpp
+++ b/src/trellis_args.cpp
@@ -25,7 +25,28 @@ void print_usage(const char* argv0, bool server) {
         "      --copyright TEXT    glTF asset.copyright metadata\n"
         "  -m, --models DIR        GGUF model directory\n"
         "      --gpu N             GPU index, <0 = CPU          (default 0)\n"
+        "      --backend NAME      force a ggml backend: Vulkan | HTP | CPU | ...\n"
+        "                          (HTP is the Qualcomm Hexagon NPU. Default: auto.\n"
+        "                          Run trellis-devices to list what this build sees.\n"
+        "                          Needed on Snapdragon, where the NPU and the Adreno\n"
+        "                          GPU both register as GPU devices.)\n"
+        "  -t, --threads N         CPU backend threads (default: all cores. ggml's own\n"
+        "                          default is 4 regardless of core count.)\n"
+        "      --sched on|off      run graphs through the multi-backend scheduler so ops\n"
+        "                          the chosen backend cannot execute fall back to another\n"
+        "                          (default: on unless the backend is the CPU). Required\n"
+        "                          for --backend HTP, whose op coverage is partial.\n"
+        "      --vulkan-fallback  with HTP, try Vulkan before CPU for unsupported ops\n"
+        "                          (same as TRELLIS_VULKAN_FALLBACK=1)\n"
+        "      --no-vulkan-fallback\n"
+        "                          disable Vulkan fallback even if the environment enables it\n"
+        "  -v, --verbose           per-stage timings, graph node counts, and a heartbeat\n"
+        "                          while a backend compute is running (TRELLIS_VERBOSE=1;\n"
+        "                          =2 also dumps the per-op histogram of each graph)\n"
         "  -s, --seed N            RNG seed                     (default 42)\n"
+        "      --steps N           flow sampler steps (default 12). Lower is faster and\n"
+        "                          rougher; useful for backend bring-up, where a CPU and\n"
+        "                          an NPU run at the same N stay directly comparable.\n"
         "      --res 512|1024|1536 geometry resolution\n"
         "      --max-tokens N      HR token budget              (default 49152)\n"
         "      --bg-removal MODE   threshold | birefnet   (default: auto -- a pre-matted\n"
@@ -49,6 +70,8 @@ void print_usage(const char* argv0, bool server) {
         "      --dump-bg           also write the background-removal cutout as <out>_cutout.png\n"
         "      --bg-only           background removal only: write the cutout and skip the rest\n"
         "      --f32               f32 sparse-conv compute\n"
+        "      --fa-fast           force F16 K/V + fast accumulation (default on HTP)\n"
+        "      --fa-f32            use BF16 K/V + F32 accumulation (HTP opt-out)\n"
         "      --no-fa             disable FlashAttention\n"
         "      --require-gpu       refuse CPU fallback\n"
         "      --threads N         CPU backend threads      (default all cores)\n"
@@ -79,6 +102,16 @@ bool parse_args(int argc, char** argv, TrellisParams& p) {
         else if (a == "--copyright")            { const char* v = need(a.c_str()); if (!v) return false; p.copyright = v; }
         else if (a == "-m" || a == "--models")  { const char* v = need(a.c_str()); if (!v) return false; p.models = v; }
         else if (a == "--gpu")                  { const char* v = need(a.c_str()); if (!v) return false; p.gpu = atoi(v); }
+        else if (a == "--backend")              { const char* v = need(a.c_str()); if (!v) return false; p.backend = v; }
+        else if (a == "-t" || a == "--threads") { const char* v = need(a.c_str()); if (!v) return false; p.threads = atoi(v); }
+        else if (a == "-v" || a == "--verbose") { p.verbose = true; }
+        else if (a == "--steps")                { const char* v = need(a.c_str()); if (!v) return false; p.steps = atoi(v); }
+        else if (a == "--sched")                { const char* v = need(a.c_str()); if (!v) return false;
+                                                  if (strcmp(v, "on") == 0 || strcmp(v, "1") == 0) p.sched = 1;
+                                                  else if (strcmp(v, "off") == 0 || strcmp(v, "0") == 0) p.sched = 0;
+                                                  else { fprintf(stderr, "[trellis] --sched expects on or off\n"); return false; } }
+        else if (a == "--vulkan-fallback")      { p.vulkan_fallback = 1; }
+        else if (a == "--no-vulkan-fallback")   { p.vulkan_fallback = 0; }
         else if (a == "-s" || a == "--seed")    { const char* v = need(a.c_str()); if (!v) return false; p.seed = (uint32_t)atoi(v); }
         else if (a == "--res")                  { const char* v = need(a.c_str()); if (!v) return false; p.set_res(atoi(v)); }
         else if (a == "--max-tokens")           { const char* v = need(a.c_str()); if (!v) return false; p.max_tokens = atoi(v); }
@@ -97,6 +130,8 @@ bool parse_args(int argc, char** argv, TrellisParams& p) {
         else if (a == "--dump-bg")              { p.dump_bg = true; }
         else if (a == "--bg-only")              { p.bg_only = true; p.dump_bg = true; }
         else if (a == "--f32")                  { p.f32 = true; }
+        else if (a == "--fa-fast")              { p.fa_fast = 1; }
+        else if (a == "--fa-f32")               { p.fa_fast = 0; }
         else if (a == "--no-fa")                { p.no_fa = true; }
         else if (a == "--require-gpu")          { p.require_gpu = true; }
         else if (a == "--threads")              { const char* v = need(a.c_str()); if (!v) return false; p.threads = atoi(v); }
diff --git a/src/trellis_cli.cpp b/src/trellis_cli.cpp
index 0dd031d..cf0f7fb 100644
--- a/src/trellis_cli.cpp
+++ b/src/trellis_cli.cpp
@@ -2,6 +2,8 @@
 //   trellis-cli <image.png> <out.glb> [gpu] [models_dir] [seed]
 // Models are loaded/freed per stage to keep VRAM modest.
 #include "trellis_model.h"
+#include "trellis_debug.h"
+#include "trellis_sched.h"
 #include "preprocess.h"
 #include "dinov3.h"
 #include "flow_runner.h"
@@ -23,9 +25,16 @@
 #include <set>
 #include <array>
 #include <cmath>
+#include <cctype>
 
 using std::vector;
 static double now() { return std::chrono::duration<double>(std::chrono::steady_clock::now().time_since_epoch()).count(); }
+static bool backend_is_htp(const std::string& backend) {
+    if (backend.size() != 3) return false;
+    return std::tolower((unsigned char)backend[0]) == 'h' &&
+           std::tolower((unsigned char)backend[1]) == 't' &&
+           std::tolower((unsigned char)backend[2]) == 'p';
+}
 // [dbg] overall stats of a flat tensor — used to compare LR vs HR shape-SLAT in decode space.
 static void slat_stats(const char* tag, const vector<float>& v) {
     if (v.empty()) { printf("      [stats] %s EMPTY\n", tag); return; }
@@ -62,8 +71,41 @@ int trellis_run(const trellis::TrellisParams& cfg) {
     // Publish the cross-module flags this run wants (modules read them with an env fallback).
     const bool F32 = cfg.f32; trellis::g_sparse_cast_f32 = F32;  // f16 default (rope bug was the real issue)
     trellis::g_no_fa = cfg.no_fa;
+    // CLI flags win over environment switches and the HTP-specific fast default.
+    std::string requested_backend = cfg.backend;
+    if (requested_backend.empty()) {
+        if (const char* e = std::getenv("TRELLIS_BACKEND")) requested_backend = e;
+    }
+    const bool fa_f32_env = std::getenv("TRELLIS_FA_F32") != nullptr;
+    const bool fa_fast_env = std::getenv("TRELLIS_FA_FAST") != nullptr;
+    const bool fa_auto_htp = cfg.fa_fast < 0 && !fa_f32_env && !fa_fast_env &&
+                             backend_is_htp(requested_backend);
+    if (cfg.fa_fast >= 0) {
+        trellis::g_fa_fast = cfg.fa_fast;
+    } else if (fa_f32_env) {
+        trellis::g_fa_fast = 0;
+    } else if (fa_fast_env) {
+        trellis::g_fa_fast = 1;
+    } else {
+        // An empty requested backend is genuinely auto-selected later by Model::load;
+        // leave the policy unresolved so sdpa can inspect that model's actual backend.
+        trellis::g_fa_fast = requested_backend.empty() ? -1 : (fa_auto_htp ? 1 : 0);
+    }
     trellis::g_require_gpu = cfg.require_gpu;
     trellis::g_cpu_threads = cfg.threads;
+    trellis::g_backend = cfg.backend;
+    trellis::set_verbose(cfg.verbose);
+    trellis::set_sched_mode(cfg.sched);
+    trellis::set_vulkan_fallback_mode(cfg.vulkan_fallback);
+    if (!cfg.no_fa) {
+        if (trellis::g_fa_fast < 0) {
+            fprintf(stderr, "[trellis] FlashAttention precision: auto (F16 fast on HTP; BF16/F32 otherwise)\n");
+        } else {
+            fprintf(stderr, "[trellis] FlashAttention precision: %s%s\n",
+                    trellis::g_fa_fast ? "F16 fast" : "BF16 K/V + F32 accumulation",
+                    fa_auto_htp ? " (HTP default)" : "");
+        }
+    }
     const std::string& img = cfg.image;
     const std::string& outglb = cfg.output;
     const std::string& M = cfg.models;
@@ -95,7 +137,14 @@ int trellis_run(const trellis::TrellisParams& cfg) {
         printf("[1/6] preprocess %s (BiRefNet bg removal, %s)\n", img.c_str(), cascade ? "1024 cascade" : "512");
         // Full BiRefNet (Swin-L backbone + deformable-conv decoder) runs on the GPU. Cutout computed
         // once, normalized for 512 and 1024.
-        trellis::Model bm = trellis::Model::load(M + "/birefnet.gguf", gpu);
+        // BiRefNet's small convolutions are slower and currently nondeterministic on HTP.
+        // Keep other explicitly selected backends on their existing path.
+        const std::string bg_saved_backend = trellis::g_backend;
+        const bool bg_on_cpu = backend_is_htp(requested_backend);
+        if (bg_on_cpu) trellis::g_backend = "CPU";
+        trellis::Model bm = trellis::Model::load(M + "/birefnet.gguf",
+                                                 bg_on_cpu ? -1 : gpu);
+        trellis::g_backend = bg_saved_backend;
         cutout = trellis::birefnet_cutout(img, bm, gpu < 0 ? 0 : gpu, cut_sz);
         bm.free();
         if (cutout.empty()) return 1;
@@ -142,13 +191,19 @@ int trellis_run(const trellis::TrellisParams& cfg) {
         trellis::DiTParams p; p.in_ch = 8; p.out_ch = 8; p.d_cond = 1024; p.cast_f32 = F32;
         trellis::DitRunner* run = trellis::make_dense_runner(m, p, 16, Lc);
         trellis::FlowFwd fwd = [&](const vector<float>& x, float ts, const float* c){ return run->forward(x, ts, c); };
-        trellis::SamplerParams sp; sp.steps=12; sp.guidance_strength=cfg.gss; sp.guidance_rescale=0.7f; sp.gi0=0.6f; sp.gi1=1.0f; sp.rescale_t=5.0f;
+        trellis::SamplerParams sp; sp.steps=(cfg.steps>0?cfg.steps:12); sp.guidance_strength=cfg.gss; sp.guidance_rescale=0.7f; sp.gi0=0.6f; sp.gi1=1.0f; sp.rescale_t=5.0f;
         vector<float> z = trellis::sample_flow(fwd, noise(8*4096), cond.data(), neg.data(), sp);  // [8,4096] ne0=8
         delete run; m.free();
         // transpose [8,L] -> torch [8,16,16,16] memory (c*4096 + sp)
         vector<float> zdec(8*4096);
         for (int c = 0; c < 8; ++c) for (int sp2 = 0; sp2 < 4096; ++sp2) zdec[(size_t)c*4096 + sp2] = z[c + 8*sp2];
-        trellis::Model d = trellis::Model::load(M + "/ss_dec.gguf", gpu);
+        // This small decoder currently miscomputes a CONT/view-to-ADD chain on HTP.
+        // Its CPU cost is negligible; other backends retain their existing placement.
+        const std::string saved_backend = trellis::g_backend;
+        const bool ss_dec_on_cpu = backend_is_htp(requested_backend);
+        if (ss_dec_on_cpu) trellis::g_backend = "CPU";
+        trellis::Model d = trellis::Model::load(M + "/ss_dec.gguf", ss_dec_on_cpu ? -1 : gpu);
+        trellis::g_backend = saved_backend;
         vector<float> logits = trellis::ss_decode(d, zdec); d.free();
         coords = trellis::ss_coords(logits, 64, 32);
     }
@@ -166,7 +221,7 @@ int trellis_run(const trellis::TrellisParams& cfg) {
         trellis::DiTParams p; p.in_ch = 32; p.out_ch = 32; p.d_cond = 1024; p.cast_f32 = F32;
         trellis::DitRunner* run = trellis::make_sparse_runner(m, p, cds, lc);
         trellis::FlowFwd fwd = [&](const vector<float>& x, float ts, const float* c){ return run->forward(x, ts, c); };
-        trellis::SamplerParams sp; sp.steps=12; sp.guidance_strength=cfg.gsh; sp.guidance_rescale=0.5f; sp.gi0=0.6f; sp.gi1=1.0f; sp.rescale_t=3.0f;
+        trellis::SamplerParams sp; sp.steps=(cfg.steps>0?cfg.steps:12); sp.guidance_strength=cfg.gsh; sp.guidance_rescale=0.5f; sp.gi0=0.6f; sp.gi1=1.0f; sp.rescale_t=3.0f;
         vector<float> sn = trellis::sample_flow(fwd, noise((size_t)32*n), cnd, ncnd, sp);   // [32,n]
         delete run; m.free();
         return sn;
@@ -316,7 +371,7 @@ int trellis_run(const trellis::TrellisParams& cfg) {
                 }
                 return run->forward(x64, ts, c);
             };
-            trellis::SamplerParams sp; sp.steps=12; sp.guidance_strength=1.0f; sp.guidance_rescale=0.0f; sp.gi0=0.6f; sp.gi1=0.9f; sp.rescale_t=3.0f;
+            trellis::SamplerParams sp; sp.steps=(cfg.steps>0?cfg.steps:12); sp.guidance_strength=1.0f; sp.guidance_rescale=0.0f; sp.gi0=0.6f; sp.gi1=0.9f; sp.rescale_t=3.0f;
             texlat = trellis::sample_flow(fwd, noise((size_t)32*tN), tcond, tneg, sp);  // [32,tN]
             delete run; m.free();
             for (int n = 0; n < tN; ++n) for (int c = 0; c < 32; ++c) texlat[(size_t)c + 32*n] = texlat[(size_t)c + 32*n]*TEX_STD[c] + TEX_MEAN[c];
diff --git a/src/trellis_cli_main.cpp b/src/trellis_cli_main.cpp
index 8e0b6bc..5877ca7 100644
--- a/src/trellis_cli_main.cpp
+++ b/src/trellis_cli_main.cpp
@@ -3,7 +3,27 @@
 #include "trellis_run.h"
 #include <cstdio>
 
+#if defined(_WIN32)
+#include <windows.h>
+namespace {
+// Long inference runs should survive the system idle timeout. The display may still blank.
+struct KeepAwake {
+    bool held = false;
+    KeepAwake() {
+        held = SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED) != 0;
+        if (!held) fprintf(stderr, "[trellis] could not hold a wake lock; sleep may interrupt this run\n");
+    }
+    ~KeepAwake() { if (held) SetThreadExecutionState(ES_CONTINUOUS); }
+};
+}  // namespace
+#else
+namespace { struct KeepAwake {}; }
+#endif
+
 int main(int argc, char** argv) {
+    // Keep stage progress visible when stdout is redirected to a file or pipe.
+    setvbuf(stdout, nullptr, _IONBF, 0);
+
     trellis::TrellisParams p;
     if (!trellis::parse_args(argc, argv, p)) {
         trellis::print_usage(argv[0], /*server=*/false);
@@ -14,5 +34,7 @@ int main(int argc, char** argv) {
         trellis::print_usage(argv[0], /*server=*/false);
         return 1;
     }
+
+    KeepAwake _awake;
     return trellis_run(p);
 }
diff --git a/src/trellis_debug.cpp b/src/trellis_debug.cpp
new file mode 100644
index 0000000..dcf0228
--- /dev/null
+++ b/src/trellis_debug.cpp
@@ -0,0 +1,118 @@
+#include "trellis_debug.h"
+
+#include <functional>
+#include <condition_variable>
+#include <cstdio>
+#include <cstdlib>
+#include <map>
+#include <mutex>
+#include <thread>
+
+namespace trellis {
+
+namespace {
+int  g_verbose = -1;          // -1 = not yet resolved from the environment
+}  // namespace
+
+bool verbose() {
+    if (g_verbose < 0) {
+        const char* e = std::getenv("TRELLIS_VERBOSE");
+        g_verbose = (e && atoi(e) > 0) ? atoi(e) : 0;
+    }
+    return g_verbose > 0;
+}
+
+void set_verbose(bool v) {
+    if (v) { if (g_verbose < 1) g_verbose = 1; }
+    else   { if (g_verbose < 0) g_verbose = 0; }
+}
+
+static int verbose_level() { verbose(); return g_verbose < 0 ? 0 : g_verbose; }
+
+ScopedTimer::ScopedTimer(std::string label)
+    : label_(std::move(label)), t0_(std::chrono::steady_clock::now()) {}
+
+double ScopedTimer::ms() const {
+    return std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - t0_).count();
+}
+
+ScopedTimer::~ScopedTimer() {
+    if (verbose()) fprintf(stderr, "[trellis:dbg] %-28s %10.1f ms\n", label_.c_str(), ms());
+}
+
+void log_graph(const char* label, const ggml_cgraph* graph) {
+    if (!verbose() || !graph) return;
+    const int n = ggml_graph_n_nodes(const_cast<ggml_cgraph*>(graph));
+    fprintf(stderr, "[trellis:dbg] %-28s %d nodes\n", label, n);
+
+    if (verbose_level() < 2) return;
+    std::map<std::string, int> hist;
+    for (int i = 0; i < n; ++i) {
+        ggml_tensor* t = ggml_graph_node(const_cast<ggml_cgraph*>(graph), i);
+        hist[ggml_op_name(t->op)]++;
+    }
+    for (const auto& [op, count] : hist)
+        fprintf(stderr, "[trellis:dbg]     %-24s %5d\n", op.c_str(), count);
+}
+
+// Shared instrumentation for potentially long-running graph execution.
+static ggml_status run_instrumented(const char* label, const char* target, int n_nodes,
+                                    const std::function<ggml_status()>& run,
+                                    const std::function<void()>& report_extra) {
+    if (!verbose()) return run();
+
+    fprintf(stderr, "[trellis:dbg] %-28s -> %s, %d nodes ...\n", label, target, n_nodes);
+    fflush(stderr);
+
+    std::mutex              mu;
+    std::condition_variable cv;
+    bool                    done = false;
+    const auto              t0 = std::chrono::steady_clock::now();
+
+    std::thread hb([&] {
+        std::unique_lock<std::mutex> lk(mu);
+        while (!cv.wait_for(lk, std::chrono::seconds(10), [&] { return done; })) {
+            const double el =
+                std::chrono::duration<double>(std::chrono::steady_clock::now() - t0).count();
+            fprintf(stderr, "[trellis:dbg] %-28s still running, %.0fs\n", label, el);
+            fflush(stderr);
+        }
+    });
+
+    const ggml_status st = run();
+
+    { std::lock_guard<std::mutex> lk(mu); done = true; }
+    cv.notify_all();
+    hb.join();
+
+    const double el = std::chrono::duration<double, std::milli>(
+                          std::chrono::steady_clock::now() - t0).count();
+    fprintf(stderr, "[trellis:dbg] %-28s done in %.1f ms%s\n", label, el,
+            st == GGML_STATUS_SUCCESS ? "" : "  (FAILED)");
+    if (report_extra) report_extra();
+    fflush(stderr);
+    return st;
+}
+
+ggml_status compute_graph(ggml_backend_t backend, ggml_cgraph* graph, const char* label) {
+    const int n = graph ? ggml_graph_n_nodes(graph) : 0;
+    return run_instrumented(label, backend ? ggml_backend_name(backend) : "?", n,
+                            [&] { return ggml_backend_graph_compute(backend, graph); },
+                            nullptr);
+}
+
+ggml_status compute_graph_sched(ggml_backend_sched_t sched, ggml_cgraph* graph, const char* label) {
+    const int n = graph ? ggml_graph_n_nodes(graph) : 0;
+    return run_instrumented(
+        label, "sched", n,
+        [&] { return ggml_backend_sched_graph_compute(sched, graph); },
+        [&] {
+            // Splits are the cost of heterogeneity: each one is a handoff (and possibly a
+            // tensor copy) between backends. One split = the graph stayed on one device.
+            fprintf(stderr, "[trellis:dbg] %-28s %d splits, %d copies\n", label,
+                    ggml_backend_sched_get_n_splits(sched),
+                    ggml_backend_sched_get_n_copies(sched));
+        });
+}
+
+}  // namespace trellis
diff --git a/src/trellis_model.cpp b/src/trellis_model.cpp
index 4240b46..ab24bec 100644
--- a/src/trellis_model.cpp
+++ b/src/trellis_model.cpp
@@ -1,4 +1,6 @@
 #include "trellis_model.h"
+#include "trellis_debug.h"
+#include "trellis_sched.h"
 
 #include "ggml.h"
 #include "gguf.h"
@@ -9,12 +11,16 @@
 #include "ggml-cuda.h"
 #endif
 
+#include <cctype>
 #include <cstdint>
+#include <thread>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <stdexcept>
-#include <thread>
+#include <map>
+#include <string>
+#include <utility>
 #include <vector>
 
 namespace {
@@ -34,35 +40,91 @@ namespace trellis {
 
 bool g_require_gpu = false;   // --require-gpu; set by trellis_run
 int  g_cpu_threads = 0;       // --threads; 0 = all cores. Set by trellis_run.
+std::string g_backend;        // --backend NAME;  set by trellis_run
 
-// ggml_backend_cpu_init() leaves the backend on ggml's built-in default thread
-// count, so most of a multi-core box sits idle on the CPU path. Measured on one
-// 20-core host, sparse-structure flow: 305s/step before, 118s/step after
-// (2.6x). Resolve the count here (flag -> TRELLIS_THREADS -> all cores) and
-// hand it to every CPU backend we create.
-static int cpu_thread_count() {
-    if (g_cpu_threads > 0) return g_cpu_threads;
-    if (const char* e = getenv("TRELLIS_THREADS")) {
-        int n = atoi(e);
-        if (n > 0) return n;
+// Tune both an explicitly selected CPU backend and the scheduler's CPU fallback.
+void tune_cpu_threads(ggml_backend* b) {
+    if (!b || !ggml_backend_is_cpu(b)) return;
+    int n = g_cpu_threads;
+    if (n <= 0) {
+        if (const char* e = std::getenv("TRELLIS_THREADS")) n = atoi(e);
     }
-    unsigned hw = std::thread::hardware_concurrency();
-    return hw > 0 ? (int) hw : 4;
+    if (n <= 0) n = (int) std::thread::hardware_concurrency();
+    if (n <= 0) n = 4;
+    ggml_backend_cpu_set_n_threads(b, n);
+    fprintf(stderr, "[trellis] CPU backend: %d threads\n", n);
 }
 
-static ggml_backend* cpu_backend() {
-    ggml_backend* b = ggml_backend_cpu_init();
-    if (b) {
-        const int nt = cpu_thread_count();
-        ggml_backend_cpu_set_n_threads(b, nt);
-        fprintf(stderr, "[trellis] CPU backend using %d threads\n", nt);
+// --backend, else TRELLIS_BACKEND (so the test binaries, which don't parse args,
+// can select a backend too).
+static std::string requested_backend() {
+    if (!g_backend.empty()) return g_backend;
+    if (const char* e = std::getenv("TRELLIS_BACKEND")) return e;
+    return {};
+}
+
+static bool name_matches(const char* have, const std::string& want) {
+    if (!have) return false;
+    if (std::strlen(have) != want.size()) return false;
+    for (size_t i = 0; i < want.size(); ++i) {
+        if (std::tolower((unsigned char) have[i]) != std::tolower((unsigned char) want[i]))
+            return false;
     }
-    return b;
+    return true;
+}
+
+// Devices whose ggml backend registration (e.g. "Vulkan", "Hexagon", "CPU") or device
+// name (e.g. "Vulkan0") matches `want`, in registration order.
+static std::vector<ggml_backend_dev_t> devices_named(const std::string& want) {
+    std::vector<ggml_backend_dev_t> out;
+    for (size_t i = 0; i < ggml_backend_dev_count(); ++i) {
+        ggml_backend_dev_t d = ggml_backend_dev_get(i);
+        if (!d) continue;
+        if (name_matches(ggml_backend_reg_name(ggml_backend_dev_backend_reg(d)), want) ||
+            name_matches(ggml_backend_dev_name(d), want)) {
+            out.push_back(d);
+        }
+    }
+    return out;
+}
+
+static void list_backends(FILE* f) {
+    fprintf(f, "[trellis] available backends:");
+    for (size_t i = 0; i < ggml_backend_reg_count(); ++i)
+        fprintf(f, " %s", ggml_backend_reg_name(ggml_backend_reg_get(i)));
+    fprintf(f, "\n");
 }
 
 static ggml_backend* make_backend(int gpu) {
+    // An explicit --backend wins over everything below. This matters on Snapdragon,
+    // where the Hexagon NPU and the Adreno GPU both register as
+    // GGML_BACKEND_DEVICE_TYPE_GPU: the "largest reported memory" heuristic further
+    // down cannot tell them apart in any meaningful way, so the choice has to be
+    // stated rather than guessed.
+    if (const std::string want = requested_backend(); !want.empty()) {
+        std::vector<ggml_backend_dev_t> devs = devices_named(want);
+        if (devs.empty()) {
+            fprintf(stderr, "[trellis] no backend named '%s' in this build\n", want.c_str());
+            list_backends(stderr);
+            throw std::runtime_error("[trellis] unknown backend: " + want);
+        }
+        const size_t idx = (gpu > 0 && (size_t) gpu < devs.size()) ? (size_t) gpu : 0;
+        if (gpu > 0 && idx != (size_t) gpu)
+            fprintf(stderr, "[trellis] --gpu %d out of range for backend '%s' (%zu device(s)); using 0\n",
+                    gpu, want.c_str(), devs.size());
+        ggml_backend_dev_props pr; ggml_backend_dev_get_props(devs[idx], &pr);
+        if (ggml_backend* b = ggml_backend_dev_init(devs[idx], nullptr)) {
+            fprintf(stderr, "[trellis] using %s -- %s (%zu MB)\n",
+                    ggml_backend_name(b), pr.description ? pr.description : "?",
+                    pr.memory_total / (1024 * 1024));
+            tune_cpu_threads(b);          // --backend CPU lands here too
+            return b;
+        }
+        throw std::runtime_error("[trellis] backend '" + want + "' failed to initialize");
+    }
+
     // gpu < 0 is an explicit request for CPU.
-    if (gpu < 0) return cpu_backend();
+    if (gpu < 0) { ggml_backend* b = ggml_backend_cpu_init(); tune_cpu_threads(b); return b; }
 #ifdef TRELLIS_USE_CUDA
     {
         ggml_backend* b = ggml_backend_cuda_init(gpu);
@@ -80,6 +142,7 @@ static ggml_backend* make_backend(int gpu) {
         std::vector<ggml_backend_dev_t> gpus;
         for (size_t i = 0; i < ggml_backend_dev_count(); ++i) {
             ggml_backend_dev_t d = ggml_backend_dev_get(i);
+            if (!d) continue;
             enum ggml_backend_dev_type t = ggml_backend_dev_type(d);
             // IGPU: integrated GPUs (e.g. Vulkan on a UMA APU) report a distinct type.
             if (t == GGML_BACKEND_DEVICE_TYPE_GPU || t == GGML_BACKEND_DEVICE_TYPE_IGPU)
@@ -117,10 +180,22 @@ static ggml_backend* make_backend(int gpu) {
             "[trellis] no usable GPU backend found and --require-gpu is set; refusing CPU fallback.");
     }
     fprintf(stderr, "[trellis] no GPU backend available; falling back to CPU\n");
-    return cpu_backend();
+    { ggml_backend* b = ggml_backend_cpu_init(); tune_cpu_threads(b); return b; }
+}
+
+// Reuse backend instances across sequential model stages. In particular, repeatedly
+// releasing and reacquiring a FastRPC session can destabilize the Hexagon runtime.
+static ggml_backend* shared_backend(int gpu) {
+    static std::map<std::pair<int, std::string>, ggml_backend*> cache;
+    const auto key = std::make_pair(gpu, requested_backend());
+    if (auto it = cache.find(key); it != cache.end()) return it->second;
+    ggml_backend* b = make_backend(gpu);
+    cache[key] = b;
+    return b;
 }
 
 Model Model::load(const std::string& path, int gpu) {
+    ScopedTimer _t("load " + path.substr(path.find_last_of("/\\") + 1));
     Model m;
 
     ggml_context* meta = nullptr;
@@ -137,13 +212,90 @@ Model Model::load(const std::string& path, int gpu) {
     if (int64_t k = gguf_find_key(m.gguf, "trellis.config_json"); k >= 0)
         m.config_json = gguf_get_val_str(m.gguf, k);
 
-    m.backend = make_backend(gpu);
-    m.on_gpu  = gpu >= 0;
+    m.backend = shared_backend(gpu);
+    m.on_gpu  = !ggml_backend_is_cpu(m.backend);
+
+    // Backends can expose an extra buffer type that performs device-specific weight
+    // repacking during upload. Hexagon requires this for its tiled quantized matmuls.
+    ggml_backend_buffer_type_t repack_buft = nullptr;
+    {
+        ggml_backend_dev_t dev = ggml_backend_get_device(m.backend);
+        ggml_backend_reg_t reg = dev ? ggml_backend_dev_backend_reg(dev) : nullptr;
+        // CPU repacking requires a per-tensor support check that this loader does not yet
+        // implement, so keep the generic CPU path unchanged.
+        if (dev && ggml_backend_is_cpu(m.backend)) {
+            if (verbose())
+                fprintf(stderr, "[trellis:dbg] extra-bufts: skipped on the CPU backend\n");
+            reg = nullptr;
+        }
+        void*              raw = reg ? ggml_backend_reg_get_proc_address(
+                                           reg, "ggml_backend_dev_get_extra_bufts") : nullptr;
+        if (raw) {
+            auto fn = (ggml_backend_dev_get_extra_bufts_t) raw;
+            if (ggml_backend_buffer_type_t* bufts = fn(dev); bufts && bufts[0])
+                repack_buft = bufts[0];
+        }
+        if (verbose())
+            fprintf(stderr, "[trellis:dbg] extra-bufts: dev=%d reg=%d proc=%d repack=%s\n",
+                    dev ? 1 : 0, reg ? 1 : 0, raw ? 1 : 0,
+                    repack_buft ? ggml_backend_buft_name(repack_buft) : "(none)");
+    }
+
+    // Only matrix weights of types supported by the Hexagon repack buffer are eligible.
+    auto repackable = [](const ggml_tensor* t) {
+        if (ggml_n_dims(const_cast<ggml_tensor*>(t)) < 2) return false;
+        switch (t->type) {
+            case GGML_TYPE_Q4_0:
+            case GGML_TYPE_Q8_0:
+            case GGML_TYPE_MXFP4: return true;
+            default:              return false;
+        }
+    };
+
+    const int64_t n_tensors = gguf_get_n_tensors(m.gguf);
+    size_t n_repack = 0;
+    if (!repack_buft) {
+        // Preserve the existing allocation path for CPU, CUDA, Vulkan, and backends
+        // without an extra weight buffer.
+        m.buffer = ggml_backend_alloc_ctx_tensors(meta, m.backend);
+        if (!m.buffer) throw std::runtime_error("failed to allocate tensor buffer for " + path);
+        ggml_backend_buffer_set_usage(m.buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+    } else {
+        const size_t ctx_size = ggml_tensor_overhead() * (size_t)(n_tensors + 8);
+        m.ctx_host   = ggml_init({ ctx_size, nullptr, true });
+        m.ctx_repack = ggml_init({ ctx_size, nullptr, true });
+
+        // Re-declare each tensor in the context matching the buffer it should use.
+        for (int64_t i = 0; i < n_tensors; ++i) {
+            const char*  nm  = gguf_get_tensor_name(m.gguf, i);
+            ggml_tensor* src = ggml_get_tensor(meta, nm);
+            const bool   rp  = repackable(src);
+            ggml_tensor* dst = ggml_dup_tensor(rp ? m.ctx_repack : m.ctx_host, src);
+            ggml_set_name(dst, nm);
+            if (rp) ++n_repack;
+        }
+
+        m.buffer = ggml_backend_alloc_ctx_tensors(m.ctx_host, m.backend);
+        if (!m.buffer) throw std::runtime_error("failed to allocate tensor buffer for " + path);
+        ggml_backend_buffer_set_usage(m.buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+
+        if (n_repack == 0) {
+            ggml_free(m.ctx_repack);
+            m.ctx_repack = nullptr;
+        } else {
+            m.buffer_repack = ggml_backend_alloc_ctx_tensors_from_buft(m.ctx_repack, repack_buft);
+            if (!m.buffer_repack) throw std::runtime_error("failed to allocate repack buffer for " + path);
+            ggml_backend_buffer_set_usage(m.buffer_repack, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
+            fprintf(stderr, "[trellis] %s: %zu/%lld tensors -> %s (%.1f MB)\n",
+                    path.substr(path.find_last_of("/\\") + 1).c_str(), n_repack, (long long) n_tensors,
+                    ggml_backend_buft_name(repack_buft),
+                    ggml_backend_buffer_get_size(m.buffer_repack) / 1e6);
+        }
+    }
 
-    // allocate one buffer for every tensor declared in the file
-    m.buffer = ggml_backend_alloc_ctx_tensors(meta, m.backend);
-    if (!m.buffer) throw std::runtime_error("failed to allocate tensor buffer for " + path);
+    m.sched = make_sched(m.backend);
 
+    if (verbose()) fprintf(stderr, "[trellis:dbg] phase: streaming weights...\n");
     // stream weights from disk into the backend buffer
     FILE* f = fopen(path.c_str(), "rb");
     if (!f) throw std::runtime_error("cannot reopen gguf: " + path);
@@ -152,7 +304,9 @@ Model Model::load(const std::string& path, int gpu) {
     const int64_t n = gguf_get_n_tensors(m.gguf);
     for (int64_t i = 0; i < n; ++i) {
         const char* name = gguf_get_tensor_name(m.gguf, i);
-        ggml_tensor* t = ggml_get_tensor(meta, name);
+        ggml_tensor* t = m.ctx_repack ? ggml_get_tensor(m.ctx_repack, name) : nullptr;
+        if (!t && m.ctx_host) t = ggml_get_tensor(m.ctx_host, name);
+        if (!t) t = ggml_get_tensor(meta, name);
         const size_t nbytes = ggml_nbytes(t);
         const size_t off = data_off + gguf_get_tensor_offset(m.gguf, i);
         staging.resize(nbytes);
@@ -188,11 +342,17 @@ size_t Model::total_bytes() const {
 }
 
 void Model::free() {
+    if (sched) ggml_backend_sched_free(sched);
+    if (buffer_repack) ggml_backend_buffer_free(buffer_repack);
     if (buffer) ggml_backend_buffer_free(buffer);
-    if (backend) ggml_backend_free(backend);
+    if (ctx_repack) ggml_free(ctx_repack);
+    if (ctx_host)   ggml_free(ctx_host);
+    // backend is shared process-wide (see shared_backend) -- never freed here.
     if (gguf) gguf_free(gguf);
     if (meta) ggml_free(meta);
-    buffer = nullptr; backend = nullptr; gguf = nullptr; meta = nullptr;
+    sched = nullptr; buffer = nullptr; buffer_repack = nullptr;
+    ctx_host = nullptr; ctx_repack = nullptr;
+    backend = nullptr; gguf = nullptr; meta = nullptr;
     tensors.clear();
 }
 
diff --git a/src/trellis_sched.cpp b/src/trellis_sched.cpp
new file mode 100644
index 0000000..4cbdfbc
--- /dev/null
+++ b/src/trellis_sched.cpp
@@ -0,0 +1,150 @@
+#include "trellis_sched.h"
+
+#include "trellis_debug.h"
+#include "trellis_model.h"
+
+#include "ggml-cpu.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <mutex>
+#include <vector>
+
+namespace trellis {
+
+namespace {
+
+int  g_sched_mode  = -1;   // -1 auto, 0 off, 1 on
+int  g_vulkan_fallback_mode = -1; // -1 environment, 0 off, 1 on
+
+// The DiT graphs are built with ggml_new_graph_custom(ctx, 32768, ...); the scheduler's
+// internal hash tables have to cover the largest graph we will hand it.
+constexpr size_t kSchedGraphSize = 40960;
+
+std::once_flag  g_cpu_once;
+ggml_backend_t  g_cpu = nullptr;
+
+std::once_flag              g_vulkan_once;
+std::vector<ggml_backend_t> g_vulkan; // Vulkan fallbacks for an HTP primary
+
+int resolve_mode() {
+    if (g_sched_mode >= 0) return g_sched_mode;
+    if (const char* e = std::getenv("TRELLIS_SCHED")) return atoi(e) > 0 ? 1 : 0;
+    return -1;   // still auto
+}
+
+bool vulkan_fallback_enabled() {
+    if (g_vulkan_fallback_mode >= 0) return g_vulkan_fallback_mode > 0;
+    const char* value = std::getenv("TRELLIS_VULKAN_FALLBACK");
+    return value && std::atoi(value) > 0;
+}
+
+}  // namespace
+
+void set_sched_mode(int mode) { g_sched_mode = mode; }
+void set_vulkan_fallback_mode(int mode) { g_vulkan_fallback_mode = mode; }
+
+ggml_backend_t fallback_cpu_backend() {
+    std::call_once(g_cpu_once, [] {
+        g_cpu = ggml_backend_cpu_init();
+        if (g_cpu) tune_cpu_threads(g_cpu);
+    });
+    return g_cpu;
+}
+
+const std::vector<ggml_backend_t>& vulkan_backends() {
+    std::call_once(g_vulkan_once, [] {
+        for (size_t i = 0; i < ggml_backend_dev_count(); ++i) {
+            ggml_backend_dev_t d = ggml_backend_dev_get(i);
+            ggml_backend_reg_t reg = ggml_backend_dev_backend_reg(d);
+            const char* reg_name = reg ? ggml_backend_reg_name(reg) : "";
+            if (std::strcmp(reg_name, "Vulkan") != 0) continue;
+            if (ggml_backend_t b = ggml_backend_dev_init(d, nullptr)) {
+                fprintf(stderr, "[trellis] Vulkan fallback %s (%s)\n",
+                        ggml_backend_name(b), ggml_backend_dev_description(d));
+                g_vulkan.push_back(b);
+            }
+        }
+    });
+    return g_vulkan;
+}
+
+bool sched_enabled_for(ggml_backend_t primary) {
+    const int mode = resolve_mode();
+    if (mode == 0) return false;
+    if (mode == 1) return true;
+    // Auto-enable only for the partial-coverage HTP backend. CUDA and Vulkan retain
+    // their existing direct execution path unless the user explicitly requests a scheduler.
+    return primary && std::strncmp(ggml_backend_name(primary), "HTP", 3) == 0;
+}
+
+ggml_backend_sched_t make_sched(ggml_backend_t primary) {
+    if (!primary) return nullptr;
+
+    std::vector<ggml_backend_t> backends;
+
+    if (!sched_enabled_for(primary)) return nullptr;
+    backends.push_back(primary);   // owns the weights and has highest priority
+    if (vulkan_fallback_enabled() &&
+        std::strncmp(ggml_backend_name(primary), "HTP", 3) == 0) {
+        for (ggml_backend_t b : vulkan_backends()) backends.push_back(b);
+    }
+    if (!ggml_backend_is_cpu(primary)) {
+        if (ggml_backend_t cpu = fallback_cpu_backend()) backends.push_back(cpu);
+    }
+
+    if (backends.size() < 2) {
+        fprintf(stderr, "[trellis] only one backend available; skipping scheduler\n");
+        return nullptr;
+    }
+
+    ggml_backend_sched_t s = ggml_backend_sched_new(
+        backends.data(), /*bufts=*/nullptr, (int) backends.size(),
+        kSchedGraphSize, /*parallel=*/false, /*op_offload=*/true);
+
+    if (!s) {
+        fprintf(stderr, "[trellis] failed to create backend scheduler; using %s alone\n", ggml_backend_name(primary));
+        return nullptr;
+    }
+
+    fprintf(stderr, "[trellis] scheduler:");
+    for (ggml_backend_t b : backends) fprintf(stderr, " %s", ggml_backend_name(b));
+    fprintf(stderr, "  (ops fall back in that order)\n");
+    return s;
+}
+
+GraphExec::GraphExec(const Model& m)
+    : backend_(m.backend), sched_(m.sched) {}
+
+GraphExec::~GraphExec() {
+    if (galloc_) ggml_gallocr_free(galloc_);
+    // sched_ is owned by the Model, not by us.
+}
+
+bool GraphExec::alloc(ggml_cgraph* graph) {
+    if (sched_) {
+        // Clears the previous graph's assignment; without it the scheduler keeps the old
+        // allocation and the freshly uploaded inputs would land in stale buffers.
+        ggml_backend_sched_reset(sched_);
+        if (!ggml_backend_sched_alloc_graph(sched_, graph)) {
+            fprintf(stderr, "[trellis] scheduler failed to allocate graph\n");
+            return false;
+        }
+        return true;
+    }
+    if (!galloc_) galloc_ = ggml_gallocr_new(ggml_backend_get_default_buffer_type(backend_));
+    return ggml_gallocr_alloc_graph(galloc_, graph);
+}
+
+ggml_status GraphExec::compute(ggml_cgraph* graph, const char* label) {
+    if (sched_) return compute_graph_sched(sched_, graph, label);
+    return compute_graph(backend_, graph, label);
+}
+
+size_t GraphExec::buffer_size() const {
+    if (galloc_) return ggml_gallocr_get_buffer_size(galloc_, 0);
+    return 0;
+}
+
+}  // namespace trellis