@@ -47,6 +47,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+polars-map = [
+  "polars-map>=0.1.1",
+]
 ibis = [
   "pyarrow>=18.0.0",
   "ibis-framework>=11.0.0",
@@ -151,6 +154,7 @@ dev = [
   "mermaid-py>=0.8.0",
   "mkdocs-metaxy",
   "pytest-postgresql>=8.0.0",
+  "polars-map>=0.1.1",
 ]
 
 examples = [
 
@@ -1,3 +1,4 @@
+import warnings
 from typing import Any, TypeAlias, cast, overload
 
 import narwhals as nw
@@ -7,6 +8,51 @@
 PolarsCompatibleFrame: TypeAlias = Frame | pl.DataFrame | pl.LazyFrame
 
 
+def _is_polars_map_dtype(dtype: pl.DataType) -> bool:
+    """Check if a Polars dtype is a polars_map.Map extension type without importing polars_map."""
+    return isinstance(dtype, pl.datatypes.classes.BaseExtension) and getattr(dtype, "_name", None) == "polars_map.map"
+
+
+def find_map_columns(df: Frame) -> list[str]:
+    """Return column names that have a Map type in the underlying frame.
+
+    Inspects the native backend (Polars, Arrow, Ibis) for Map-typed columns.
+    """
+    if df.implementation == nw.Implementation.POLARS:
+        from metaxy.config import MetaxyConfig
+
+        if not MetaxyConfig.get().enable_polars_map:
+            return []
+
+        native = df.to_native()
+        schema = native.collect_schema() if isinstance(native, pl.LazyFrame) else native.schema  # ty: ignore[union-attribute]
+        return [name for name, dtype in schema.items() if _is_polars_map_dtype(dtype)]
+
+    if df.implementation == nw.Implementation.PYARROW:
+        import pyarrow as pa
+
+        table = cast(pa.Table, df.to_native())
+        return [field.name for field in table.schema if pa.types.is_map(field.type)]
+
+    if df.implementation == nw.Implementation.IBIS:
+        import ibis
+        import ibis.expr.datatypes as dt
+
+        table = cast(ibis.Table, df.to_native())
+        return [name for name, dtype in table.schema().items() if isinstance(dtype, dt.Map)]
+
+    warnings.warn(
+        f"cannot identify Map columns for unsupported narwhals implementation {df.implementation}",
+        stacklevel=2,
+    )
+    return []
+
+
+def has_polars_map_columns(df: pl.DataFrame | pl.LazyFrame) -> bool:
+    """Check if a Polars DataFrame/LazyFrame has any polars_map.Map columns."""
+    return bool(find_map_columns(cast(Frame, nw.from_native(df))))
+
+
 def collect_to_polars(frame: PolarsCompatibleFrame) -> pl.DataFrame:
     """Helper to convert a Narwhals frame into an eager Polars DataFrame.
 
@@ -53,14 +99,30 @@ def switch_implementation_to_polars(frame: LazyFrameT) -> LazyFrameT: ...
 def switch_implementation_to_polars(frame: FrameT) -> FrameT:
     if frame.implementation == nw.Implementation.POLARS:
         return frame
-    elif isinstance(frame, nw.DataFrame):
-        return nw.from_native(frame.to_polars())
+
+    # Detect map columns before conversion (they lose their type in Polars)
+    from metaxy.config import MetaxyConfig
+
+    map_columns: list[str] = []
+    if MetaxyConfig.get().enable_polars_map:
+        map_columns = find_map_columns(frame)
+
+    if isinstance(frame, nw.DataFrame):
+        result = nw.from_native(frame.to_polars())
     elif isinstance(frame, nw.LazyFrame):
-        return nw.from_native(
-            frame.collect().to_polars(),
-        ).lazy()
+        result = nw.from_native(frame.collect().to_polars()).lazy()
     else:
         raise ValueError(f"Unsupported frame type: {type(frame)}")
 
+    # Reconstruct polars_map.Map columns that were lost during conversion
+    if map_columns:
+        from metaxy.versioning._arrow_map import convert_maps_to_polars_map
+
+        native = result.to_native()
+        native = convert_maps_to_polars_map(native, columns=map_columns)
+        result = nw.from_native(native)
+
+    return result
+
 
 __all__ = ["collect_to_polars"]
@@ -189,6 +189,11 @@ def _filter_incomplete_stores(cls, data: Any) -> Any:
 
     hash_truncation_length: int = PydanticField(default=8, description="Truncate hash values to this length.", ge=8)
 
+    enable_polars_map: bool = PydanticField(
+        default=False,
+        description="Use `polars-map.Map` datatype for versioning columns instead of `pl.Struct`. Experimental.",
+    )
+
     auto_create_tables: bool = PydanticField(
         default=False,
         description="Auto-create tables when opening stores. It is not advised to enable this setting in production.",
 
@@ -17,6 +17,7 @@
 
 from metaxy._decorators import public
 from metaxy._utils import collect_to_polars
+from metaxy.config import MetaxyConfig
 from metaxy.metadata_store.base import MetadataStore, MetadataStoreConfig
 from metaxy.metadata_store.types import AccessMode
 from metaxy.metadata_store.utils import is_local_path
@@ -26,6 +27,13 @@
 from metaxy.versioning.types import HashAlgorithm
 
 
+def _map_columns_from_delta_schema(schema: deltalake.Schema) -> list[str]:
+    """Return column names that have a native Arrow Map type in the Delta schema."""
+    from deltalake.schema import MapType
+
+    return [field.name for field in schema.fields if isinstance(field.type, MapType)]
+
+
 @public
 class DeltaMetadataStoreConfig(MetadataStoreConfig):
     """Configuration for DeltaMetadataStore.
@@ -268,6 +276,26 @@ def _write_feature(
         mode = write_opts.pop("mode", "append")
         storage_options = write_opts.pop("storage_options", None)
 
+        if MetaxyConfig.get().enable_polars_map:
+            # Collect to Arrow, convert Struct *_by_field → native MapArray
+            from metaxy.models.constants import METAXY_DATA_VERSION_BY_FIELD, METAXY_PROVENANCE_BY_FIELD
+            from metaxy.versioning._arrow_map import convert_extension_maps_to_native, convert_structs_to_maps
+
+            df_native = self._cast_enum_to_string(collect_to_polars(df))
+            df_native = convert_structs_to_maps(
+                df_native, columns=[METAXY_PROVENANCE_BY_FIELD, METAXY_DATA_VERSION_BY_FIELD]
+            )
+            arrow_table = df_native.to_arrow()
+            arrow_table = convert_extension_maps_to_native(arrow_table)
+            deltalake.write_deltalake(
+                table_uri,
+                arrow_table,
+                mode=mode,
+                storage_options=storage_options,
+                **(write_opts or {}),
+            )
+            return
+
         # Check if we can use sink_delta (Polars >= 1.37, native Polars LazyFrame)
         can_sink = (
             df.implementation == nw.Implementation.POLARS
@@ -378,6 +406,14 @@ def _read_feature(
             storage_options=self.storage_options or None,
         )
 
+        if MetaxyConfig.get().enable_polars_map:
+            delta_table = self._open_delta_table(feature_key, without_files=True)
+            map_columns = _map_columns_from_delta_schema(delta_table.schema())
+            if map_columns:
+                from metaxy.versioning._arrow_map import convert_maps_to_polars_map
+
+                lf = convert_maps_to_polars_map(lf, columns=map_columns)
+
         # Convert to Narwhals
         nw_lazy = nw.from_native(lf)
 
 
@@ -9,6 +9,7 @@
 
 if TYPE_CHECKING:
     from pyiceberg.catalog import Catalog
+    from pyiceberg.schema import Schema
     from pyiceberg.table import Table
 
 import narwhals as nw
@@ -19,6 +20,7 @@
 
 from metaxy._decorators import public
 from metaxy._utils import collect_to_polars
+from metaxy.config import MetaxyConfig
 from metaxy.metadata_store.base import MetadataStore, MetadataStoreConfig
 from metaxy.metadata_store.types import AccessMode
 from metaxy.metadata_store.utils import is_local_path
@@ -31,6 +33,13 @@
 """A ``(namespace, table_name)`` pair used by PyIceberg to locate a table within a catalog."""
 
 
+def _map_columns_from_iceberg_schema(schema: Schema) -> list[str]:
+    """Return column names that have a native Map type in the Iceberg schema."""
+    from pyiceberg.types import MapType
+
+    return [field.name for field in schema.fields if isinstance(field.field_type, MapType)]
+
+
 def _strip_casts() -> Callable[[Any], Any]:
     """Unwrap ``CAST(x AS type)`` → ``x`` to match PyIceberg's
     `row filter syntax <https://py.iceberg.apache.org/row-filter-syntax/>`_
@@ -257,7 +266,19 @@ def _write_feature(
             and Version(pl.__version__) >= Version("1.39.0")
         )
 
-        if can_sink:
+        if MetaxyConfig.get().enable_polars_map:
+            from metaxy.models.constants import METAXY_DATA_VERSION_BY_FIELD, METAXY_PROVENANCE_BY_FIELD
+            from metaxy.versioning._arrow_map import convert_extension_maps_to_native, convert_structs_to_maps
+
+            df_polars = self._cast_enum_to_string(collect_to_polars(df))
+            df_polars = convert_structs_to_maps(
+                df_polars, columns=[METAXY_PROVENANCE_BY_FIELD, METAXY_DATA_VERSION_BY_FIELD]
+            )
+            arrow_table = df_polars.to_arrow()
+            arrow_table = convert_extension_maps_to_native(arrow_table)
+            iceberg_table = self._ensure_table(identifier, arrow_table.schema)
+            iceberg_table.append(arrow_table, **kwargs)
+        elif can_sink:
             lf_native = df.to_native()
             assert isinstance(lf_native, pl.LazyFrame)
             arrow_schema = pl.DataFrame(schema=self._cast_enum_to_string(lf_native).collect_schema()).to_arrow().schema
@@ -296,7 +317,17 @@ def _read_feature(
         if not self.catalog.table_exists(identifier):
             return None
 
-        nw_lazy = nw.from_native(pl.scan_iceberg(self.catalog.load_table(identifier)))
+        iceberg_table = self.catalog.load_table(identifier)
+        lf = pl.scan_iceberg(iceberg_table)
+
+        if MetaxyConfig.get().enable_polars_map:
+            map_columns = _map_columns_from_iceberg_schema(iceberg_table.schema())
+            if map_columns:
+                from metaxy.versioning._arrow_map import convert_maps_to_polars_map
+
+                lf = convert_maps_to_polars_map(lf, columns=map_columns)
+
+        nw_lazy = nw.from_native(lf)
 
         if filters:
             nw_lazy = nw_lazy.filter(*filters)
 
@@ -61,6 +61,20 @@
     pass
 
 
+def _is_map_column(df: Frame, col_name: str) -> bool:
+    """Check if a column in a narwhals frame is a Map type.
+
+    Returns False immediately if enable_polars_map is not set.
+    Delegates to find_map_columns for backend-specific detection.
+    """
+    if not MetaxyConfig.get().enable_polars_map:
+        return False
+
+    from metaxy._utils import find_map_columns
+
+    return col_name in find_map_columns(df)
+
+
 # TypeVar for config types - used for typing from_config method
 MetadataStoreConfigT = TypeVar("MetadataStoreConfigT", bound="MetadataStoreConfig")
 
@@ -1229,7 +1243,7 @@ def hash_struct_version_column(
                     df.implementation,
                     message=f"`{hash_column}` will be calculated in Polars.",
                 )
-                df = nw.from_native(df.lazy().collect().to_polars())
+                df = switch_implementation_to_polars(nw.from_native(df.lazy().collect()))
 
             return cast(
                 Frame,
@@ -1647,10 +1661,12 @@ def _validate_schema(self, df: Frame) -> None:
         if METAXY_PROVENANCE_BY_FIELD not in schema.names():
             raise MetadataSchemaError(f"DataFrame must have '{METAXY_PROVENANCE_BY_FIELD}' column")
 
-        # Check that metaxy_provenance_by_field is a struct
+        # Check that metaxy_provenance_by_field is a struct or map
         provenance_dtype = schema[METAXY_PROVENANCE_BY_FIELD]
-        if not isinstance(provenance_dtype, nw.Struct):
-            raise MetadataSchemaError(f"'{METAXY_PROVENANCE_BY_FIELD}' column must be a Struct, got {provenance_dtype}")
+        if not isinstance(provenance_dtype, nw.Struct) and not _is_map_column(df, METAXY_PROVENANCE_BY_FIELD):
+            raise MetadataSchemaError(
+                f"'{METAXY_PROVENANCE_BY_FIELD}' column must be a Struct or Map, got {provenance_dtype}"
+            )
 
         # Note: metaxy_provenance is auto-computed if missing, so we don't validate it here