huggingface · vasqu · Jul 2, 2026 · Mar 19, 2026 · Mar 19, 2026 · Mar 19, 2026
diff --git a/docs/source/en/_toctree.yml b/docs/source/en/_toctree.yml
@@ -122,6 +122,8 @@
       title: Kernels
     - local: perf_torch_compile
       title: torch.compile
+    - local: exporters
+      title: Exporters
     - local: perf_infer_gpu_multi
       title: Tensor parallelism
     - local: expert_parallelism
@@ -476,6 +478,8 @@
       title: Pipelines
     - local: main_classes/processors
       title: Processors
+    - local: main_classes/exporters
+      title: Exporters
     - local: main_classes/quantization
       title: Quantization
     - local: main_classes/tokenizer

diff --git a/docs/source/en/exporters.md b/docs/source/en/exporters.md
diff --git a/docs/source/en/main_classes/exporters.md b/docs/source/en/main_classes/exporters.md
@@ -0,0 +1,49 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Exporters
+
+New export backends can be added to Transformers by subclassing [`HfExporter`].
+
+<Tip>
+
+Learn how to use the built-in exporters in the [Exporters](../exporters) guide.
+
+</Tip>
+
+## AutoHfExporter
+
+[[autodoc]] exporters.auto.AutoHfExporter
+
+## AutoExportConfig
+
+[[autodoc]] exporters.auto.AutoExportConfig
+
+## HfExporter
+
+[[autodoc]] exporters.base.HfExporter
+
+## DynamoConfig
+
+[[autodoc]] exporters.configs.DynamoConfig
+
+## OnnxConfig
+
+[[autodoc]] exporters.configs.OnnxConfig
+
+## ExecutorchConfig
+
+[[autodoc]] exporters.configs.ExecutorchConfig
diff --git a/src/transformers/__init__.py b/src/transformers/__init__.py
@@ -106,6 +106,7 @@
     "dependency_versions_table": [],
     "distributed": [],
     "dynamic_module_utils": [],
+    "exporters": [],
     "feature_extraction_sequence_utils": ["SequenceFeatureExtractor"],
     "feature_extraction_utils": ["BatchFeature", "FeatureExtractionMixin"],
     "file_utils": [],

diff --git a/src/transformers/exporters/__init__.py b/src/transformers/exporters/__init__.py
@@ -0,0 +1,20 @@
+# Copyright 2026 The HuggingFace Inc. team. All rights reserved.
+# Modifications Copyright (C) 2025, Advanced Micro Devices, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .auto import AutoExportConfig, AutoHfExporter, get_hf_exporter, register_export_config, register_exporter
+from .base import HfExporter
+from .configs import DynamoConfig, ExecutorchConfig, ExportConfigMixin, ExportFormat, OnnxConfig
+from .exporter_dynamo import DynamoExporter
+from .exporter_executorch import ExecutorchExporter
+from .exporter_onnx import OnnxExporter
diff --git a/src/transformers/exporters/auto.py b/src/transformers/exporters/auto.py
@@ -0,0 +1,185 @@
+# Copyright 2026 The HuggingFace Inc. team. All rights reserved.
+# Modifications Copyright (C) 2025, Advanced Micro Devices, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Auto exporter factory for HuggingFace exporters."""
+
+from __future__ import annotations
+
+from ..utils import logging
+from .base import HfExporter
+from .configs import ExportConfigMixin, ExportFormat
+from .exporter_dynamo import DynamoConfig, DynamoExporter
+from .exporter_executorch import ExecutorchConfig, ExecutorchExporter
+from .exporter_onnx import OnnxConfig, OnnxExporter
+
+
+AUTO_EXPORTER_MAPPING = {
+    "executorch": ExecutorchExporter,
+    "dynamo": DynamoExporter,
+    "onnx": OnnxExporter,
+}
+
+AUTO_EXPORT_CONFIG_MAPPING = {
+    "executorch": ExecutorchConfig,
+    "dynamo": DynamoConfig,
+    "onnx": OnnxConfig,
+}
+
+logger = logging.get_logger(__name__)
+
+
+class AutoExportConfig:
+    """
+    The Auto-HF export config class that takes care of automatically dispatching to the correct
+    export config given an export config stored in a dictionary.
+    """
+
+    @classmethod
+    def from_dict(cls, export_config_dict: dict):
+        export_format = export_config_dict.get("export_format")
+
+        if export_format is None:
+            raise ValueError("export_config_dict must contain key 'export_format' set to exporter name")
+
+        # Allow passing an ExportFormat enum value or a plain string
+        if isinstance(export_format, ExportFormat):
+            name = export_format.value
+        else:
+            name = export_format
+
+        if name not in AUTO_EXPORT_CONFIG_MAPPING:
+            raise ValueError(
+                f"Unknown exporter type, got {name} - supported exporters are: {list(AUTO_EXPORT_CONFIG_MAPPING.keys())}"
+            )
+
+        target_cls = AUTO_EXPORT_CONFIG_MAPPING[name]
+        return target_cls.from_dict(export_config_dict)
+
+
+class AutoHfExporter:
+    """
+    The Auto-HF expoerter class that takes care of automatically instantiating to the correct
+    `HfExporter` given the `ExportConfig`.
+    """
+
+    @classmethod
+    def from_config(cls, export_config: ExportConfigMixin | dict, **kwargs) -> HfExporter:
+        # Normalize to a dict so ``supports_export_format`` can act as the single gate.
+        export_config_dict = export_config.to_dict() if isinstance(export_config, ExportConfigMixin) else export_config
+        if not cls.supports_export_format(export_config_dict):
+            raise ValueError(
+                f"Unsupported export config: {export_config_dict!r}. "
+                f"Registered exporters: {sorted(AUTO_EXPORTER_MAPPING)}."
+            )
+
+        export_format = export_config_dict["export_format"]
+        name = export_format.value if isinstance(export_format, ExportFormat) else export_format
+        return AUTO_EXPORTER_MAPPING[name](**kwargs)
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path, **kwargs) -> HfExporter | None:
+        """
+        Load an exporter instance from a pretrained model/checkpoint that ships an export config.
+
+        **Not implemented yet** — placeholder for a first-class "export recipe" workflow.
+
+        The idea: model owners publish an ``export_config.json`` (or an ``export_config`` field in
+        ``config.json``) alongside their weights on the Hub. That file captures the settings the
+        owner has already validated for their architecture — the target format (``dynamo`` /
+        ``onnx`` / ``executorch``), exact dynamic-shape specs (e.g. ``text_ids`` dynamic to 4096,
+        image tiles fixed at 448, ``batch=1`` for edge deployment), ``strict`` flag, ONNX opset,
+        prefill vs. decode layout, ExecuTorch backend choice, and any other knob that today lives
+        as tribal knowledge in a README or a private notebook.
+
+        Consumers then get the owner-validated export in one call::
+
+            exporter = AutoHfExporter.from_pretrained("org/model-name")
+            program = exporter.export(model, inputs)
+
+        Composes with the [`register_export_input_preparer`] registry: the owner supplies the
+        shape spec via ``export_config.json``, transformers supplies the data-dependent
+        precomputations (``cu_seqlens``, vision position ids, window indices, …) for that
+        architecture. Together they cover the two hard parts of exporting new models — knowing
+        the right shape contract and preparing the right inputs — so downstream users don't
+        re-derive either from scratch (and don't break in production when they get it wrong).
+        """
+        raise NotImplementedError(
+            "AutoHfExporter.from_pretrained is not implemented yet. "
+            "Load/export configs explicitly and call AutoHfExporter.from_config(...) instead."
+        )
+
+    @staticmethod
+    def supports_export_format(export_config_dict: dict) -> bool:
+        """Return True if the provided dict describes an ``export_format`` that has both a
+        registered config class and a registered exporter class. Warns with an actionable message
+        when the format is missing entirely, unknown, or only half-registered."""
+        export_fmt = export_config_dict.get("export_format")
+        if export_fmt is None:
+            logger.warning(
+                "No 'export_format' key in export config — supported values are: "
+                f"{sorted(AUTO_EXPORTER_MAPPING)}. Skipping."
+            )
+            return False
+
+        name = export_fmt.value if isinstance(export_fmt, ExportFormat) else export_fmt
+        has_config = name in AUTO_EXPORT_CONFIG_MAPPING
+        has_exporter = name in AUTO_EXPORTER_MAPPING
+
+        if not has_config and not has_exporter:
+            logger.warning(
+                f"Unknown export format {export_fmt!r} — supported values are: "
+                f"{sorted(set(AUTO_EXPORTER_MAPPING) & set(AUTO_EXPORT_CONFIG_MAPPING))}. Skipping."
+            )
+            return False
+        if not has_config:
+            logger.warning(
+                f"Export format {name!r} has a registered exporter but no config class. "
+                f"Register one via ``@register_export_config({name!r})``. Skipping."
+            )
+            return False
+        if not has_exporter:
+            logger.warning(
+                f"Export format {name!r} has a registered config class but no exporter. "
+                f"Register one via ``@register_exporter({name!r})``. Skipping."
+            )
+            return False
+        return True
+
+
+def register_exporter(name: str):
+    def register_exporter_fn(cls):
+        if name in AUTO_EXPORTER_MAPPING:
+            logger.warning(f"Exporter '{name}' is already registered and will be overwritten.")
+        if not issubclass(cls, HfExporter):
+            raise TypeError("Exporter must extend HfExporter")
+        AUTO_EXPORTER_MAPPING[name] = cls
+        return cls
+
+    return register_exporter_fn
+
+
+def register_export_config(name: str):
+    def register_export_config_fn(cls):
+        if name in AUTO_EXPORT_CONFIG_MAPPING:
+            logger.warning(f"Export config '{name}' is already registered and will be overwritten.")
+        if not issubclass(cls, ExportConfigMixin):
+            raise TypeError("Export config must extend ExportConfigMixin")
+        AUTO_EXPORT_CONFIG_MAPPING[name] = cls
+        return cls
+
+    return register_export_config_fn
+
+
+def get_hf_exporter(export_config) -> HfExporter:
+    return AutoHfExporter.from_config(export_config)