@@ -37,6 +37,7 @@
     deprecate,
     get_class_from_dynamic_module,
     is_accelerate_available,
+    is_flashpack_available,
     is_peft_available,
     is_transformers_available,
     is_transformers_version,
@@ -832,6 +833,45 @@ def load_sub_model(
         and transformers_version >= version.parse("4.20.0")
     )
 
+    # transformers' `from_pretrained` has no FlashPack support, so when a transformers component ships
+    # FlashPack weights, load it here the way `ModelMixin.from_pretrained` does for diffusers models:
+    # initialize the model on empty weights from its config, then assign the packed weights onto it.
+    # Component folders without a flashpack file (e.g. from repos saved before transformers components
+    # were packed) keep loading through their regular `load_method` below.
+    flashpack_file = os.path.join(cached_folder, name, FLASHPACK_WEIGHTS_NAME)
+    if use_flashpack and is_transformers_model and os.path.isfile(flashpack_file):
+        if not is_flashpack_available():
+            raise ImportError("Please install flashpack to load a pipeline with `use_flashpack=True`.")
+        import flashpack
+
+        config = class_obj.config_class.from_pretrained(os.path.join(cached_folder, name))
+        dtype_orig = None
+        if dtype is not None:
+            dtype_orig = torch.get_default_dtype()
+            torch.set_default_dtype(dtype)
+        with accelerate.init_empty_weights():
+            loaded_sub_model = class_obj(config)
+        if dtype_orig is not None:
+            torch.set_default_dtype(dtype_orig)
+
+        if device_map is None:
+            logger.warning(
+                "`device_map` has not been provided for FlashPack, model will be on `cpu` - provide `device_map` to fully utilize "
+                "the benefit of FlashPack."
+            )
+            flashpack_device = torch.device("cpu")
+        else:
+            device = device_map[""]
+            if isinstance(device, str) and device in ["auto", "balanced", "balanced_low_0", "sequential"]:
+                raise ValueError(
+                    "FlashPack `device_map` should not be one of `auto`, `balanced`, `balanced_low_0`, `sequential`. Use a specific device instead, e.g., `device_map='cuda'` or `device_map='cuda:0'"
+                )
+            flashpack_device = torch.device(device) if not isinstance(device, torch.device) else device
+
+        flashpack.mixin.assign_from_file(model=loaded_sub_model, path=flashpack_file, device=flashpack_device)
+        # transformers' `from_pretrained` always returns models in eval mode.
+        return loaded_sub_model.eval()
+
     # For transformers models >= 4.56.0, use 'dtype' instead of 'torch_dtype' to avoid deprecation warnings
     if issubclass(class_obj, torch.nn.Module):
         if is_transformers_model and transformers_version >= version.parse("4.56.0"):
 
@@ -61,6 +61,7 @@
 from ..utils import (
     CONFIG_NAME,
     DEPRECATED_REVISION_ARGS,
+    FLASHPACK_WEIGHTS_NAME,
     BaseOutput,
     PushToHubMixin,
     _get_detailed_type,
@@ -70,9 +71,11 @@
     is_accelerate_available,
     is_accelerate_version,
     is_bitsandbytes_version,
+    is_flashpack_available,
     is_hpu_available,
     is_torch_npu_available,
     is_torch_version,
+    is_transformers_available,
     is_transformers_version,
     logging,
     numpy_to_pil,
@@ -85,6 +88,9 @@
 if is_torch_npu_available():
     import torch_npu  # noqa: F401
 
+if is_transformers_available():
+    from transformers import PreTrainedModel
+
 from .pipeline_loading_utils import (
     ALL_IMPORTABLE_CLASSES,
     CONNECTED_PIPES_KEYS,
@@ -284,6 +290,9 @@ class implements both a save and loading method. The pipeline is easily reloaded
                 Whether or not to push your model to the Hugging Face model hub after saving it. You can specify the
                 repository you want to push to with `repo_id` (will default to the name of `save_directory` in your
                 namespace).
+            use_flashpack (`bool`, *optional*, defaults to `False`):
+                If set to `True`, model components (diffusers models as well as transformers models such as text
+                encoders) save their weights as a single `model.flashpack` file instead of safetensors.
 
             kwargs (`Dict[str, Any]`, *optional*):
                 Additional keyword arguments passed along to the [`~utils.PushToHubMixin.push_to_hub`] method.
@@ -322,6 +331,26 @@ def is_saveable_module(name, value):
                 sub_model = _unwrap_model(sub_model)
                 model_cls = sub_model.__class__
 
+            # transformers' `save_pretrained` has no FlashPack support, so mirror what
+            # `ModelMixin.save_pretrained(use_flashpack=True)` does for diffusers models: save the
+            # config as usual and pack the weights to a single `model.flashpack` file.
+            if use_flashpack and is_transformers_available() and isinstance(sub_model, PreTrainedModel):
+                if not is_flashpack_available():
+                    raise ImportError("Please install flashpack to save a pipeline with `use_flashpack=True`.")
+                import flashpack
+
+                component_directory = os.path.join(save_directory, pipeline_component_name)
+                os.makedirs(component_directory, exist_ok=True)
+                sub_model.config.save_pretrained(component_directory)
+                if sub_model.can_generate():
+                    sub_model.generation_config.save_pretrained(component_directory)
+                flashpack.serialization.pack_to_file(
+                    state_dict_or_model=sub_model.state_dict(),
+                    destination_path=os.path.join(component_directory, FLASHPACK_WEIGHTS_NAME),
+                    target_dtype=sub_model.dtype,
+                )
+                continue
+
             save_method_name = None
             # search for the model's base class in LOADABLE_CLASSES
             for library_name, library_classes in LOADABLE_CLASSES.items():
@@ -745,6 +774,11 @@ def from_pretrained(cls, pretrained_model_name_or_path: str | os.PathLike, **kwa
             dduf_file(`str`, *optional*):
                 Load weights from the specified dduf file. <Deprecated> This argument is deprecated and will be removed
                 in version 0.41.0. </Deprecated>
+            use_flashpack (`bool`, *optional*, defaults to `False`):
+                If set to `True`, model components whose folder contains a `model.flashpack` file (diffusers models as
+                well as transformers models such as text encoders) load their weights from it; FlashPack weights are
+                downloaded instead of the other formats for those components. If set to `False`, FlashPack weights are
+                never downloaded.
             disable_mmap ('bool', *optional*, defaults to 'False'):
                 Whether to disable mmap when loading a Safetensors model. This option can perform better when the model
                 is on a network mount or hard drive, which may not handle the seeky-ness of mmap very well.
 
@@ -118,17 +118,20 @@ def test_load_model_device_auto(self):
 
     @require_flashpack
     def test_download_filter_flashpack_pipeline_roundtrip(self):
-        # A flashpack pipeline mixes flashpack weights (diffusers components) with safetensors weights
-        # (transformers components). The download path must keep both; on `main` it drops the
-        # transformers safetensors, so the filtered snapshot fails to load. This is the e2e repro,
-        # inverted into a green test.
+        # A mixed repo pairs flashpack weights (diffusers components) with safetensors weights
+        # (transformers components) — the layout `save_pretrained(use_flashpack=True)` produced
+        # before transformers components were packed too. The download path must keep both formats;
+        # on `main` it drops the transformers safetensors, so the filtered snapshot fails to load.
         pipeline = AutoPipelineForText2Image.from_pretrained(self.model_id)
         # `ignore_cleanup_errors` because on Windows flashpack keeps `model.flashpack` mmap'd, which
         # blocks the temp-dir teardown (unrelated to what this test asserts).
         with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as temp_dir:
             saved = os.path.join(temp_dir, "saved")
             downloaded = os.path.join(temp_dir, "downloaded")
-            pipeline.save_pretrained(saved, use_flashpack=True)
+            pipeline.save_pretrained(saved)
+            for component in ("transformer", "vae"):
+                getattr(pipeline, component).save_pretrained(os.path.join(saved, component), use_flashpack=True)
+                os.remove(os.path.join(saved, component, "diffusion_pytorch_model.safetensors"))
             self.assertTrue((pathlib.Path(saved) / "transformer" / "model.flashpack").exists())
             self.assertTrue((pathlib.Path(saved) / "text_encoder" / "model.safetensors").exists())
 
@@ -148,6 +151,39 @@ def test_download_filter_flashpack_pipeline_roundtrip(self):
                 for key, value in original.items():
                     self.assertTrue(torch.equal(value, restored[key]))
 
+    @require_flashpack
+    def test_save_load_pipeline_transformers_flashpack(self):
+        # With `use_flashpack=True`, transformers components (text encoders) are packed too, so the
+        # pipeline is FlashPack end to end: no safetensors are written, the download filter keeps the
+        # flashpack weights, and the round trip restores every model component bitwise.
+        pipeline = AutoPipelineForText2Image.from_pretrained(self.model_id)
+        with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as temp_dir:
+            saved = os.path.join(temp_dir, "saved")
+            downloaded = os.path.join(temp_dir, "downloaded")
+            pipeline.save_pretrained(saved, use_flashpack=True)
+            for component in ("transformer", "vae", "text_encoder", "text_encoder_2"):
+                component_files = os.listdir(os.path.join(saved, component))
+                self.assertIn("model.flashpack", component_files)
+                self.assertFalse(any(f.endswith(".safetensors") for f in component_files))
+
+            kept = _files_kept_by_download_filter(saved, use_flashpack=True)
+            for component in ("transformer", "vae", "text_encoder", "text_encoder_2"):
+                self.assertIn(f"{component}/model.flashpack", kept)
+            for f in kept:
+                dst = os.path.join(downloaded, f)
+                os.makedirs(os.path.dirname(dst), exist_ok=True)
+                shutil.copy2(os.path.join(saved, f), dst)
+
+            reloaded = AutoPipelineForText2Image.from_pretrained(downloaded, use_flashpack=True)
+            for name in ("transformer", "vae", "text_encoder", "text_encoder_2"):
+                original = getattr(pipeline, name).state_dict()
+                restored = getattr(reloaded, name).state_dict()
+                self.assertEqual(original.keys(), restored.keys())
+                for key, value in original.items():
+                    self.assertTrue(torch.equal(value, restored[key]))
+            # transformers' `from_pretrained` returns models in eval mode; the flashpack path must too
+            self.assertFalse(reloaded.text_encoder.training)
+
     def test_ignore_patterns_flashpack_false_excludes_flashpack(self):
         # Dual-format repo (both safetensors and flashpack shipped). With `use_flashpack=False` the
         # flashpack files must be ignored and every safetensors kept.