refactor: centralize model factories and defaults (#2198)

src/model/diffusion/minimax_h3.hpp

@@ -12,6 +12,7 @@
 #include "core/ggml_tensor_utils.h"
 
 #include "core/ggml_graph_cut.h"
+#include "model/common/block.hpp"
 #include "model/diffusion/dit.hpp"
 #include "model/diffusion/model.hpp"
 

src/model/diffusion/mmdit.hpp

@@ -14,6 +14,7 @@
 #include "core/util.h"
 #include "model/common/block.hpp"
 #include "model/common/ggml_block.hpp"
+#include "model/diffusion/dit.hpp"
 #include "model/diffusion/model.hpp"
 #include "model_loader.h"
 

src/model/integrations/anima.cpp

@@ -0,0 +1,43 @@
+#include "model/diffusion/anima.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_anima(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<AnimaConditioner>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                            tensor_storage_map,
+                                                            weight_manager,
+                                                            tokenizers);
+    result.diffusion               = std::make_shared<Anima::AnimaRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                            tensor_storage_map,
+                                                            "model.diffusion_model",
+                                                            weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& anima_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_ANIMA;
+            definition.geometry                       = {1, 16, 3};
+            definition.ref_image_preset               = "cosmos_reference";
+            definition.name                           = "Anima";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::WAN;
+            definition.traits.video_tae               = true;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_anima;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/boogu_image.cpp

@@ -0,0 +1,46 @@
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/boogu.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_boogu_image(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       true,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<Boogu::BooguImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                 tensor_storage_map,
+                                                                 "model.diffusion_model",
+                                                                 version,
+                                                                 weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& boogu_image_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_BOOGU_IMAGE;
+            definition.geometry                       = {1, 16, 3};
+            definition.ref_image_preset               = "z_image_omni";
+            definition.name                           = "Boogu Image";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX;
+            definition.sampling                       = {FLOW_PRED, 3.16f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_boogu_image;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/ernie_image.cpp

@@ -0,0 +1,44 @@
+#include "model/diffusion/ernie_image.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_ernie_image(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       false,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<ErnieImage::ErnieImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                      tensor_storage_map,
+                                                                      "model.diffusion_model",
+                                                                      weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& ernie_image_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_ERNIE_IMAGE;
+            definition.geometry                       = {1, 128, 3};
+            definition.name                           = "Ernie Image";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX2;
+            definition.sampling                       = {FLOW_PRED, 4.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_ernie_image;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/fibo2.cpp

@@ -0,0 +1,39 @@
+#include "model/diffusion/fibo2.hpp"
+#include "conditioning/conditioner.hpp"
+#include "conditioning/fibo2.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_fibo2(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<Fibo2Conditioner>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                            tensor_storage_map, weight_manager, tokenizers);
+    result.diffusion               = std::make_shared<Fibo2::Fibo2Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                            tensor_storage_map, "model.diffusion_model", weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& fibo2_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_FIBO2;
+            definition.geometry                       = {1, 128, 3};
+            definition.ref_image_preset               = "fibo2";
+            definition.name                           = "Fibo-2.0";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX2;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = FLUX_SCHEDULER;
+            definition.build                          = build_fibo2;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/flux.cpp

@@ -0,0 +1,159 @@
+#include "model/diffusion/flux.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model/integrations/flux.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_flux(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    bool is_chroma                 = false;
+    for (auto pair : tensor_storage_map) {
+        if (pair.first.find("distilled_guidance_layer.in_proj.weight") != std::string::npos) {
+            is_chroma = true;
+            break;
+        }
+    }
+    if (is_chroma) {
+        result.conditioner = std::make_shared<T5CLIPEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                              tensor_storage_map,
+                                                              false,
+                                                              1,
+                                                              false,
+                                                              weight_manager,
+                                                              sd_ctx_params->model_args);
+    } else if (version == VERSION_OVIS_IMAGE) {
+        result.conditioner = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                           tensor_storage_map,
+                                                           version,
+                                                           "",
+                                                           false,
+                                                           weight_manager,
+                                                           tokenizers);
+    } else {
+        result.conditioner = std::make_shared<FluxCLIPEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                                tensor_storage_map,
+                                                                weight_manager,
+                                                                tokenizers);
+    }
+    result.diffusion = std::make_shared<Flux::FluxRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                          tensor_storage_map,
+                                                          "model.diffusion_model",
+                                                          version,
+                                                          weight_manager,
+                                                          sd_ctx_params->model_args);
+    return true;
+}
+
+const std::vector<ModelDefinition>& flux_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_FLUX;
+            definition.geometry                         = {1, 16, 3};
+            definition.ref_image_preset                 = "flux_kontext";
+            definition.name                             = "Flux";
+            definition.traits.is_dit                    = true;
+            definition.traits.vae_kind                  = ModelVAEKind::FLUX;
+            definition.sampling                         = {FLUX_FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = FLUX_SCHEDULER;
+            definition.build                            = build_flux;
+            definition.sampling.flow_shift_from_weights = flux_guidance_flow_shift;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_FLUX_FILL;
+            definition.geometry                         = {1, 16, 3};
+            definition.ref_image_preset                 = "flux_kontext";
+            definition.name                             = "Flux Fill";
+            definition.traits.is_dit                    = true;
+            definition.traits.vae_kind                  = ModelVAEKind::FLUX;
+            definition.traits.is_inpaint                = true;
+            definition.sampling                         = {FLUX_FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = FLUX_SCHEDULER;
+            definition.build                            = build_flux;
+            definition.sampling.flow_shift_from_weights = flux_guidance_flow_shift;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_FLUX_CONTROLS;
+            definition.geometry                         = {1, 16, 3};
+            definition.ref_image_preset                 = "flux_kontext";
+            definition.name                             = "Flux Control";
+            definition.traits.is_dit                    = true;
+            definition.traits.vae_kind                  = ModelVAEKind::FLUX;
+            definition.traits.is_control                = true;
+            definition.sampling                         = {FLUX_FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = FLUX_SCHEDULER;
+            definition.build                            = build_flux;
+            definition.sampling.flow_shift_from_weights = flux_guidance_flow_shift;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_FLEX_2;
+            definition.geometry                         = {1, 16, 3};
+            definition.ref_image_preset                 = "flux_kontext";
+            definition.name                             = "Flex.2";
+            definition.traits.is_dit                    = true;
+            definition.traits.vae_kind                  = ModelVAEKind::FLUX;
+            definition.traits.is_inpaint                = true;
+            definition.traits.is_control                = true;
+            definition.sampling                         = {FLUX_FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = FLUX_SCHEDULER;
+            definition.build                            = build_flux;
+            definition.sampling.flow_shift_from_weights = flux_guidance_flow_shift;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_CHROMA_RADIANCE;
+            definition.geometry                         = {1, 3, 3};
+            definition.ref_image_preset                 = "flux_kontext";
+            definition.name                             = "Chroma Radiance";
+            definition.traits.is_dit                    = true;
+            definition.traits.vae_kind                  = ModelVAEKind::FLUX;
+            definition.traits.fake_vae                  = true;
+            definition.sampling                         = {FLUX_FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = FLUX_SCHEDULER;
+            definition.build                            = build_flux;
+            definition.sampling.flow_shift_from_weights = flux_guidance_flow_shift;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_OVIS_IMAGE;
+            definition.geometry                         = {1, 16, 3};
+            definition.ref_image_preset                 = "flux_kontext";
+            definition.name                             = "Ovis Image";
+            definition.traits.is_dit                    = true;
+            definition.traits.vae_kind                  = ModelVAEKind::FLUX;
+            definition.sampling                         = {FLUX_FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = FLUX_SCHEDULER;
+            definition.build                            = build_flux;
+            definition.sampling.flow_shift_from_weights = flux_guidance_flow_shift;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}
+
+float flux_guidance_flow_shift(const String2TensorStorage& weights) {
+    for (const auto& [name, tensor] : weights) {
+        if (starts_with(name, "model.diffusion_model.guidance_in.in_layer.weight"))
+            return 1.15f;
+    }
+    return 1.f;
+}

src/model/integrations/flux.hpp

@@ -0,0 +1,5 @@
+#ifndef __SD_MODEL_INTEGRATIONS_FLUX_HPP__
+#define __SD_MODEL_INTEGRATIONS_FLUX_HPP__
+#include "model.h"
+float flux_guidance_flow_shift(const String2TensorStorage& weights);
+#endif

src/model/integrations/flux2.cpp

@@ -0,0 +1,79 @@
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/flux.hpp"
+#include "model/integrations/flux.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_flux2(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    bool is_chroma                 = false;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       false,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<Flux::FluxRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                          tensor_storage_map,
+                                                          "model.diffusion_model",
+                                                          version,
+                                                          weight_manager,
+                                                          sd_ctx_params->model_args);
+    return true;
+}
+
+const std::vector<ModelDefinition>& flux2_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_FLUX2;
+            definition.geometry                         = {1, 128, 3};
+            definition.ref_image_preset                 = "flux2";
+            definition.name                             = "Flux.2";
+            definition.traits.is_dit                    = true;
+            definition.traits.vae_kind                  = ModelVAEKind::FLUX2;
+            definition.sampling                         = {FLUX_FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = FLUX2_SCHEDULER;
+            definition.build                            = build_flux2;
+            definition.sampling.flow_shift_from_weights = flux_guidance_flow_shift;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_FLUX2_KLEIN;
+            definition.geometry                         = {1, 128, 3};
+            definition.ref_image_preset                 = "flux2";
+            definition.name                             = "Flux.2 klein";
+            definition.traits.is_dit                    = true;
+            definition.traits.vae_kind                  = ModelVAEKind::FLUX2;
+            definition.sampling                         = {FLUX_FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = FLUX2_SCHEDULER;
+            definition.build                            = build_flux2;
+            definition.sampling.flow_shift_from_weights = flux_guidance_flow_shift;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_SEFI_IMAGE;
+            definition.geometry                       = {1, 144, 3};
+            definition.ref_image_preset               = "flux2";
+            definition.name                           = "SeFi-Image";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX2;
+            definition.sampling                       = {SEFI_FLOW_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_flux2;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/flux3.cpp

@@ -0,0 +1,38 @@
+#include "model/diffusion/flux3.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_flux3(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map, version, "", false, weight_manager, tokenizers);
+    result.diffusion               = std::make_shared<Flux3::Flux3Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                            tensor_storage_map, "model.diffusion_model", weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& flux3_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_FLUX3;
+            definition.geometry                       = {1, 128, 3};
+            definition.ref_image_preset               = "flux2";
+            definition.name                           = "Flux.3 Image Klein";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX2;
+            definition.sampling                       = {FLUX3_FLOW_PRED, 6.93f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_flux3;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/hidream_o1.cpp

@@ -0,0 +1,41 @@
+#include "model/diffusion/hidream_o1.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_hidream_o1(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<HiDreamO1::HiDreamO1Conditioner>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                                           tensor_storage_map,
+                                                                           weight_manager,
+                                                                           tokenizers);
+    result.diffusion               = std::make_shared<HiDreamO1::HiDreamO1Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                    tensor_storage_map,
+                                                                    "model",
+                                                                    weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& hidream_o1_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_HIDREAM_O1;
+            definition.geometry                       = {1, 3, 3};
+            definition.name                           = "HiDream O1";
+            definition.traits.is_dit                  = true;
+            definition.traits.fake_vae                = true;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_hidream_o1;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/hunyuan_video.cpp

@@ -0,0 +1,47 @@
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/hunyuan.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_hunyuan_video(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       false,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<Hunyuan::HunyuanVideoRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                     tensor_storage_map,
+                                                                     "model.diffusion_model",
+                                                                     version,
+                                                                     weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& hunyuan_video_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_HUNYUAN_VIDEO;
+            definition.geometry                         = {1, 32, 3};
+            definition.name                             = "Hunyuan Video";
+            definition.traits.is_dit                    = true;
+            definition.traits.supports_video_generation = true;
+            definition.traits.vae_kind                  = ModelVAEKind::HUNYUAN;
+            definition.traits.video_tae                 = true;
+            definition.sampling                         = {FLOW_PRED, 7.f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_hunyuan_video;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/ideogram4.cpp

@@ -0,0 +1,44 @@
+#include "model/diffusion/ideogram4.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_ideogram4(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       false,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<Ideogram4::Ideogram4Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                    tensor_storage_map,
+                                                                    "model.diffusion_model",
+                                                                    weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& ideogram4_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_IDEOGRAM4;
+            definition.geometry                       = {1, 128, 3};
+            definition.name                           = "Ideogram 4";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX2;
+            definition.sampling                       = {FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = LOGIT_NORMAL_SCHEDULER;
+            definition.build                          = build_ideogram4;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/iris.cpp

@@ -0,0 +1,37 @@
+#include "model/diffusion/iris.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_iris(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map, version, "", false, weight_manager, tokenizers);
+    result.diffusion               = std::make_shared<Iris::IrisRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                          tensor_storage_map, "model.diffusion_model", weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& iris_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_IRIS;
+            definition.geometry                       = {16, 3, 3};
+            definition.name                           = "Iris-3B";
+            definition.traits.is_dit                  = true;
+            definition.traits.fake_vae                = true;
+            definition.sampling                       = {FLOW_PRED, 4.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_iris;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/krea2.cpp

@@ -0,0 +1,46 @@
+#include "model/diffusion/krea2.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_krea2(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       true,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<Krea2::Krea2Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                            tensor_storage_map,
+                                                            "model.diffusion_model",
+                                                            weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& krea2_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_KREA2;
+            definition.geometry                       = {1, 16, 3};
+            definition.ref_image_preset               = "krea2_ostris_edit";
+            definition.name                           = "Krea2";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::WAN;
+            definition.traits.video_tae               = true;
+            definition.sampling                       = {FLUX_FLOW_PRED, 1.15f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_krea2;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/lens.cpp

@@ -0,0 +1,44 @@
+#include "model/diffusion/lens.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_lens(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       false,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<Lens::LensRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                          tensor_storage_map,
+                                                          "model.diffusion_model",
+                                                          weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& lens_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_LENS;
+            definition.geometry                       = {1, 128, 3};
+            definition.name                           = "Lens";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX2;
+            definition.sampling                       = {FLUX_FLOW_PRED, 1.83f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_lens;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/lingbot_video.cpp

@@ -0,0 +1,54 @@
+#include "model/diffusion/lingbot_video.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_lingbot_video(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    bool enable_vision             = false;
+    for (const auto& [name, _] : tensor_storage_map) {
+        if (starts_with(name, "text_encoders.llm.visual.")) {
+            enable_vision = true;
+            break;
+        }
+    }
+    result.conditioner = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       enable_vision,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion   = std::make_shared<LingBotVideo::LingBotVideoRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                          tensor_storage_map,
+                                                                          "model.diffusion_model",
+                                                                          weight_manager,
+                                                                          sd_ctx_params->model_args);
+    return true;
+}
+
+const std::vector<ModelDefinition>& lingbot_video_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_LINGBOT_VIDEO;
+            definition.geometry                         = {2, 16, 3};
+            definition.name                             = "LingBot Video";
+            definition.traits.is_dit                    = true;
+            definition.traits.supports_video_generation = true;
+            definition.traits.vae_kind                  = ModelVAEKind::WAN;
+            definition.traits.video_tae                 = true;
+            definition.sampling                         = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_lingbot_video;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/llada_image.cpp

@@ -0,0 +1,50 @@
+#include "model/diffusion/llada_image.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_llada_image(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLaDAImageEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                              tensor_storage_map,
+                                                              "text_encoders.llm",
+                                                              "queryformer",
+                                                              "text_projection",
+                                                              "sigvq",
+                                                              weight_manager,
+                                                              tokenizers);
+    result.diffusion               = std::make_shared<LLaDAImage::LLaDAImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                      tensor_storage_map,
+                                                                      "model.diffusion_model",
+                                                                      weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& llada_image_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_LLADA_IMAGE;
+            definition.geometry                       = {1, 128, 3};
+            definition.ref_image_preset               = "llada_image";
+            definition.name                           = "LLaDA-Image";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX2;
+            definition.sampling                       = {FLOW_PRED, 1.0f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = LLADA_IMAGE_SCHEDULER;
+            definition.build                          = build_llada_image;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}
+
+// The attention projections keep their diffusers names (JointAttention's split_qkv mode), so
+// only the patch-size-keyed dicts need flattening. Latents arrive already patchified from the
+// Flux2 VAE, so the only patch key is 1-1.

src/model/integrations/longcat.cpp

@@ -0,0 +1,47 @@
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/flux.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_longcat(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       true,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<Flux::FluxRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                          tensor_storage_map,
+                                                          "model.diffusion_model",
+                                                          version,
+                                                          weight_manager,
+                                                          sd_ctx_params->model_args);
+    return true;
+}
+
+const std::vector<ModelDefinition>& longcat_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_LONGCAT;
+            definition.geometry                       = {1, 16, 3};
+            definition.ref_image_preset               = "longcat";
+            definition.name                           = "Longcat-Image";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX;
+            definition.sampling                       = {FLUX_FLOW_PRED, 3.0f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_longcat;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/ltxav.cpp

@@ -0,0 +1,45 @@
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/ltxv.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_ltxav(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LTXAVEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                         tensor_storage_map,
+                                                         "text_encoders.llm",
+                                                         "text_embedding_projection",
+                                                         weight_manager,
+                                                         tokenizers);
+    result.diffusion               = std::make_shared<LTXV::LTXAVRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                           tensor_storage_map,
+                                                           "model.diffusion_model",
+                                                           weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& ltxav_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_LTXAV;
+            definition.geometry                         = {1, 128, 3};
+            definition.name                             = "LTXAV";
+            definition.traits.is_dit                    = true;
+            definition.traits.supports_video_generation = true;
+            definition.traits.vae_kind                  = ModelVAEKind::LTXAV;
+            definition.traits.video_tae                 = true;
+            definition.sampling                         = {FLUX_FLOW_PRED, 2.37f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = LTX2_SCHEDULER;
+            definition.build                            = build_ltxav;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/mage_flow.cpp

@@ -0,0 +1,45 @@
+#include "model/diffusion/mage_flow.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_mage_flow(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       true,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<MageFlow::MageFlowRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                  tensor_storage_map,
+                                                                  "model.diffusion_model",
+                                                                  weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& mage_flow_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_MAGE_FLOW;
+            definition.geometry                       = {1, 128, 3};
+            definition.ref_image_preset               = "mage_flow";
+            definition.name                           = "Mage Flow";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::MAGE;
+            definition.sampling                       = {FLOW_PRED, 6.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_mage_flow;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/ming_image.cpp

@@ -0,0 +1,38 @@
+#include "model/diffusion/ming_image.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_ming_image(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<MingImageEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                             tensor_storage_map, weight_manager, tokenizers);
+    result.diffusion               = std::make_shared<MingImage::MingImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                    tensor_storage_map, "model.diffusion_model", weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& ming_image_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_MING_IMAGE;
+            definition.geometry                       = {2, 16, 4};
+            definition.name                           = "Ming-Image";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::WAN;
+            definition.traits.video_tae               = true;
+            definition.sampling                       = {MING_IMAGE_FLOW_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_ming_image;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/minimax_h3.cpp

@@ -0,0 +1,46 @@
+#include "model/diffusion/minimax_h3.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_minimax_h3(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       true,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<MiniMaxH3::MiniMaxH3Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                    tensor_storage_map,
+                                                                    "model.diffusion_model",
+                                                                    weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& minimax_h3_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_MINIMAX_H3;
+            definition.geometry                         = {2, 24, 3};
+            definition.name                             = "MiniMax-H3";
+            definition.traits.is_dit                    = true;
+            definition.traits.supports_video_generation = true;
+            definition.traits.vae_kind                  = ModelVAEKind::MINIMAX_H3;
+            definition.traits.video_tae                 = true;
+            definition.sampling                         = {H3_AV_FLOW_PRED, 12.f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_minimax_h3;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/minit2i.cpp

@@ -0,0 +1,40 @@
+#include "model/diffusion/minit2i.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_minit2i(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<MiniT2IConditioner>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                              tensor_storage_map,
+                                                              weight_manager);
+    result.diffusion               = std::make_shared<MiniT2I::MiniT2IRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                tensor_storage_map,
+                                                                "model.diffusion_model.model.net",
+                                                                weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& minit2i_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_MINIT2I;
+            definition.geometry                       = {1, 3, 3};
+            definition.name                           = "MiniT2I";
+            definition.traits.is_dit                  = true;
+            definition.traits.fake_vae                = true;
+            definition.sampling                       = {MINIT2I_FLOW_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_minit2i;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/moss_image.cpp

@@ -0,0 +1,33 @@
+#include "model_definition.h"
+
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/moss_image.hpp"
+#include "pipeline/model_builders.h"
+
+static bool build_moss_image(const sd::model_builders::Context& ctx,
+                             const TokenizerConfig& tokenizers,
+                             sd::model_builders::CoreRunners& runners) {
+    runners.conditioner = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                        ctx.tensor_storage_map, ctx.version, "", false,
+                                                        ctx.weight_manager, tokenizers);
+    runners.diffusion   = std::make_shared<MOSSImage::MOSSImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                     ctx.tensor_storage_map, "model.diffusion_model", ctx.weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& moss_image_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        ModelDefinition definition;
+        definition.version                        = VERSION_MOSS_IMAGE;
+        definition.geometry                       = {1, 128, 3};
+        definition.name                           = "MOSS-Image";
+        definition.traits.is_dit                  = true;
+        definition.traits.vae_kind                = ModelVAEKind::FLUX2;
+        definition.sampling                       = {FLOW_PRED, 5.f};
+        definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+        definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+        definition.build                          = build_moss_image;
+        return std::vector<ModelDefinition>{std::move(definition)};
+    }();
+    return definitions;
+}

src/model/integrations/pid.cpp

@@ -0,0 +1,44 @@
+#include "model/diffusion/pid.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_pid(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       false,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<Pid::PiDRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                        tensor_storage_map,
+                                                        "model.diffusion_model.net",
+                                                        weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& pid_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_PID;
+            definition.geometry                       = {1, 3, 3};
+            definition.name                           = "PiD";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_format_override     = true;
+            definition.sampling                       = {FLOW_PRED, 1.5f};
+            definition.sampling.default_sample_method = LCM_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_pid;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/pixart.cpp

@@ -0,0 +1,67 @@
+#include "model/diffusion/pixart.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model/vae/auto_encoder_kl.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static void configure_pixart_vae(const sd::model_builders::Context& ctx,
+                                 const sd::model_builders::VAEOptions&,
+                                 VAE& vae) {
+    auto& model = static_cast<AutoEncoderKL&>(vae);
+    // Alpha-512 and Sigma share tensor layouts; Alpha-512 needs an explicit scale override.
+    if (ctx.tensor_storage_map.count("model.diffusion_model.csize_embedder.mlp.0.weight") != 0) {
+        model.scale_factor = 0.18215f;
+    }
+    for (const auto& [key, value] : parse_key_value_args(ctx.params.model_args, "model arg")) {
+        if (key == "pixart_vae_scale_factor") {
+            float parsed = 0.f;
+            if (parse_strict_float(value, parsed) && std::isfinite(parsed) && parsed > 0.f) {
+                model.scale_factor = parsed;
+            } else {
+                LOG_WARN("ignoring invalid PixArt model arg '%s=%s'", key.c_str(), value.c_str());
+            }
+        }
+    }
+    LOG_VERBOSE("pixart: VAE scale factor = %.5f", model.scale_factor);
+}
+
+static bool build_pixart(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<T5CLIPEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                          tensor_storage_map,
+                                                          true,
+                                                          0,
+                                                          false,
+                                                          weight_manager,
+                                                          sd_ctx_params->model_args);
+    result.diffusion               = std::make_shared<PixArt::PixArtRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                              tensor_storage_map,
+                                                              "model.diffusion_model",
+                                                              weight_manager,
+                                                              sd_ctx_params->model_args);
+    return true;
+}
+
+const std::vector<ModelDefinition>& pixart_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_PIXART;
+            definition.geometry                       = {2, 4, 3};
+            definition.name                           = "PixArt";
+            definition.traits.is_dit                  = true;
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_pixart;
+            definition.configure_vae                  = configure_pixart_vae;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/qwen_image.cpp

@@ -0,0 +1,87 @@
+#include "model/diffusion/qwen_image.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/qwen_image_2_1.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_qwen_image(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    bool enable_vision             = version != VERSION_QWEN_IMAGE_LAYERED;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       enable_vision,
+                                                       weight_manager,
+                                                       tokenizers);
+    if (version == VERSION_QWEN_IMAGE_2_1) {
+        result.diffusion = std::make_shared<Qwen::QwenImage21Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                     tensor_storage_map,
+                                                                     "model.diffusion_model",
+                                                                     weight_manager,
+                                                                     sd_ctx_params->model_args);
+    } else {
+        result.diffusion = std::make_shared<Qwen::QwenImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                   tensor_storage_map,
+                                                                   "model.diffusion_model",
+                                                                   version,
+                                                                   weight_manager,
+                                                                   sd_ctx_params->model_args);
+    }
+    return true;
+}
+
+const std::vector<ModelDefinition>& qwen_image_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_QWEN_IMAGE;
+            definition.geometry                       = {1, 16, 3};
+            definition.ref_image_preset               = "qwen";
+            definition.name                           = "Qwen Image";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::WAN;
+            definition.traits.video_tae               = true;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_qwen_image;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_QWEN_IMAGE_LAYERED;
+            definition.geometry                       = {1, 16, 4};
+            definition.ref_image_preset               = "qwen_layered";
+            definition.name                           = "Qwen Image Layered";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::WAN;
+            definition.traits.video_tae               = true;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_qwen_image;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_QWEN_IMAGE_2_1;
+            definition.geometry                       = {2, 64, 4};
+            definition.ref_image_preset               = "qwen";
+            definition.name                           = "Qwen Image 2.1";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::WAN;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = FLUX_SCHEDULER;
+            definition.build                          = build_qwen_image;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/sd.cpp

@@ -0,0 +1,261 @@
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/unet.hpp"
+#include "model/vae/auto_encoder_kl.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static void configure_sdxl_vae(const sd::model_builders::Context& ctx,
+                               const sd::model_builders::VAEOptions& options,
+                               VAE& vae) {
+    if (strlen(SAFE_STR(ctx.params.vae_path)) == 0 || ctx.params.force_sdxl_vae_conv_scale || options.external_vae_is_invalid) {
+        float vae_conv_2d_scale = 1.f / 32.f;
+        LOG_WARN(
+            "No valid VAE specified with --vae or --force-sdxl-vae-conv-scale flag set, "
+            "using Conv2D scale %.3f",
+            vae_conv_2d_scale);
+        static_cast<AutoEncoderKL&>(vae).set_conv2d_scale(vae_conv_2d_scale);
+    }
+}
+
+static bool build_sd(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    // SD1.x SD2.x SDXL
+    std::map<std::string, std::string> embbeding_map;
+    for (uint32_t i = 0; i < sd_ctx_params->embedding_count; i++) {
+        embbeding_map.emplace(SAFE_STR(sd_ctx_params->embeddings[i].name), SAFE_STR(sd_ctx_params->embeddings[i].path));
+    }
+    result.conditioner = std::make_shared<FrozenCLIPEmbedderWithCustomWords>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                                             tensor_storage_map,
+                                                                             embbeding_map,
+                                                                             version,
+                                                                             weight_manager,
+                                                                             tokenizers);
+    result.diffusion   = std::make_shared<UNetModelRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                         tensor_storage_map,
+                                                         "model.diffusion_model",
+                                                         version,
+                                                         weight_manager);
+    return true;
+}
+static prediction_t detect_sdxl_prediction(const String2TensorStorage& weights) {
+    if (weights.count("edm_vpred.sigma_max"))
+        return EDM_V_PRED;
+    return weights.count("v_pred") ? V_PRED : EPS_PRED;
+}
+
+const std::vector<ModelDefinition>& sd_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SD1;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SD 1.x";
+
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_SD1_INPAINT;
+            definition.geometry                       = {8, 4, 3};
+            definition.name                           = "SD 1.x Inpaint";
+            definition.traits.is_inpaint              = true;
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_SD1_PIX2PIX;
+            definition.geometry                       = {8, 4, 3};
+            definition.name                           = "Instruct-Pix2Pix";
+            definition.traits.is_unet_edit            = true;
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SD1_TINY_UNET;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SD 1.x Tiny UNet";
+
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SD2;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SD 2.x";
+
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            definition.sampling.probe_v_prediction    = true;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_SD2_INPAINT;
+            definition.geometry                       = {8, 4, 3};
+            definition.name                           = "SD 2.x Inpaint";
+            definition.traits.is_inpaint              = true;
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            definition.sampling.probe_v_prediction    = true;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SD2_TINY_UNET;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SD 2.x Tiny UNet";
+
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            definition.sampling.probe_v_prediction    = true;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SDXS_512_DS;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SDXS (512-DS)";
+
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SDXS_09;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SDXS (09)";
+
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            definition.sampling.probe_v_prediction    = true;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SDXL;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SDXL";
+
+            definition.sampling                         = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method   = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_sd;
+            definition.sampling.prediction_from_weights = detect_sdxl_prediction;
+            definition.configure_vae                    = configure_sdxl_vae;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_SDXL_INPAINT;
+            definition.geometry                         = {8, 4, 3};
+            definition.name                             = "SDXL Inpaint";
+            definition.traits.is_inpaint                = true;
+            definition.sampling                         = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method   = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_sd;
+            definition.sampling.prediction_from_weights = detect_sdxl_prediction;
+            definition.configure_vae                    = configure_sdxl_vae;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_SDXL_PIX2PIX;
+            definition.geometry                         = {8, 4, 3};
+            definition.name                             = "SDXL Instruct-Pix2Pix";
+            definition.traits.is_unet_edit              = true;
+            definition.sampling                         = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method   = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_sd;
+            definition.sampling.prediction_from_weights = detect_sdxl_prediction;
+            definition.configure_vae                    = configure_sdxl_vae;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SDXL_VEGA;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SDXL (Vega)";
+
+            definition.sampling                         = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method   = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_sd;
+            definition.sampling.prediction_from_weights = detect_sdxl_prediction;
+            definition.configure_vae                    = configure_sdxl_vae;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_SDXL_SSD1B;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "SDXL (SSD1B)";
+
+            definition.sampling                         = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method   = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_sd;
+            definition.sampling.prediction_from_weights = detect_sdxl_prediction;
+            definition.configure_vae                    = configure_sdxl_vae;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_SVD;
+            definition.geometry                         = {8, 4, 3};
+            definition.name                             = "SVD";
+            definition.traits.supports_video_generation = true;
+            definition.sampling                         = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method   = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_sd;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version  = VERSION_ESRGAN;
+            definition.geometry = {8, 4, 3};
+            definition.name     = "ESRGAN";
+
+            definition.sampling                       = {EPS_PRED, INFINITY};
+            definition.sampling.default_sample_method = EULER_A_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/sd3.cpp

@@ -0,0 +1,40 @@
+#include "conditioning/conditioner.hpp"
+#include "model/diffusion/mmdit.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_sd3(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<SD3CLIPEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                           tensor_storage_map,
+                                                           weight_manager,
+                                                           tokenizers);
+    result.diffusion               = std::make_shared<MMDiTRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                     tensor_storage_map,
+                                                     "model.diffusion_model",
+                                                     weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& sd3_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_SD3;
+            definition.geometry                       = {1, 16, 3};
+            definition.name                           = "SD3.x";
+            definition.traits.is_dit                  = true;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sd3;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/sensenova_u1.cpp

@@ -0,0 +1,38 @@
+#include "model/diffusion/sensenova_u1.h"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_sensenova_u1(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<SenseNovaU1Conditioner>();
+    result.diffusion               = std::make_shared<SenseNovaU1::SenseNovaU1Runner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                        tensor_storage_map,
+                                                                        "",
+                                                                        weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& sensenova_u1_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_SENSENOVA_U1_5;
+            definition.geometry                       = {32, 3, 3};
+            definition.name                           = "SenseNova U1.5";
+            definition.traits.is_dit                  = true;
+            definition.traits.fake_vae                = true;
+            definition.sampling                       = {SENSENOVA_U1_FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_sensenova_u1;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/wan.cpp

@@ -0,0 +1,119 @@
+#include "model/diffusion/wan.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model/audio/wav2vec2.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_wan(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<T5CLIPEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                          tensor_storage_map,
+                                                          true,
+                                                          0,
+                                                          true,
+                                                          weight_manager);
+    result.diffusion               = std::make_shared<WAN::WanRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                        tensor_storage_map,
+                                                        "model.diffusion_model",
+                                                        version,
+                                                        weight_manager);
+    if (strlen(SAFE_STR(sd_ctx_params->high_noise_diffusion_model_path)) > 0) {
+        result.high_noise_diffusion = std::make_shared<WAN::WanRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                       tensor_storage_map,
+                                                                       "model.high_noise_diffusion_model",
+                                                                       version,
+                                                                       weight_manager);
+    }
+    if (result.diffusion->get_desc() == "Wan2.1-I2V-14B" ||
+        result.diffusion->get_desc() == "Wan2.1-FLF2V-14B" ||
+        result.diffusion->get_desc() == "Wan2.1-I2V-1.3B") {
+        if (!sd::model_builders::ensure_backend_pair(ctx.backends, SDBackendModule::CLIP_VISION)) {
+            return false;
+        }
+        result.clip_vision = std::make_shared<FrozenCLIPVisionEmbedder>(ctx.backends.runtime_backend(SDBackendModule::CLIP_VISION),
+                                                                        tensor_storage_map,
+                                                                        weight_manager);
+    }
+    if (version == VERSION_WAN2_2_S2V &&
+        tensor_storage_map.count("wav2vec2.encoder.layer_norm.bias") > 0) {
+        if (!sd::model_builders::ensure_backend_pair(ctx.backends, SDBackendModule::AUDIO_ENCODER)) {
+            return false;
+        }
+        result.audio_encoder = std::make_shared<Wav2Vec2::Wav2Vec2ModelRunner>(ctx.backends.runtime_backend(SDBackendModule::AUDIO_ENCODER),
+                                                                               tensor_storage_map,
+                                                                               "wav2vec2.",
+                                                                               weight_manager);
+    }
+    return true;
+}
+
+const std::vector<ModelDefinition>& wan_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_WAN2;
+            definition.geometry                         = {2, 16, 3};
+            definition.name                             = "Wan 2.x";
+            definition.traits.is_dit                    = true;
+            definition.traits.supports_video_generation = true;
+            definition.traits.vae_kind                  = ModelVAEKind::WAN;
+            definition.traits.video_tae                 = true;
+            definition.sampling                         = {FLOW_PRED, 5.f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_wan;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_WAN2_2_I2V;
+            definition.geometry                         = {2, 16, 3};
+            definition.name                             = "Wan 2.2 I2V";
+            definition.traits.is_dit                    = true;
+            definition.traits.supports_video_generation = true;
+            definition.traits.vae_kind                  = ModelVAEKind::WAN;
+            definition.traits.video_tae                 = true;
+            definition.sampling                         = {FLOW_PRED, 5.f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_wan;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_WAN2_2_TI2V;
+            definition.geometry                         = {2, 48, 3};
+            definition.name                             = "Wan 2.2 TI2V";
+            definition.traits.is_dit                    = true;
+            definition.traits.supports_video_generation = true;
+            definition.traits.vae_kind                  = ModelVAEKind::WAN;
+            definition.traits.video_tae                 = true;
+            definition.sampling                         = {FLOW_PRED, 5.f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_wan;
+            result.push_back(std::move(definition));
+        }
+        {
+            ModelDefinition definition;
+            definition.version                          = VERSION_WAN2_2_S2V;
+            definition.geometry                         = {2, 16, 3};
+            definition.name                             = "Wan 2.2 S2V";
+            definition.traits.is_dit                    = true;
+            definition.traits.supports_video_generation = true;
+            definition.traits.vae_kind                  = ModelVAEKind::WAN;
+            definition.traits.video_tae                 = true;
+            definition.sampling                         = {FLOW_PRED, 5.f};
+            definition.sampling.default_sample_method   = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler       = DISCRETE_SCHEDULER;
+            definition.build                            = build_wan;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/z_image.cpp

@@ -0,0 +1,45 @@
+#include "model/diffusion/z_image.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_z_image(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       false,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<ZImage::ZImageRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                              tensor_storage_map,
+                                                              "model.diffusion_model",
+                                                              version,
+                                                              weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& z_image_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_Z_IMAGE;
+            definition.geometry                       = {1, 16, 3};
+            definition.name                           = "Z-Image";
+            definition.traits.is_dit                  = true;
+            definition.traits.vae_kind                = ModelVAEKind::FLUX;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_z_image;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}

src/model/integrations/z_image_l2p.cpp

@@ -0,0 +1,44 @@
+#include "model/diffusion/z_image_l2p.hpp"
+#include "conditioning/conditioner.hpp"
+#include "model_definition.h"
+#include "pipeline/model_builders.h"
+
+static bool build_z_image_l2p(const sd::model_builders::Context& ctx, const TokenizerConfig& tokenizers, sd::model_builders::CoreRunners& result) {
+    const auto* sd_ctx_params      = &ctx.params;
+    const auto& tensor_storage_map = ctx.tensor_storage_map;
+    const auto version             = ctx.version;
+    const auto& weight_manager     = ctx.weight_manager;
+    result.conditioner             = std::make_shared<LLMEmbedder>(ctx.backends.runtime_backend(SDBackendModule::TE),
+                                                       tensor_storage_map,
+                                                       version,
+                                                       "",
+                                                       false,
+                                                       weight_manager,
+                                                       tokenizers);
+    result.diffusion               = std::make_shared<ZImageL2P::ZImageL2PRunner>(ctx.backends.runtime_backend(SDBackendModule::DIFFUSION),
+                                                                    tensor_storage_map,
+                                                                    "model.diffusion_model",
+                                                                    weight_manager);
+    return true;
+}
+
+const std::vector<ModelDefinition>& z_image_l2p_definitions() {
+    static const std::vector<ModelDefinition> definitions = [] {
+        std::vector<ModelDefinition> result;
+        {
+            ModelDefinition definition;
+            definition.version                        = VERSION_Z_IMAGE_L2P;
+            definition.geometry                       = {16, 3, 3};
+            definition.name                           = "Z-Image L2P";
+            definition.traits.is_dit                  = true;
+            definition.traits.fake_vae                = true;
+            definition.sampling                       = {FLOW_PRED, 3.f};
+            definition.sampling.default_sample_method = EULER_SAMPLE_METHOD;
+            definition.sampling.default_scheduler     = DISCRETE_SCHEDULER;
+            definition.build                          = build_z_image_l2p;
+            result.push_back(std::move(definition));
+        }
+        return result;
+    }();
+    return definitions;
+}