@@ -28,6 +28,29 @@
 
 class COMPILE_SPEC_KEYS(Enum):
     METHOD_NAME = "method_name"
+    DATA_NAME = "data_name"
+
+
+# The name becomes a file name on every platform, so keep it short, to portable
+# characters, and clear of Windows device names such as NUL. Without re.ASCII,
+# IGNORECASE lets [A-Za-z] match letters like the Kelvin sign. A leading '-'
+# reads as an option on a command line. Some writers add .ptd only when it is
+# missing, so "encoder" and "encoder.ptd" could both write encoder.ptd.
+_DATA_NAME_PATTERN = re.compile(
+    r"(?!(?:CON|PRN|AUX|NUL|COM\d|LPT\d)(?:\.|$))(?!.*\.ptd$)"
+    r"[A-Za-z0-9_][A-Za-z0-9_.-]{0,199}",
+    re.IGNORECASE | re.ASCII,
+)
+
+
+def _checked_data_name(data_name: str) -> str:
+    if not _DATA_NAME_PATTERN.fullmatch(data_name):
+        raise ValueError(
+            f"Invalid data name {data_name!r}: use up to 200 ASCII letters, "
+            "digits, '_', '-' and '.', do not start with '.' or '-', do not end "
+            "with '.ptd', and avoid Windows device names such as NUL"
+        )
+    return data_name
 
 
 @experimental(
@@ -368,7 +391,9 @@ def preprocess(
         # Determine whether to save named data externally based on backend setting
         # External: save to separate .ptd file, otherwise merge with .pte file
         external_tag = (
-            f"aoti_{device_name}_blob" if cls.save_data_externally() else None
+            cls.data_name_from_compile_specs(compile_specs)
+            if cls.save_data_externally()
+            else None
         )
 
         named_data_store.add_named_data(weights_blob_key, blob_data, 1, external_tag)
@@ -404,6 +429,33 @@ def generate_method_name_compile_spec(
             method_name.encode("utf-8"),
         )
 
+    @classmethod
+    def generate_data_name_compile_spec(cls, data_name: str) -> CompileSpec:
+        """
+        Generate a CompileSpec that names the external data file, written as
+        ``<data_name>.ptd``, so several programs can share a folder.
+        """
+        if not cls.save_data_externally():
+            raise ValueError(
+                f"{cls.__name__} keeps its data in the .pte file, so it takes no "
+                "data name"
+            )
+        return CompileSpec(
+            COMPILE_SPEC_KEYS.DATA_NAME.value,
+            _checked_data_name(data_name).encode("utf-8"),
+        )
+
+    @classmethod
+    def data_name_from_compile_specs(cls, compile_specs: List[CompileSpec]) -> str:
+        """
+        The external data file name, without ``.ptd``, set by
+        generate_data_name_compile_spec, or ``aoti_<device>_blob`` by default.
+        """
+        for spec in compile_specs:
+            if spec.key == COMPILE_SPEC_KEYS.DATA_NAME.value:
+                return _checked_data_name(spec.value.decode("utf-8"))
+        return f"aoti_{cls.get_device_name()}_blob"
+
     @classmethod
     def method_name_from_compile_specs(
         cls,
 
@@ -704,6 +704,7 @@ def _preprocess_with_weight_collector(
             cls.get_device_name(),
             target_sm=target_sm,
             ptx_compute=ptx_compute,
+            external_tag=cls.data_name_from_compile_specs(compile_specs),
         )
         return result
 
@@ -726,6 +727,17 @@ def preprocess_multimethod(
         compile_specs: Dict[str, List[List[CompileSpec]]],
     ) -> Dict[str, List[PreprocessResult]]:
         """Compile every method against one global ``(device, FQN)`` store."""
+        # The methods share one weights file, so they must agree on its name.
+        data_names = {
+            cls.data_name_from_compile_specs(specs)
+            for method_specs in compile_specs.values()
+            for specs in method_specs
+        }
+        if len(data_names) > 1:
+            raise ValueError(
+                "Every method of a program must use the same data name, got "
+                f"{sorted(data_names)}"
+            )
         collector = CudaWeightCollector()
         results: Dict[str, List[PreprocessResult]] = {}
         for method_name, programs in edge_programs.items():
 
@@ -570,6 +570,7 @@ def add_preprocess_result(
         device_name: str,
         target_sm: Optional[int] = None,
         ptx_compute: int = 0,
+        external_tag: Optional[str] = None,
     ) -> None:
         if result.data_store_output is None:
             raise RuntimeError("CUDA AOTI preprocess returned no named data")
@@ -589,7 +590,7 @@ def add_preprocess_result(
             keep_compatibility_blob=not artifact.entries,
         )
 
-        external_tag = f"aoti_{device_name}_blob"
+        external_tag = external_tag or f"aoti_{device_name}_blob"
         serialized_entries = []
         for entry in artifact.entries:
             data = artifact.storages.get(entry.storage_key)
@@ -601,7 +602,7 @@ def add_preprocess_result(
                     ),
                 )
             if data is not None:
-                # Every program writes its weights to the same file name, so the
+                # Programs can write their weights to the same file name, so the
                 # key carries the content: another program's file then fails to
                 # load instead of running this program with its weights.
                 content_key = f"{entry.storage_key}:{data.sha256().hex()}"
 
@@ -208,6 +208,11 @@ def _load_artifact(source: CudaPteInput) -> _Artifact:
     return _Artifact(source, pte, _named_data_bytes(pte.named_data), ptd, delegates)
 
 
+# Compile specs that only shape how a variant was exported, so variants that
+# differ in them still merge.
+_EXPORT_ONLY_SPEC_KEYS = ("cuda_include_ptx", "data_name")
+
+
 def _normalized_program(program: Program) -> Program:
     normalized = copy.deepcopy(program)
     payloads = []
@@ -219,7 +224,7 @@ def _normalized_program(program: Program) -> Program:
                 delegate.compile_specs = [
                     spec
                     for spec in delegate.compile_specs
-                    if spec.key != "cuda_include_ptx"
+                    if spec.key not in _EXPORT_ONLY_SPEC_KEYS
                 ]
             delegate.processed = BackendDelegateDataReference(
                 location=DataLocation.INLINE, index=len(payloads)
@@ -534,7 +539,7 @@ def _prepare_merged_output(reference: _Artifact) -> Tuple[Program, NamedDataStor
                 delegate.compile_specs = [
                     spec
                     for spec in delegate.compile_specs
-                    if spec.key != "cuda_include_ptx"
+                    if spec.key not in _EXPORT_ONLY_SPEC_KEYS
                 ]
 
     merged_store = NamedDataStore()
 
@@ -236,6 +236,60 @@ def test_invalid_cuda_include_ptx_compile_spec(self):
                 [CompileSpec(key="cuda_include_ptx", value=b"MAYBE")]
             )
 
+    def test_invalid_data_name_compile_spec(self):
+        for name in (
+            "",
+            "..",
+            ".hidden",
+            "../outside",
+            "a/b",
+            "a\\b",
+            "a/../../outside",
+            "C:model",
+            "model?",
+            "nul",
+            "COM1.txt",
+            "a" * 201,
+            # Non-ASCII letters that IGNORECASE alone would let through.
+            "\u212a" * 200,
+            "\u017fizes",
+            "\u0130d",
+            "\u0131d",
+            "-enc",
+            # One writer turns "encoder.ptd" into the same file as "encoder".
+            # The check ignores case, like the rest of the pattern.
+            "encoder.ptd",
+            "encoder.PTD",
+        ):
+            with self.subTest(name=name):
+                with self.assertRaisesRegex(ValueError, "Invalid data name"):
+                    CudaBackend.generate_data_name_compile_spec(name)
+                with self.assertRaisesRegex(ValueError, "Invalid data name"):
+                    CudaBackend.data_name_from_compile_specs(
+                        [CompileSpec(key="data_name", value=name.encode())]
+                    )
+        # A backend that keeps its data in the .pte would ignore the name.
+        with patch.object(CudaBackend, "save_data_externally", return_value=False):
+            with self.assertRaisesRegex(ValueError, "takes no data name"):
+                CudaBackend.generate_data_name_compile_spec("encoder")
+
+    def test_valid_data_name_compile_spec(self):
+        self.assertEqual(CudaBackend.data_name_from_compile_specs([]), "aoti_cuda_blob")
+        for name in ("encoder", "model_sm80", "v1.2-final", "a" * 200, "x.ptd.bak"):
+            with self.subTest(name=name):
+                spec = CudaBackend.generate_data_name_compile_spec(name)
+                self.assertEqual(CudaBackend.data_name_from_compile_specs([spec]), name)
+
+    def test_methods_of_one_program_must_share_a_data_name(self):
+        def specs(name):
+            return [[CudaBackend.generate_data_name_compile_spec(name)]]
+
+        with self.assertRaisesRegex(ValueError, "same data name"):
+            CudaBackend.preprocess_multimethod(
+                {"forward": [None], "second": [None]},
+                {"forward": specs("first"), "second": specs("second")},
+            )
+
 
 class TestCudaExport(unittest.TestCase):
     """Test CUDA export functionality for various operations using to_edge_transform_and_lower."""
 
@@ -58,6 +58,7 @@ def _write_artifact(
         fqn: str = "model.weight",
         weight_key: str = "cuda_fqn_weight:cuda:model.weight",
         ptx_compute: int | None = None,
+        data_name: str | None = None,
     ) -> CudaPteInput:
         if ptx_compute is None:
             ptx_compute = target_sm
@@ -79,6 +80,8 @@ def _write_artifact(
         compile_specs.append(
             CompileSpec("cuda_include_ptx", b"ON" if ptx_compute else b"OFF")
         )
+        if data_name is not None:
+            compile_specs.append(CompileSpec("data_name", data_name.encode()))
         delegate = BackendDelegate(
             id="CudaBackend",
             processed=BackendDelegateDataReference(DataLocation.INLINE, 0),
@@ -148,8 +151,12 @@ def test_merges_variants_and_keeps_one_weight_manifest(self) -> None:
             sm80.mkdir()
             sm120.mkdir()
             inputs = [
-                self._write_artifact(sm80, 80, b"sm80-so", b"shared-weight"),
-                self._write_artifact(sm120, 120, b"sm120-so", b"shared-weight"),
+                self._write_artifact(
+                    sm80, 80, b"sm80-so", b"shared-weight", data_name="model_sm80"
+                ),
+                self._write_artifact(
+                    sm120, 120, b"sm120-so", b"shared-weight", data_name="model_sm120"
+                ),
             ]
 
             merged = deserialize_pte_binary(bytes(merge_cuda_pte_files(inputs)))
@@ -176,14 +183,14 @@ def test_merges_variants_and_keeps_one_weight_manifest(self) -> None:
                     hashlib.sha256(b"sm120-so").hexdigest() + "_so_blob",
                 },
             )
-            self.assertNotIn(
-                "cuda_include_ptx",
+            self.assertEqual(
                 {
                     spec.key
                     for spec in merged.program.execution_plan[0]
                     .delegates[0]
                     .compile_specs
                 },
+                {"method_name"},
             )
 
     def test_uses_ptx_only_from_explicit_fallback(self) -> None:
 
@@ -22,6 +22,7 @@
 import os
 import tempfile
 import unittest
+from typing import Optional
 
 import torch
 from executorch.backends.cuda.cuda_backend import CudaBackend
@@ -51,14 +52,25 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
     "loads through the Python runtime, which the ROCm build does not include",
 )
 class TestMissingWeightsBlob(unittest.TestCase):
-    def _lower(self, outdir: str, seed: int = 0, name: str = "model.pte") -> str:
+    def _lower(
+        self,
+        outdir: str,
+        seed: int = 0,
+        name: str = "model.pte",
+        data_name: Optional[str] = None,
+        module: Optional[torch.nn.Module] = None,
+    ) -> str:
         torch.manual_seed(seed)
-        module = ModuleWithConstants().eval().cuda()
+        if module is None:
+            module = ModuleWithConstants()
+        module = module.eval().cuda()
         inputs = (torch.randn(4, 64, device="cuda"),)
         exported = export(module, inputs)
-        spec = CudaBackend.generate_method_name_compile_spec("forward")
+        specs = [CudaBackend.generate_method_name_compile_spec("forward")]
+        if data_name is not None:
+            specs.append(CudaBackend.generate_data_name_compile_spec(data_name))
         lowered = to_edge_transform_and_lower(
-            exported, partitioner=[CudaPartitioner([spec])]
+            exported, partitioner=[CudaPartitioner(specs)]
         )
         program = lowered.to_executorch()
         path = os.path.join(outdir, name)
@@ -177,6 +189,39 @@ def test_load_fails_with_another_programs_blob(self) -> None:
             ):
                 program.load_method("forward")
 
+    def test_programs_with_their_own_data_names_share_a_folder(self) -> None:
+        from executorch.runtime import Runtime
+
+        with tempfile.TemporaryDirectory() as outdir:
+            for seed, name in ((0, "first"), (1, "second")):
+                self._lower(outdir, seed=seed, name=f"{name}.pte", data_name=name)
+            # A program with no constants still writes a data file.
+            self._lower(
+                outdir, name="third.pte", data_name="third", module=torch.nn.ReLU()
+            )
+            self.assertEqual(
+                sorted(f for f in os.listdir(outdir) if f.endswith(".ptd")),
+                ["first.ptd", "second.ptd", "third.ptd"],
+            )
+            for seed, name in ((0, "first"), (1, "second")):
+                # The same draws _lower made, so the same weights and input.
+                torch.manual_seed(seed)
+                module = ModuleWithConstants().eval().cuda()
+                value = torch.randn(4, 64, device="cuda")
+                method = (
+                    Runtime.get()
+                    .load_program(
+                        os.path.join(outdir, f"{name}.pte"),
+                        data_path=os.path.join(outdir, f"{name}.ptd"),
+                    )
+                    .load_method("forward")
+                )
+                out = method.execute([value.cpu()])
+                torch.testing.assert_close(
+                    (out[0] if isinstance(out, (list, tuple)) else out).cpu(),
+                    module(value).cpu(),
+                )
+
     def test_load_succeeds_when_the_model_has_no_constants(self) -> None:
         """A model with nothing to bind still loads without its weights blob.
 
 
@@ -81,6 +81,25 @@ save_pte_program(exec_program, model_name, "./output_dir")
 ```
 This generates `.pte` and `.ptd` files that can be executed on CUDA devices.
 
+The weights go to a data file named `aoti_cuda_blob.ptd`. To export several programs into one folder, give each program its own
+data file name. This partitioner writes `encoder.ptd`:
+
+```python
+partitioner = CudaPartitioner([
+    CudaBackend.generate_method_name_compile_spec("forward"),
+    CudaBackend.generate_data_name_compile_spec("encoder"),
+])
+```
+
+The name can have up to 200 ASCII letters, digits, `_`, `-` and `.`. It cannot start with `.` or `-`, cannot end with `.ptd`
+(the export adds it), and cannot be a Windows device name such as `NUL`. Load each program with its own data file:
+
+```python
+from executorch.runtime import Runtime
+
+program = Runtime.get().load_program("encoder.pte", data_path="encoder.ptd")
+```
+
 For a complete working example, see the [CUDA export script](https://github.com/pytorch/executorch/blob/main/examples/cuda/scripts/export.py).
 
 
 
@@ -170,9 +170,11 @@ The Torch-TensorRT docs call such a program *coalesced*.
 
 The export writes the weights of the CUDA part to a data file, `aoti_cuda_blob.ptd`, next to the
 `.pte`. Pass that file when you load the program: if the CUDA part has weights, loading fails
-without it. The file has the same name for every model, so a second export into the same directory
-overwrites the first one's weights, and the first model can then return wrong answers with no
-error. Save each model into its own directory.
+without it. By default the file has the same name for every model, so a second export into the
+same directory overwrites the first one's weights, and the first model then fails to load. To keep
+several models in one directory, give each its own data file name with
+`CudaBackend.generate_data_name_compile_spec`, as the
+[CUDA backend page](../cuda/cuda-overview.md) shows, or save each model into its own directory.
 
 ### Keeping inputs and outputs on the GPU
 
@@ -432,7 +434,8 @@ shows how to set the options that apply at run time, from C++ or from Python.
   Pass `external_engine_data="engines"` to `torch_tensorrt.save` to write the engines to
   `engines.ptd` instead of the `.pte`, and pass that file when you load the program.
   The Python loader takes one data file, so for a program that also uses the CUDA backend, pass
-  `external_engine_data="aoti_cuda_blob"` to share its file.
+  the name of the CUDA data file to share it: `external_engine_data="aoti_cuda_blob"` by default,
+  or the name given to `CudaBackend.generate_data_name_compile_spec`.
 - [**Optimization profiles.**](https://docs.pytorch.org/TensorRT/user_guide/runtime_performance/executorch.html#optimization-profiles)
   One engine can be tuned for several ranges of input shapes, for example one for decoding one
   token at a time and one for a long prompt. A C++ application picks the profile for each call