@@ -19,6 +19,7 @@
 from sdm.processing import EnsembleProcessor
 from sdm.relational.join import join_index
 from sdm.tensor.categorical import _iter_categories
+from sdm.tensor.var_len import _cat, _contiguous
 
 _UNSIGNED_DTYPES = frozenset({torch.uint16, torch.uint32, torch.uint64})
 
@@ -339,56 +340,19 @@ def _string_category_lookups(
     ) -> tuple[Tensor, ...]:
         if not input_categories:
             return ()
-
-        # Pair IDs for each input category: (total_input_categories,).
-        left_pair = torch.cat(
-            [
-                codes.new_full((categories.numel(),), pair_index)
-                for pair_index, categories in enumerate(input_categories)
-            ]
-        )
-        # Pair IDs for each fitted category: (total_fitted_categories,).
-        right_pair = torch.cat(
-            [
-                codes.new_full((categories.numel(),), pair_index)
-                for pair_index, categories in enumerate(fitted_categories)
-            ]
-        )
-        left_index, right_index = join_index(
-            left_table=TableTensor(
-                columns={"id": ("pair", "value")},
-                id=ColumnarTensor(
-                    (left_pair, torch.cat(input_categories)),
-                ),
-            ),
-            right_table=TableTensor(
-                columns={"id": ("pair", "value")},
-                id=ColumnarTensor(
-                    (right_pair, torch.cat(fitted_categories)),
-                ),
-            ),
-            left_keys=["pair", "value"],
-            right_keys=["pair", "value"],
-            dtype=codes.dtype,
-        )
-        fitted_codes = torch.cat(
-            [
-                torch.arange(
-                    categories.numel(),
-                    dtype=codes.dtype,
-                    device=codes.device,
-                )
-                for categories in fitted_categories
-            ]
-        )
-        # Fitted code for each input category: (total_input_categories,).
-        lookup = codes.new_full(
-            (sum(categories.numel() for categories in input_categories),),
-            -1,
+        # StringTensor does not handle this custom op. Pass its underlying
+        # tensors and layout without copying the string data.
+        inputs, input_layout = _flatten_strings(input_categories)
+        fitted, fitted_layout = _flatten_strings(fitted_categories)
+        lookup = _string_category_lookup(
+            inputs=inputs,
+            input_layout=input_layout,
+            fitted=fitted,
+            fitted_layout=fitted_layout,
+            codes=codes,
         )
-        lookup[left_index] = fitted_codes[right_index]
         return lookup.split(
-            [categories.numel() for categories in input_categories]
+            [category.numel() for category in input_categories]
         )
 
     @staticmethod
@@ -535,3 +499,123 @@ def __repr__(self, *, indent: int = 0) -> str:
         return (
             f"{' ' * indent}{self.__class__.__name__}({', '.join(arguments)})"
         )
+
+
+def _flatten_strings(
+    categories: tuple[Tensor, ...],
+) -> tuple[list[Tensor | None], list[int]]:
+    """Pack vocabulary tensors and their (length, stride, offset) metadata."""
+    tensors: list[Tensor | None] = []
+    layout: list[int] = []
+    for category in categories:
+        category = cast(StringTensor, category)
+        tensors.extend((category._data, category._offset, category._valid))
+        layout.extend(
+            (
+                category.numel(),
+                category.stride(0),
+                category._logical_storage_offset,
+            )
+        )
+    return tensors, layout
+
+
+def _unflatten_strings(
+    tensors: list[Tensor | None], layout: list[int]
+) -> tuple[StringTensor, ...]:
+    """Rebuild string views over the same tensors for the join."""
+    return tuple(
+        StringTensor(
+            data=cast(Tensor, tensors[3 * i]),
+            offset=cast(Tensor, tensors[3 * i + 1]),
+            valid=tensors[3 * i + 2],
+            size=(layout[3 * i],),
+            stride=(layout[3 * i + 1],),
+            storage_offset=layout[3 * i + 2],
+        )
+        for i in range(len(layout) // 3)
+    )
+
+
+def _concatenate_strings(categories: tuple[StringTensor, ...]) -> StringTensor:
+    # Calling torch.cat here fails on StringTensor during compiled execution.
+    # Call SDM's concatenation implementation directly.
+    contiguous = tuple(
+        category if category.is_contiguous() else _contiguous(category)
+        for category in categories
+    )
+    return cast(StringTensor, _cat(contiguous))
+
+
+@torch.library.custom_op("sdm::string_category_lookup", mutates_args=())
+def _string_category_lookup(
+    inputs: list[Tensor | None],
+    input_layout: list[int],
+    fitted: list[Tensor | None],
+    fitted_layout: list[int],
+    codes: Tensor,
+) -> Tensor:
+    """Keep the backend join's dynamic row pairs inside a fixed-size lookup."""
+    input_categories = _unflatten_strings(inputs, input_layout)
+    fitted_categories = _unflatten_strings(fitted, fitted_layout)
+    # Pair IDs for each input category: (total_input_categories,).
+    left_pair = torch.cat(
+        [
+            codes.new_full((categories.numel(),), pair_index)
+            for pair_index, categories in enumerate(input_categories)
+        ]
+    )
+    # Pair IDs for each fitted category: (total_fitted_categories,).
+    right_pair = torch.cat(
+        [
+            codes.new_full((categories.numel(),), pair_index)
+            for pair_index, categories in enumerate(fitted_categories)
+        ]
+    )
+    left_index, right_index = join_index(
+        left_table=TableTensor(
+            columns={"id": ("pair", "value")},
+            id=ColumnarTensor(
+                (left_pair, _concatenate_strings(input_categories)),
+            ),
+        ),
+        right_table=TableTensor(
+            columns={"id": ("pair", "value")},
+            id=ColumnarTensor(
+                (right_pair, _concatenate_strings(fitted_categories)),
+            ),
+        ),
+        left_keys=["pair", "value"],
+        right_keys=["pair", "value"],
+        dtype=codes.dtype,
+    )
+    fitted_codes = torch.cat(
+        [
+            torch.arange(
+                categories.numel(),
+                dtype=codes.dtype,
+                device=codes.device,
+            )
+            for categories in fitted_categories
+        ]
+    )
+    # Fitted code for each input category: (total_input_categories,).
+    lookup = codes.new_full(
+        (sum(categories.numel() for categories in input_categories),),
+        -1,
+    )
+    lookup[left_index] = fitted_codes[right_index]
+    return lookup
+
+
+@_string_category_lookup.register_fake
+def _string_category_lookup_fake(
+    inputs: list[Tensor | None],
+    input_layout: list[int],
+    fitted: list[Tensor | None],
+    fitted_layout: list[int],
+    codes: Tensor,
+) -> Tensor:
+    # E.g. inputs ["red", "blue", "unknown"], fitted ["blue", "red"]:
+    # real lookup [1, 0, -1]; the fake result only describes its shape (3,).
+    return codes.new_empty((sum(input_layout[::3]),))
@@ -499,28 +499,21 @@ def flatten(value: Any) -> tuple[int, ...]:
 
     # Properties ##############################################################
 
+    @property
+    def _logical_storage_offset(self) -> int:
+        """Expose the logical view offset as traceable Python metadata."""
+        # torch.compile can read this integer as an attribute, but rejects
+        # the direct storage_offset() call on this tensor subclass.
+        return cast(int, self.storage_offset())
+
     @property
     def data_offset(self) -> tuple[Tensor, Tensor]:
         r"""Return contiguous data and normalized offsets.
 
         Returns:
             ``(data, offset)`` tuple.
         """
-        if not self.is_contiguous():
-            raise RuntimeError(
-                f"Can't access 'data_offset' for non-contiguous "
-                f"{self.__class__.__name__!r}"
-            )
-
-        start = int(self.storage_offset())
-        offset = self._offset[start : start + self.numel() + 1]
-        if self._data.numel() == 0:
-            # An empty payload has only zero offsets, already normalized.
-            return self._data, offset
-        data = self._data[offset[0] : offset[-1]]
-        if offset.is_cpu and int(offset[0]) == 0:
-            return data, offset
-        return data, offset - offset[0]
+        return _data_offset(self)
 
     @property
     def valid(self) -> Tensor | None:
@@ -530,15 +523,7 @@ def valid(self) -> Tensor | None:
             Boolean mask with shape ``self.size()`` indicating valid,
             non-null tensor elements, or ``None`` when all elements are valid.
         """
-        if self._valid is None:
-            return None
-
-        return torch.as_strided(
-            self._valid,
-            size=self.size(),
-            stride=self.stride(),
-            storage_offset=int(self.storage_offset()),
-        )
+        return _valid(self)
 
     @property
     def is_nullable(self) -> bool:
@@ -611,6 +596,13 @@ def __torch_function__(
         args: tuple[Any, ...] = (),
         kwargs: dict[str, Any] | None = None,
     ) -> Any:
+        if (
+            (func is torch.equal or func is Tensor.equal)
+            and not kwargs
+            and len(args) == 2
+            and type(args[0]) is type(args[1])
+        ):
+            return cls.HANDLED_FUNCTIONS[aten.equal.default](*args)
         if func is torch.isfinite or func is Tensor.isfinite:
             assert isinstance(args[0], VarLenTensor)
             return _isfinite(args[0])
@@ -1007,14 +999,44 @@ def _isfinite(inp: VarLenTensor) -> Tensor:
     return valid.clone()
 
 
+def _valid(inp: VarLenTensor) -> Tensor | None:
+    if inp._valid is None:
+        return None
+
+    return torch.as_strided(
+        inp._valid,
+        size=inp.size(),
+        stride=inp.stride(),
+        storage_offset=int(inp.storage_offset()),
+    )
+
+
+def _data_offset(inp: VarLenTensor) -> tuple[Tensor, Tensor]:
+    if not inp.is_contiguous():
+        raise RuntimeError(
+            f"Can't access 'data_offset' for non-contiguous "
+            f"{inp.__class__.__name__!r}"
+        )
+
+    start = int(inp.storage_offset())
+    offset = inp._offset[start : start + inp.numel() + 1]
+    if inp._data.numel() == 0:
+        # An empty payload has only zero offsets, already normalized.
+        return inp._data, offset
+    data = inp._data[offset[0] : offset[-1]]
+    if offset.is_cpu and int(offset[0]) == 0:
+        return data, offset
+    return data, offset - offset[0]
+
+
 @VarLenTensor.implements(aten.equal.default)
 def _equal(inp: VarLenTensor, other: Tensor) -> bool:
     if inp.__class__ is not other.__class__:
         return False
     if inp.size() != other.size():
         return False
 
-    valid1, valid2 = inp.valid, other.valid
+    valid1, valid2 = _valid(inp), _valid(other)
     if valid1 is not None and valid2 is not None:
         if not valid1.equal(valid2):
             return False
@@ -1032,8 +1054,8 @@ def _equal(inp: VarLenTensor, other: Tensor) -> bool:
         other.contiguous() if valid2 is None else other[valid2],
     )
 
-    data1, offset1 = inp.data_offset
-    data2, offset2 = other.data_offset
+    data1, offset1 = _data_offset(inp)
+    data2, offset2 = _data_offset(other)
 
     if not offset1.equal(offset2):
         return False
@@ -1332,7 +1354,7 @@ def _cat(tensors: Sequence[Tensor], dim: int = 0) -> VarLenTensor:
     tensors = tuple(
         cast(VarLenTensor, tensor.contiguous()) for tensor in tensors
     )
-    data_list, offsets = zip(*(tensor.data_offset for tensor in tensors))
+    data_list, offsets = zip(*(_data_offset(tensor) for tensor in tensors))
     valid: Tensor | None = None
     if any(tensor._valid is not None for tensor in tensors):
         valid_views = tuple(
 
@@ -504,3 +504,39 @@ def test_align_categories_ensemble_matches_member_fits(
         expected_query = reference.transform(query)
         assert query_output[member_id].equal(expected_query)
         assert fitted_query_output[member_id].equal(expected_query)
+
+
+def test_string_category_lookups_compile(compilation: None) -> None:
+    fitted = (
+        StringTensor.from_list(["a", "b"]),
+        StringTensor.from_list(["a", "x"]),
+    )
+    codes = torch.empty((), dtype=torch.int32)
+
+    def lookups(categories: StringTensor) -> tuple[torch.Tensor, ...]:
+        return AlignCategories._string_category_lookups(
+            input_categories=(categories, categories),
+            fitted_categories=fitted,
+            codes=codes,
+        )
+
+    compiled = torch.compile(lookups, backend="inductor", fullgraph=True)
+    first, second = compiled(StringTensor.from_list(["b", "z", "a"]))
+    torch.testing.assert_close(
+        actual=first,
+        expected=torch.tensor([1, -1, 0], dtype=codes.dtype),
+    )
+    torch.testing.assert_close(
+        actual=second,
+        expected=torch.tensor([-1, -1, 0], dtype=codes.dtype),
+    )
+
+    first, second = compiled(StringTensor.from_list(["x", "z", "q"]))
+    torch.testing.assert_close(
+        actual=first,
+        expected=torch.tensor([-1, -1, -1], dtype=codes.dtype),
+    )
+    torch.testing.assert_close(
+        actual=second,
+        expected=torch.tensor([1, -1, -1], dtype=codes.dtype),
+    )
@@ -484,6 +484,16 @@ def test_equal_allclose() -> None:
     assert torch.allclose(tensor, other[:, ::2])
 
 
+def test_compiled_equal_independent_views(compilation: None) -> None:
+    values = [[1], [2, 3]]
+    tensor = VarLenTensor.from_list(values)
+    other = VarLenTensor.from_list([[0], *values, [0]])[1:-1]
+    equal = torch.compile(torch.equal, backend="eager", fullgraph=False)
+
+    assert equal(tensor, other)
+    assert not equal(tensor, VarLenTensor.from_list([[99], [2, 3]]))
+
+
 def test_isnan_isfinite() -> None:
     tensor = VarLenTensor.from_list([[1, 2], None, [3]])
     assert tensor.is_nullable