@@ -181,7 +181,16 @@ def __init__(
         # keeping the all-reduce outside the compiled region lets DDP ranks
         # (world_size > 1) use the same reduce-overhead graphs as the
         # single-learner path instead of falling back to eager.
-        if bool(cfg.compile) and device.type == "cuda":
+        if bool(cfg.compile) and device.type == "mps":
+            # MPS: inductor kernels measured ~2.6x SLOWER than eager
+            # MPSGraph on the g1-wbt-dance update (Mac Studio, torch 2.11),
+            # and MPS autocast bf16/fp16 gains nothing (~1%). aot_eager
+            # keeps the same MPSGraph kernels but removes the Python /
+            # dispatch overhead: measured 86ms vs 106ms per update(4),
+            # ~19% faster.
+            self._critic_backward_runtime = torch.compile(self._critic_backward, backend="aot_eager", dynamic=False)
+            self._actor_backward_runtime = torch.compile(self._actor_backward, backend="aot_eager", dynamic=False)
+        elif bool(cfg.compile) and device.type == "cuda":
             import torch._inductor.config as inductor_config
 
             inductor_config.compile_threads = 1
 
@@ -38,8 +38,12 @@ def resolve_collector_inference_device(device_spec: str) -> torch.device:
     device = torch.device(device_spec)
     if device.type == "cpu":
         return device
+    if device.type == "mps":
+        if not torch.backends.mps.is_available():
+            raise RuntimeError(f"collector_inference_device='{device_spec}' requested MPS, but MPS is unavailable")
+        return device
     if device.type != "cuda":
-        raise ValueError(f"collector_inference_device must be cpu or cuda, got '{device_spec}'")
+        raise ValueError(f"collector_inference_device must be cpu, cuda or mps, got '{device_spec}'")
     if not torch.cuda.is_available():
         raise RuntimeError(f"collector_inference_device='{device_spec}' requested CUDA, but CUDA is unavailable")
     index = torch.cuda.current_device() if device.index is None else device.index
@@ -136,15 +140,19 @@ def __init__(
         except KeyError as exc:
             raise ValueError("collector_amp_dtype must be 'fp16' or 'bf16'") from exc
 
-        self._flat_params = bind_flat_params(self.actor) if self.device.type == "cuda" else None
+        # MPS has no pinned host memory, CUDA graphs or stream-ordered copies;
+        # it shares the staged-host path with plain CPU staging buffers.
+        self._is_cuda = self.device.type == "cuda"
+        self._flat_params = bind_flat_params(self.actor) if self._is_cuda else None
         self._obs_host = None
         self._obs_device = None
         self._actions_host = None
-        if self.device.type == "cuda":
-            self._obs_host = torch.empty((self.num_envs, obs_dim), dtype=torch.float32, pin_memory=True)
+        if self.device.type in ("cuda", "mps"):
+            pin = self._is_cuda
+            self._obs_host = torch.empty((self.num_envs, obs_dim), dtype=torch.float32, pin_memory=pin)
             self._obs_device = torch.empty_like(self._obs_host, device=self.device)
-            self._actions_host = torch.empty((self.num_envs, act_dim), dtype=torch.float32, pin_memory=True)
-            if bool(self.async_options.collector_compile):
+            self._actions_host = torch.empty((self.num_envs, act_dim), dtype=torch.float32, pin_memory=pin)
+            if self._is_cuda and bool(self.async_options.collector_compile):
                 import torch._inductor.config as inductor_config
 
                 inductor_config.compile_threads = 1
@@ -201,7 +209,8 @@ def _infer(self, obs: torch.Tensor) -> torch.Tensor:
         self._actions_host.copy_(device_actions, non_blocking=True)
         # reduce-overhead may reuse CUDA Graph output storage. Complete D2H
         # before returning so the next replay cannot overwrite env actions.
-        torch.cuda.current_stream(self.device).synchronize()
+        if self._is_cuda:
+            torch.cuda.current_stream(self.device).synchronize()
         return self._actions_host
 
     def warmup_inference(self) -> None:
 
@@ -103,6 +103,9 @@ def select_collector_cpus(
 
 def apply_cpu_affinity(cpus: list[int], role: str) -> None:
     """Pin the current process to ``cpus``, intersected with allowed CPUs."""
+    if not hasattr(os, "sched_getaffinity"):
+        logger.warning("%s: CPU affinity is unsupported on this platform; skipping pinning to %s", role, sorted(cpus))
+        return
     allowed = os.sched_getaffinity(0)
     selected = sorted(set(cpus) & allowed)
     if not selected:
 
@@ -39,6 +39,8 @@
 from motrix_rl_builtin.fastsac.async_impl import numa
 from motrix_rl_builtin.fastsac.config import FastSacAsyncOptionsCfg
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True)
 class LearnerInfo:
@@ -148,8 +150,18 @@ def resolve_collector_inference_devices(
     :func:`motrix_rl_builtin.fastsac.async_impl.collector.resolve_collector_inference_device`.
     """
     device = torch.device(collector_inference_device)
-    if device.type not in ("cpu", "cuda"):
-        raise ValueError(f"collector_inference_device must be cpu or cuda, got '{collector_inference_device}'")
+    if device.type not in ("cpu", "cuda", "mps"):
+        raise ValueError(f"collector_inference_device must be cpu, cuda or mps, got '{collector_inference_device}'")
+    if device.type == "mps" and not torch.backends.mps.is_available():
+        raise RuntimeError(
+            f"collector_inference_device='{collector_inference_device}' requested MPS, but MPS is unavailable"
+        )  # noqa: E501
+    if device.type == "cuda" and device.index is None and not torch.cuda.is_available():
+        # Generic "cuda" means "the trainer's accelerator": on a CUDA-less
+        # host it degrades to the default device (MPS on Apple Silicon, CPU
+        # elsewhere), mirroring the learner's device resolution.
+        logger.warning("collector_inference_device='cuda' but CUDA is unavailable; using %s", default_device)
+        return [default_device] * num_collectors
     if (
         device.type == "cuda"
         and device.index is not None
@@ -305,6 +317,9 @@ def resolve_trainer_topology(
     # best-effort contract.
     def _base_cpus(node: int | None) -> list[int]:
         if node is None:
+            # macOS has no sched_getaffinity; degrade to no binding like worker.py
+            if not hasattr(os, "sched_getaffinity"):
+                return []
             return sorted(os.sched_getaffinity(0))
         try:
             return numa.numa_node_cpus(node)
 
@@ -55,6 +55,7 @@
     run_learner_process,
 )
 from motrix_rl_builtin.fastsac.config import FastSacCfg
+from motrix_rl_builtin.fastsac.device import resolve_default_device
 from motrix_rl_builtin.fastsac.wrap import FastSacEnvWrap
 
 torch.set_float32_matmul_precision("high")
@@ -75,7 +76,7 @@ def __init__(self, *, context: TrainerContext[FastSacCfg]) -> None:
     def _device(self) -> torch.device:
         if self._rlcfg.device:
             return torch.device(self._rlcfg.device)
-        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        return resolve_default_device()
 
     def _make_env(
         self,
@@ -690,6 +691,20 @@ def _render_panel(force: bool = False) -> None:
                     tb_writer.add_scalar(f"perf/collector_{k}_ms", v, step)
                 tb_writer.add_scalar("perf/learn_ms_total", learn_ms, step)
                 tb_writer.add_scalar("perf/learn_pct", learn_pct, step)
+                for rank_key, group in timing_groups.items():
+                    if rank_key == "collector":
+                        continue
+                    rank_tag = "" if rank_key == "learner" else f"{rank_key}/"
+
+                    def _emit_timing(prefix: str, node: dict) -> None:
+                        for key, value in node.items():
+                            name = f"{prefix}{key.replace(' ', '_')}"
+                            if isinstance(value, dict):
+                                _emit_timing(f"{name}_", value)
+                            else:
+                                tb_writer.add_scalar(f"perf/learner_{rank_tag}{name}_ms", value, step)
+
+                    _emit_timing("", group)
                 for k, v in last_stats["env_metrics"].items():
                     tb_writer.add_scalar(f"metrics/{k}", v, step)
                 for k, v in last_stats["reward_terms"].items():
 
@@ -57,6 +57,7 @@
     weight_receiver_for,
 )
 from motrix_rl_builtin.fastsac.config import FastSacCfg
+from motrix_rl_builtin.fastsac.device import resolve_default_device
 from motrix_rl_builtin.fastsac.wrap import FastSacEnvWrap
 from motrix_rl_builtin.fastsac.wrap_np import FastSacNpEnvWrap
 from motrix_rl_builtin.fastsac.wrap_torch import FastSacTorchEnvWrap
@@ -490,11 +491,12 @@ def run_learner_process(
         opts = cfg.trainer.async_options
         _pin_worker_cpus(_resolve_cpu_set(opts.learner_cpu_cores, "learner_cpu_cores"))
         num_collectors = len(all_rings)
-        device = (
-            torch.device(learner_device)
-            if learner_device is not None
-            else torch.device(cfg.device or ("cuda" if torch.cuda.is_available() else "cpu"))
-        )
+        if learner_device is not None:
+            device = torch.device(learner_device)
+        elif cfg.device:
+            device = torch.device(cfg.device)
+        else:
+            device = resolve_default_device()
         if num_learners > 1:
             if device.type != "cuda" or device.index is None:
                 raise ValueError(f"multi-learner requires explicit indexed CUDA learner devices, got {device}")
 
@@ -239,8 +239,11 @@ def __init__(self, shape, device, eps=1e-2, until=None):
         self.eps = eps
         self.until = until
         self.local_enabled = False
-        self._local_mean = torch.zeros(shape, dtype=torch.float64, device=device)
-        self._local_var = torch.ones(shape, dtype=torch.float64, device=device)
+        # MPS has no float64; the local accumulators exist only for the
+        # multi-learner merge (a CUDA-only path), so keep them on the CPU.
+        acc_device = device if torch.device(device).type != "mps" else torch.device("cpu")
+        self._local_mean = torch.zeros(shape, dtype=torch.float64, device=acc_device)
+        self._local_var = torch.ones(shape, dtype=torch.float64, device=acc_device)
         self._local_count = 0
         self.register_buffer("_mean", torch.zeros(shape).unsqueeze(0).to(device))
         self.register_buffer("_var", torch.ones(shape).unsqueeze(0).to(device))
 
@@ -0,0 +1,22 @@
+# Copyright Motphys Technology Co., Ltd. 2025, 2026
+# SPDX-License-Identifier: Apache-2.0
+
+"""Default Torch device resolution shared by the FastSAC trainers.
+
+CUDA first (identical to the historical behavior), then MPS on Apple
+Silicon, then CPU. Explicitly configured devices (``rl_cfg.device``,
+``collector_inference_device``) never pass through here.
+"""
+
+from __future__ import annotations
+
+import torch
+
+
+def resolve_default_device() -> torch.device:
+    """The trainer device when the configuration leaves it unset."""
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
@@ -24,6 +24,7 @@
 )
 from motrix_rl_builtin.fastsac.agent import FastSacAgent
 from motrix_rl_builtin.fastsac.config import FastSacCfg
+from motrix_rl_builtin.fastsac.device import resolve_default_device
 from motrix_rl_builtin.fastsac.wrap import FastSacEnvWrap
 from motrix_rl_builtin.fastsac.wrap_np import FastSacNpEnvWrap
 from motrix_rl_builtin.fastsac.wrap_torch import FastSacTorchEnvWrap
@@ -53,7 +54,7 @@ def __init__(
     def _device(self) -> torch.device:
         if self._rlcfg.device:
             return torch.device(self._rlcfg.device)
-        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        return resolve_default_device()
 
     def _make_env(
         self,
 
@@ -262,8 +262,8 @@ def test_collector_cuda_request_fails_without_cuda(monkeypatch) -> None:
         resolve_collector_inference_device("cuda")
 
 
-def test_collector_rejects_non_cpu_cuda_device() -> None:
-    with pytest.raises(ValueError, match="must be cpu or cuda"):
+def test_collector_rejects_unsupported_device() -> None:
+    with pytest.raises(ValueError, match="must be cpu, cuda or mps"):
         resolve_collector_inference_device("meta")