miniworld-engine 2.3.11__tar.gz → 2.3.12__tar.gz

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: miniworld-engine
-Version: 2.3.11
+Version: 2.3.12
 Summary: MiniWorld GPU kernel development repo — Triton / CUDA kernels + benches for AF3-style ops (triangle multiplication, transition, attention, ...).
 License-Expression: MIT AND Apache-2.0 AND BSD-3-Clause
 Requires-Python: >=3.10
@@ -39,7 +39,7 @@ Dynamic: license-file
 # miniworld-engine
 
 GPU kernel library for MiniWorld / AF3-style ops. Each op is cut out of the model and
-optimized in isolation: **hand-written CUDA where it exists, a Triton fallback on every other GPU**
+optimized in isolation: **hand-written CUDA where it exists, a portable kernel fallback on every other GPU**
 (H100 and B200 have none, on purpose: they fall back to PyTorch), and a PyTorch reference that defines what "correct" means.
 
 > **Where this fits.** miniworld-engine is the bottom layer of a three-layer stack: it owns
@@ -47,7 +47,7 @@ optimized in isolation: **hand-written CUDA where it exists, a Triton fallback o
 > blocks; terminal product repos assemble those into full models. Boundary rules live in
 > team-gm's `docs/ARCHITECTURE.md`.
 
-**Version 2.3.11** — CUDA + Triton only (CuTe/quack removed), torch 2.13 (CUDA 12.9 or 13.0), prebuilt H100 kernels,
+**Version 2.3.12** — CUDA + portable kernels only (CuTe/quack removed), torch 2.13 (CUDA 12.9 or 13.0), prebuilt H100 kernels,
 cuequivariance 0.12. [Changelog](docs/CHANGELOG.md) ·
 [attribution](licenses/THIRD_PARTY_NOTICES.md).
 
@@ -71,7 +71,7 @@ to read a number.
 python -m pip install -e .
 ```
 
-**2. Check what you have.** Prints the version and the config set every triton kernel will search
+**2. Check what you have.** Prints the version and the config set every kernel will search
 if you do nothing else.
 
 ```bash
@@ -199,12 +199,12 @@ from the code.
 
 **The minimum supported architecture is sm80.** The generated table above states each
 registered kernel's minimum architecture; it is not a numerical qualification for every
-listed GPU. The public backends are `pytorch`, `miniworld`, `cuequivariance` and `anthropic`; Triton is
-not one of them. `miniworld` runs the engine's CUDA path where one serves the call; on a card without one
-it routes to the internal Triton kernel family only if the engine holds a record for that exact card
+listed GPU. The values of `implementation` are `pytorch`, `miniworld`, `cuequivariance` and `anthropic`; `miniworld` routes per card
+automatically. It runs the engine's CUDA path where one serves the call; on a card without one
+it routes to the engine's portable kernels only if the engine holds a record for that exact card
 (`autotune/manifests/`), else it warns and runs the PyTorch reference
-([docs/dispatch.md](docs/dispatch.md)). `settings.force_triton_kernels` is the internal A/B switch that
-forces the Triton family. Native CUDA variants can require a newer architecture.
+([docs/dispatch.md](docs/dispatch.md)). `settings.force_portable_kernels` is the internal A/B switch that
+forces the portable kernels. Native CUDA variants can require a newer architecture.
 
 One extension is **not** in the table because it is not in the registry: `transition_b2b_cuda`,
 which the `Transition` module builds on demand, is compiled for `sm_90a` and fails to build on

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/README.md

@@ -1,7 +1,7 @@
 # miniworld-engine
 
 GPU kernel library for MiniWorld / AF3-style ops. Each op is cut out of the model and
-optimized in isolation: **hand-written CUDA where it exists, a Triton fallback on every other GPU**
+optimized in isolation: **hand-written CUDA where it exists, a portable kernel fallback on every other GPU**
 (H100 and B200 have none, on purpose: they fall back to PyTorch), and a PyTorch reference that defines what "correct" means.
 
 > **Where this fits.** miniworld-engine is the bottom layer of a three-layer stack: it owns
@@ -9,7 +9,7 @@ optimized in isolation: **hand-written CUDA where it exists, a Triton fallback o
 > blocks; terminal product repos assemble those into full models. Boundary rules live in
 > team-gm's `docs/ARCHITECTURE.md`.
 
-**Version 2.3.11** — CUDA + Triton only (CuTe/quack removed), torch 2.13 (CUDA 12.9 or 13.0), prebuilt H100 kernels,
+**Version 2.3.12** — CUDA + portable kernels only (CuTe/quack removed), torch 2.13 (CUDA 12.9 or 13.0), prebuilt H100 kernels,
 cuequivariance 0.12. [Changelog](docs/CHANGELOG.md) ·
 [attribution](licenses/THIRD_PARTY_NOTICES.md).
 
@@ -33,7 +33,7 @@ to read a number.
 python -m pip install -e .
 ```
 
-**2. Check what you have.** Prints the version and the config set every triton kernel will search
+**2. Check what you have.** Prints the version and the config set every kernel will search
 if you do nothing else.
 
 ```bash
@@ -161,12 +161,12 @@ from the code.
 
 **The minimum supported architecture is sm80.** The generated table above states each
 registered kernel's minimum architecture; it is not a numerical qualification for every
-listed GPU. The public backends are `pytorch`, `miniworld`, `cuequivariance` and `anthropic`; Triton is
-not one of them. `miniworld` runs the engine's CUDA path where one serves the call; on a card without one
-it routes to the internal Triton kernel family only if the engine holds a record for that exact card
+listed GPU. The values of `implementation` are `pytorch`, `miniworld`, `cuequivariance` and `anthropic`; `miniworld` routes per card
+automatically. It runs the engine's CUDA path where one serves the call; on a card without one
+it routes to the engine's portable kernels only if the engine holds a record for that exact card
 (`autotune/manifests/`), else it warns and runs the PyTorch reference
-([docs/dispatch.md](docs/dispatch.md)). `settings.force_triton_kernels` is the internal A/B switch that
-forces the Triton family. Native CUDA variants can require a newer architecture.
+([docs/dispatch.md](docs/dispatch.md)). `settings.force_portable_kernels` is the internal A/B switch that
+forces the portable kernels. Native CUDA variants can require a newer architecture.
 
 One extension is **not** in the table because it is not in the registry: `transition_b2b_cuda`,
 which the `Transition` module builds on demand, is compiled for `sm_90a` and fails to build on

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "miniworld-engine"
-version = "2.3.11"
+version = "2.3.12"
 requires-python = ">=3.10"
 readme = "README.md"
 description = "MiniWorld GPU kernel development repo — Triton / CUDA kernels + benches for AF3-style ops (triangle multiplication, transition, attention, ...)."

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/architecture/_engine_impl.py

@@ -16,7 +16,7 @@ def torch_pointwise() -> bool:
 
     B200 policy: the pieces around the GEMMs and attention are PyTorch ops that
     ``torch.compile`` fuses (inductor), not the engine's hand-written Triton
-    kernels. ``miniworld_engine.settings.b200_engine_triton`` keeps the engine
+    kernels. ``miniworld_engine.settings.b200_portable_kernels`` keeps the engine
     Triton kernels (the A/B switch). An engine that predates the switch keeps
     its Triton kernels, so this is a no-op until the engine pin has it.
 
@@ -28,7 +28,7 @@ def torch_pointwise() -> bool:
         and torch.cuda.get_device_capability() == _B200_CAPABILITY
     ):
         return False
-    return not getattr(settings.current(), "b200_engine_triton", True)
+    return not getattr(settings.current(), "b200_portable_kernels", True)
 
 
 def to_engine_impl_pointwise(

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/autotune/builder.py

@@ -146,7 +146,7 @@ SWITCHES: dict[str, tuple[tuple, tuple[str, ...]]] = {
     # covered by the unpinned unit, so pinning both would double the build for nothing.
     "ln_bwd_path": (("persistent", "atomic", "cuda"), ("train",)),
     "ln_out_bwd_path": (("split", "fused"), ("train",)),
-    "trimul_impl": (("triton",), ("eval", "train")),
+    "trimul_impl": (("portable",), ("eval", "train")),
     # The rest of settings.py's backend selectors. They were left out when SWITCHES was written
     # and each one is a set of kernels no unit ever reached: measured against the shipped A6000
     # cache, 26 kernels with working drivers were in the cache and in NO derived unit, and the
@@ -318,8 +318,8 @@ def cases() -> list[Case]:
     )
 
     def IT(i):
-        # "triton" is the A/B label of a build unit (run_case forces the Triton family around it), not a public backend
-        return ImplementationType.MINIWORLD if i == "triton" else ImplementationType(i)
+        # "portable" is the A/B label of a build unit (run_case forces the portable family around it), not a backend
+        return ImplementationType.MINIWORLD if i == "portable" else ImplementationType(i)
 
     # The dims that used to be declared here -- PAIR_D, PAIR_HID, HID_D, BOTH -- are in
     # registry_module.csv now, with a `source` column saying where each number came from. They are
@@ -464,11 +464,11 @@ def cases() -> list[Case]:
 def run_case(case: Case, length: int, dim_index: int, *, train: bool, p_drop: float = 0.0,
              impl: str = "miniworld", dtype: torch.dtype = BF16,
              compute_dtype: torch.dtype | None = None) -> int:
-    """:func:`_run_case`, with the engine's Triton family forced for the ``triton`` impl: it is not a public backend any more, so the unit
-    builds a ``miniworld`` module under ``settings.force_triton_kernels`` (the A/B switch), as the explicit ``triton`` request did."""
+    """:func:`_run_case`, with the portable family forced for the ``portable`` impl: it is not a backend, so the unit
+    builds a ``miniworld`` module under ``settings.force_portable_kernels`` (the A/B switch), as the A/B request does."""
     from miniworld_engine import settings
 
-    previous = settings.configure(force_triton_kernels=True) if impl == "triton" else None
+    previous = settings.configure(force_portable_kernels=True) if impl == "portable" else None
     try:
         return _run_case(case, length, dim_index, train=train, p_drop=p_drop, impl=impl, dtype=dtype, compute_dtype=compute_dtype)
     finally:

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/autotune/manifests/NVIDIA H100 80GB HBM3 (sm90).csv

@@ -1,5 +1,5 @@
 kernel,backend,family,file,status,detail,dtype
-#provenance,2.3.10,acfebaea42b4,clean,2026-10-24,v2.3.9-27-gacfebaea,
+#provenance,2.3.11,e5a9bd768e0f,clean,2026-10-24,v2.3.10-10-ge5a9bd76,
 adaln_bwd_dx_dlnw_triton,triton,adaln,miniworld_engine/kernels/adaln/triton/training.py,ok,rel DCond=2.15e-03 DLnW=2.62e-03 (band 1e-02 declared),bf16
 adaln_bwd_pre_dx_triton,triton,adaln,miniworld_engine/kernels/adaln/triton/training.py,ok,rel D=1.49e-03 DX=3.13e-03 (band 1e-02 declared),bf16
 adaln_epilogue_saveact_triton,triton,adaln,miniworld_engine/kernels/adaln/triton/training.py,ok,rel Y=2.65e-03 Mean=2.23e-08 Rstd=1.86e-07 Gate=1.96e-03 (band 1e-02 declared),bf16
@@ -12,8 +12,8 @@ augmented_attention_bwd_pre_triton,triton,augmented_attention,miniworld_engine/k
 augmented_attention_bwd_split_triton,triton,augmented_attention,miniworld_engine/kernels/augmented_attention/triton/main.py,ok,rel dq=4.04e-03 dk=3.25e-03 dv=4.70e-03 dbias=2.58e-03 (band 2e-02 declared),bf16
 augmented_attention_fwd_triton,triton,augmented_attention,miniworld_engine/kernels/augmented_attention/triton/main.py,ok,rel out=2.17e-03 m=9.38e-08 (band 9e-03 declared),bf16
 augmented_attention_fwd_window_triton,triton,augmented_attention,miniworld_engine/kernels/augmented_attention/triton/window.py,ok,rel out=2.29e-03 lse=1.23e-07 (band 1e-02 declared),bf16
-augmented_attention_bwd_window_triton,triton,augmented_attention,miniworld_engine/kernels/augmented_attention/triton/window.py,ok,rel dq=3.33e-03 dk=3.39e-03 dv=2.44e-03 dbias=2.12e-03 (band 2e-02 declared),bf16
-augmented_attention_bwd_reduce_window_triton,triton,augmented_attention,miniworld_engine/kernels/augmented_attention/triton/window.py,ok,rel out=8.28e-08 (band 7e-07 declared),bf16
+augmented_attention_bwd_window_triton,triton,augmented_attention,miniworld_engine/kernels/augmented_attention/triton/window.py,ok,rel dq=3.33e-03 dk=3.39e-03 dv=2.44e-03 dbias=2.12e-03 (band 1e-02 declared),bf16
+augmented_attention_bwd_reduce_window_triton,triton,augmented_attention,miniworld_engine/kernels/augmented_attention/triton/window.py,ok,rel out=8.28e-08 (band 3e-07 declared),bf16
 bias_only_attention_bwd_pre_triton,triton,bias_only_attention,miniworld_engine/kernels/bias_only_attention/triton/main.py,ok,rel out=6.62e-08 (band 3e-07 declared),bf16
 bias_only_attention_bwd_triton,triton,bias_only_attention,miniworld_engine/kernels/bias_only_attention/triton/main.py,ok,rel dv=7.22e-03 dbias=5.84e-03 (band 5e-02 declared),bf16
 bias_only_attention_fwd_triton,triton,bias_only_attention,miniworld_engine/kernels/bias_only_attention/triton/main.py,ok,rel out=8.88e-03 m=8.11e-04 (band 4e-02 declared),bf16
@@ -35,9 +35,9 @@ gated_projection_gate_dropres_triton,triton,trimul_inproj,miniworld_engine/kerne
 gated_projection_gate_flat_triton,triton,gated_projection,miniworld_engine/kernels/gated_projection/triton/main.py,ok,rel out=2.15e-03 (band 8e-03 declared),bf16
 gated_projection_gate_gemm_triton,triton,bias_only_attention,miniworld_engine/kernels/bias_only_attention/triton/gate_out.py,ok,rel out=3.79e-03 (band 1e-02 declared),bf16
 gated_projection_gate_triton,triton,gated_projection,miniworld_engine/kernels/gated_projection/triton/main.py,ok,rel out=2.15e-03 (band 8e-03 declared),bf16
-layernorm_bwd_atomic_strided_triton,triton,layernorm_linear,miniworld_engine/kernels/layernorm_linear/triton/te_style.py,ok,rel dx=2.60e-03 dgamma=4.41e-07 dbeta=1.25e-07 (band 1e-02 declared),bf16
+layernorm_bwd_atomic_strided_triton,triton,layernorm_linear,miniworld_engine/kernels/layernorm_linear/triton/te_style.py,ok,rel dx=2.60e-03 dgamma=5.35e-07 dbeta=1.25e-07 (band 1e-02 declared),bf16
 layernorm_bwd_atomic_triton,triton,layernorm,miniworld_engine/kernels/layernorm/triton/main.py,ok,rel dx=2.03e-03 dw=2.26e-03 db=2.41e-03 (band 1e-02 declared),bf16
-layernorm_bwd_foldstats_triton,triton,transition,miniworld_engine/kernels/transition/triton/fused.py,ok,rel dx=2.61e-03 dgamma=2.62e-07 dbeta=8.45e-08 (band 9e-03 declared),bf16
+layernorm_bwd_foldstats_triton,triton,transition,miniworld_engine/kernels/transition/triton/fused.py,ok,rel dx=2.61e-03 dgamma=2.40e-07 dbeta=8.45e-08 (band 9e-03 declared),bf16
 layernorm_bwd_reduce_cuda,cuda,layernorm,miniworld_engine/kernels/layernorm/cuda/layer_norm_cuda_kernel.cu,ok,rel dw=2.26e-03 db=2.41e-03 (band 9e-03 declared),bf16
 layernorm_bwd_split_cuda,cuda,layernorm,miniworld_engine/kernels/layernorm/cuda/layer_norm_cuda_kernel.cu,ok,rel dx=2.03e-03 dw=2.26e-03 db=2.41e-03 (band 1e-02 declared),bf16
 layernorm_bwd_split_mmajor_triton,triton,layernorm_linear,miniworld_engine/kernels/layernorm_linear/triton/mmajor_bwd.py,ok,rel dx=2.60e-03 dgamma=3.07e-07 dbeta=1.04e-07 (band 1e-02 declared),bf16
@@ -105,7 +105,7 @@ transition_fwd_b2b_sm90_cuda,cuda,transition,miniworld_engine/kernels/transition
 transition_expand_gate_sm90_cuda,cuda,transition,miniworld_engine/kernels/transition/cuda/transition_expand_gate_kernel.cu,ok,rel out=1.94e-03 (band 8e-03 declared),bf16
 transition_bwd_gate_sm90_cuda,cuda,transition,miniworld_engine/kernels/transition/cuda/transition_gatebwd_kernel.cu,ok,rel h=1.94e-03 dAB=2.97e-03 xn=5.27e-04 (band 1e-02 declared),bf16
 trimul_output_f567_train_triton,triton,trimul_inproj,miniworld_engine/kernels/trimul_inproj/triton/output_fused.py,ok,rel y=4.27e-03 proj=2.95e-03 gate=2.72e-03 (band 1e-02 declared),bf16
-trimul_input_ln_residual_bwd_triton,triton,trimul_inproj,miniworld_engine/kernels/trimul_inproj/triton/backward_fused.py,ok,rel dx=2.29e-03 dw=8.05e-07 db=8.17e-08 (band 1e-02 declared),bf16
+trimul_input_ln_residual_bwd_triton,triton,trimul_inproj,miniworld_engine/kernels/trimul_inproj/triton/backward_fused.py,ok,rel dx=2.29e-03 dw=2.41e-07 db=8.17e-08 (band 1e-02 declared),bf16
 trimul_input_dual_bwd_triton,triton,trimul_inproj,miniworld_engine/kernels/trimul_inproj/triton/backward_fused.py,ok,rel dx=2.34e-03 (band 1e-02 declared),bf16
 transition_squeeze_residual_triton,triton,transition,miniworld_engine/kernels/transition/triton/residual.py,ok,rel out=2.14e-03 (band 1e-02 declared),bf16
 mpnn_edge_tail_fwd_gemm_gather_saveact_triton,triton,mpnn_edge_tail,miniworld_engine/kernels/mpnn_edge_tail/triton/compute.py,ok,rel out=6.01e-03 (band 5e-02),bf16

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/autotune/records.py

@@ -170,7 +170,7 @@ def missing(op: str, name: str, capability: tuple[int, int], dtype: str = "bf16"
     table does not know has no kernels to vouch for: its only entry is a note naming the op."""
     kernels = triton_kernels(op, dtype, mode)
     if not kernels:
-        return (f"<no Triton kernel of {op!r} declares {dtype}>",)
+        return (f"<no portable kernel of {op!r} declares {dtype}>",)
     rows = _load(card_key(name, capability))
     return tuple(k for k in kernels if rows.get((k, dtype)) != "ok")
 

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/build/bundle_coverage.py

@@ -537,7 +537,7 @@ def serve() -> int:
     """Worker loop: one JSON descriptor per stdin line, one ``RESULT <json>`` line per descriptor on stdout."""
     from miniworld_engine import settings
 
-    settings.configure(triton_on_hopper_blackwell=False, force_triton_kernels=False)
+    settings.configure(portable_on_hopper_blackwell=False, force_portable_kernels=False)
     for line in sys.stdin:
         line = line.strip()
         if not line:

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/cli.py

@@ -192,7 +192,7 @@ PINS: dict[str, tuple[tuple, tuple[str, ...], tuple[str, ...]]] = {
     #: would just rebuild the same shard under a second name.
     "dropout": ((0.25,), ("triangle_multiplication",), ("training",)),
     # transition's forward runs the hand-CUDA fused b2b when it applies, and that kernel is not
-    # autotuned -- so the TRITON expand-gate forward never fires during a build and
+    # autotuned -- so the PORTABLE expand-gate forward never fires during a build and
     # transition_expand_gate_fwd stays absent from the cache, while its backward (which has no CUDA
     # counterpart) is captured normally. The CUDA path only covers fixed shapes, so production
     # falls back to the triton one elsewhere and finds nothing cached. Sweeping it off captures
@@ -837,10 +837,7 @@ def _reject_unknown_build_target(args: argparse.Namespace, repo: Path) -> int:
 
 
 def _kernels_choice(args: argparse.Namespace) -> str:
-    """``build --kernels {auto,native,portable}``; the hidden ``--backend {auto,native,triton}`` is its deprecated spelling (``triton`` is ``portable``)."""
-    old = getattr(args, "backend", None)
-    if old is not None:
-        return {"triton": "portable"}.get(old, old)
+    """``build --kernels {auto,native,portable}``."""
     return getattr(args, "kernels", None) or "auto"
 
 
@@ -899,7 +896,7 @@ def cmd_build(args: argparse.Namespace) -> int:
         from miniworld_engine.autotune import policy
         units = policy.filter_op_units(units)
         if not units:
-            print(f"no triton op with a driver matched {args.case!r}", file=sys.stderr)
+            print(f"no kernel op with a driver matched {args.case!r}", file=sys.stderr)
             return None
         if only and len(only) > len({u.op for u in units}):
             # Named and not built is not the same as not named. A kernel with no driver, or none
@@ -923,7 +920,7 @@ def cmd_build(args: argparse.Namespace) -> int:
 
     # A NAMED target drives its MODULE: the two name spaces are different -- `build <case>` names a
     # module and `--per-op <kernel>` names a kernel -- so running the op sweep for a case name
-    # filters `op_units` by a name no kernel has and returns "no triton op with a driver matched".
+    # filters `op_units` by a name no kernel has and returns "no kernel op with a driver matched".
     # Which is what this did for one commit, turning `build gated_projection grid` into exit 2.
     # The MODULE pass is the default now, including for `all`. It used to be the op pass, because
     # the module pass reached only the 48 of 91 kernels some module happened to dispatch to while
@@ -1751,7 +1748,7 @@ def build_parser() -> argparse.ArgumentParser:
     cap.add_argument("--shards", default="~/.cache/miniworld-shards", help="where shards go")
     cap.add_argument("--impl", default="miniworld",
                      help="implementations=[...]. Use miniworld: for triangle_multiplication, "
-                          "'triton' builds the fp32 dtv1 baseline and captures nothing")
+                          "'portable' builds the fp32 baseline and captures nothing")
     cap.add_argument("--no-sweep-dispatch", action="store_true",
                      help="capture only the branch this card picks (leaves the other uncached)")
     cap.add_argument("--resume", action="store_true", help="skip shards that already exist")
@@ -1801,9 +1798,8 @@ def build_parser() -> argparse.ArgumentParser:
     bld.add_argument("config_type", nargs="?", default=DEFAULT_CONFIG_SET,
                      help="config set: a directory of <op>.csv files, or a short name resolving to configs/<name> (e.g. accuracy). Every kernel's grid comes from here.")
     bld.add_argument("--kernels", choices=("auto", "native", "portable"), default="auto",
-                     help="auto follows module dispatch; native tunes the hand-written CUDA per-op drivers, portable the Triton ones "
+                     help="auto follows module dispatch; native tunes the hand-written CUDA per-op drivers, portable the portable-kernel ones "
                           "(the portable family is internal: it is what miniworld routes to on a card with a record)")
-    bld.add_argument("--backend", choices=("auto", "native", "triton"), default=None, help=argparse.SUPPRESS)  # deprecated spelling of --kernels
     bld.add_argument("--include-alternatives", action="store_true",
                      help="also tune forced fallback backends; default follows production dispatch")
     bld.add_argument("--mode", choices=("both", "train", "eval"), default="both",

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/anthropic_msa.py

@@ -123,7 +123,7 @@ def wanted(implementation) -> bool:
         return True
     if implementation != ImplementationType.MINIWORLD:
         return False
-    return bool(payload_dir()) and (not settings.current().force_triton_kernels)
+    return bool(payload_dir()) and (not settings.current().force_portable_kernels)
 
 
 def _common_refusal(x: torch.Tensor, *, grad: bool) -> str | None:

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/anthropic_trimul.py

@@ -105,7 +105,7 @@ def wanted(implementation) -> bool:
         return True
     if implementation != ImplementationType.MINIWORLD:
         return False
-    return bool(payload_dir()) and (not settings.current().force_triton_kernels)
+    return bool(payload_dir()) and (not settings.current().force_portable_kernels)
 
 
 def refusal(pair: torch.Tensor, c_z: int, c_hidden: int, *, grad: bool, dropout: bool) -> str | None:

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/attention_pair_bias_b200.py

@@ -68,7 +68,7 @@ def _eligible(
 ) -> bool:
     if (
         module.implementation != ImplementationType.MINIWORLD
-        or settings.current().force_triton_kernels
+        or settings.current().force_portable_kernels
     ):
         return False
     H, D = module.n_head, single.shape[-1]

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/bias_only_dit.py

@@ -15,7 +15,7 @@ settings.bias_only_dit_inf3=0 (read per call) keeps the 12-launch cuBLAS + rows
 ``bo_tail2_bf16``) behind bf16 tables (``runner._tables3b``); settings.bias_only_dit_inf3_bf16=0 (read per call) keeps the 12-launch
 bf16 step, which is also what a failed build falls back to.
 
-``serves()`` is the whole gate: no autograd, the engine's kernels (implementation MINIWORLD or TRITON), B200 or H100, bf16 or fp32, the
+``serves()`` is the whole gate: no autograd, the engine's kernels (implementation MINIWORLD), B200 or H100, bf16 or fp32, the
 token widths (768; the attention as 16 heads x 48, 24 x 32, 12 x 64 or 16 x 64 / cond 384 / pair 128 / transition n = 2), B == 1, L a multiple of 128 (up to 768; 3072 on H100: ``core_supported``), a key mask [1, L] or
 none, LayerNorm eps 1e-5. The conditioning may be one per sample or one shared by the samples (sample axis 1 or stride 0).
 settings.bias_only_dit=0 turns it off. Anything else keeps the module's PyTorch composition.
@@ -77,7 +77,7 @@ def serves(module, single, cond, pair, mask=None, bias=None) -> bool:
         return False
     if module.implementation != ImplementationType.MINIWORLD:
         return False
-    if settings.current().force_triton_kernels:
+    if settings.current().force_portable_kernels:
         return False
     dt = single.dtype
     src = (

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/bias_only_dit_hoist.py

@@ -61,7 +61,7 @@ def serves(implementation, attns, pair, per_sample=False) -> bool:
         return False
     if implementation != ImplementationType.MINIWORLD:
         return False
-    if settings.current().force_triton_kernels:
+    if settings.current().force_portable_kernels:
         return False
     if not pair.is_cuda or torch.cuda.get_device_capability(pair.device) not in ((10, 0), (9, 0)):
         return False

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/bias_only_dit_train.py

@@ -34,7 +34,7 @@ the dxa GEMM / adaln_a_bwd / dchat + dcg GEMMs / cond_bwd (``bo_bwd_mid`` x 3 wi
 weight gradients and the unfold, ``pair_bias_bwd_fin`` for pair_bias_bwd + finalize (_BWD_PBFIN). settings.bias_only_dit_bwd_fused=0,
 read per call, or a failed build: the per-step launches.
 
-``serves()`` is the whole gate: autograd on, the engine's kernels (implementation MINIWORLD or TRITON), B200, bf16 or fp32 inputs, the
+``serves()`` is the whole gate: autograd on, the engine's kernels (implementation MINIWORLD), B200, bf16 or fp32 inputs, the
 token widths (768; the attention as 16 heads x 48, 24 x 32, 12 x 64 or 16 x 64 / cond 384 / pair 128 / transition n = 2), B == 1, L a multiple of 128 up to 768, a per-sample
 conditioning [A, 1, L, 384], a key mask [1, L] or none, LayerNorm eps 1e-5. settings.bias_only_dit_train=0 turns it off.
 
@@ -105,7 +105,7 @@ def serves(module, single, cond, pair, mask=None, bias=None, per_sample=False) -
         return False
     if module.implementation != ImplementationType.MINIWORLD:
         return False
-    if settings.current().force_triton_kernels:
+    if settings.current().force_portable_kernels:
         return False
     from miniworld_engine.kernels.bias_only_dit.cuda import h100_enabled
 

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/local_dit.py

@@ -18,7 +18,7 @@ depend on what the attention attends to. The attention and the pair bias are ``s
 the trunked pair ``[nwin, 32, 128, 16]`` (bias ``LN(z) Wb`` per window, shared by the samples), no N x N tensor anywhere.
 Both residuals are inside post_fwd (the block returns the stream).
 
-``serves()`` is the whole gate: B200, the engine's kernel backend (implementation MINIWORLD or TRITON), bf16 single / cond / pair,
+``serves()`` is the whole gate: B200, the engine's kernel backend (implementation MINIWORLD), bf16 single / cond / pair,
 the atom widths (d_single = d_cond = 128, 4 heads x 32, d_pair = 16, transition n = 2, no QK-norm), B == 1, any N, a [B, N] bool key
 mask or none, LayerNorm eps 1e-5. N is padded to a multiple of 128 for the row kernels (zero single / cond rows, the padded atoms
 masked as keys, the pair padded with zero windows) and the first N rows come back. ``settings.local_dit_sm100=0`` turns it off. A
@@ -358,13 +358,13 @@ def serves(module, single, cond, pair, mask, rope=None) -> bool:
     if (
         (_FAILED32 if fp32 else _FAILED)
         or (not settings.current().local_dit_sm100)
-        or settings.current().force_triton_kernels
+        or settings.current().force_portable_kernels
     ):
         return False
     from miniworld_engine.modules.dispatch import KernelBackend
 
     a, tr = module.attention, module.transition
-    if a._backend != KernelBackend.TRITON or a.use_qk_norm:
+    if a._backend != KernelBackend.PORTABLE or a.use_qk_norm:
         return False
     cap = torch.cuda.get_device_capability(single.device) if single.is_cuda else None
     if cap != (10, 0):
@@ -449,7 +449,7 @@ def _require_hopper_training(module, single, cond, pair, mask):
 
     a, tr = module.attention, module.transition
     if (
-        a._backend != KernelBackend.TRITON
+        a._backend != KernelBackend.PORTABLE
         or not torch.is_grad_enabled()
         or not single.is_cuda
         or torch.cuda.get_device_capability(single.device) != (9, 0)
@@ -465,7 +465,7 @@ def _require_hopper_training(module, single, cond, pair, mask):
                 f"H100 local atom DiT training requires {detail}; no composed fallback"
             )
 
-    require(not settings.current().force_triton_kernels, "the CUDA engine backend")
+    require(not settings.current().force_portable_kernels, "the CUDA engine backend")
     require(
         module.cross_attention and not a.use_qk_norm, "cross-attention without QK norm"
     )
@@ -550,7 +550,7 @@ def _require_hopper_inference(module, single, cond, pair, mask):
 
     a, tr = module.attention, module.transition
     if (
-        a._backend != KernelBackend.TRITON
+        a._backend != KernelBackend.PORTABLE
         or torch.is_grad_enabled()
         or not single.is_cuda
     ):
@@ -564,7 +564,7 @@ def _require_hopper_inference(module, single, cond, pair, mask):
                 f"H100 local atom DiT inference requires {detail}; no composed fallback"
             )
 
-    require(not settings.current().force_triton_kernels, "the CUDA engine backend")
+    require(not settings.current().force_portable_kernels, "the CUDA engine backend")
     require(
         module.cross_attention and not a.use_qk_norm, "cross-attention without QK norm"
     )

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/local_dit_h100.py

@@ -45,11 +45,11 @@ def matches(module, single, cond, pair, mask, rope=None) -> bool:
     if _ld._af3_variant(module) and not _af3_servable(module, single, cond, pair, mask):
         return False
     a, tr = module.attention, module.transition
-    if settings.current().force_triton_kernels:
+    if settings.current().force_portable_kernels:
         return False
     from miniworld_engine.modules.dispatch import KernelBackend
 
-    if a._backend != KernelBackend.TRITON:
+    if a._backend != KernelBackend.PORTABLE:
         return False
     params = _weights_of(module)
     if any(p.device != single.device or not p.is_contiguous() for p in params):
@@ -676,7 +676,7 @@ def _esm_matches(module, single, cond, pair, mask, rope) -> bool:
 
     if not (single.is_cuda and _hopper(single)) or not settings.current().local_dit_h100_mma:
         return False
-    if settings.current().force_triton_kernels or module.attention._backend != KernelBackend.TRITON:
+    if settings.current().force_portable_kernels or module.attention._backend != KernelBackend.PORTABLE:
         return False
     a, tr = module.attention, module.transition
     options = (module.cross_attention, module.kv_norm, module.key_window, module.keys, module.window_half, module.conditioning,

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/opm_train.py

@@ -85,7 +85,7 @@ def wanted(implementation) -> bool:
     # (integrations.anthropic_msa), not this engine's own H100 path.
     return (
         _enabled()
-        and (not settings.current().force_triton_kernels)
+        and (not settings.current().force_portable_kernels)
         and implementation == ImplementationType.MINIWORLD
     )
 

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/pwa_train.py

@@ -101,7 +101,7 @@ def wanted(implementation) -> bool:
     ``settings.pwa_infer`` and, when that is unset, ``settings.pwa_train`` (no payload needed; faster than the upstream cell)."""
     from miniworld_engine.modules.exceptions import ImplementationType
 
-    on = _enabled() and (not settings.current().force_triton_kernels)
+    on = _enabled() and (not settings.current().force_portable_kernels)
     # ``ANTHROPIC`` is not asked here: an explicit ``implementation="anthropic"`` is the Anthropic release's cell
     # (integrations.anthropic_msa), not this engine's own H100 path.
     return on and implementation == ImplementationType.MINIWORLD

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/token_dit.py

@@ -69,7 +69,7 @@ def _native_fp32_inference(module, single) -> bool:
 
     return (
         not torch.is_grad_enabled()
-        and module.attention._backend == KernelBackend.TRITON
+        and module.attention._backend == KernelBackend.PORTABLE
         and getattr(getattr(module.attention, "to_bias", None), "weight", None)
         is not None
         and module.attention.to_bias.weight.shape[1] == 128
@@ -89,7 +89,7 @@ def require_hopper_native(module, single, cond, pair, mask, compute_dtype=None)
     from miniworld_engine.modules.dispatch import KernelBackend
 
     if (
-        module.attention._backend != KernelBackend.TRITON
+        module.attention._backend != KernelBackend.PORTABLE
         or not single.is_cuda
         or module.attention.to_bias.weight.shape[1] != 128
         or torch.cuda.get_device_capability(single.device) != (9, 0)
@@ -101,10 +101,10 @@ def require_hopper_native(module, single, cond, pair, mask, compute_dtype=None)
     def require(ok, detail):
         if not ok:
             raise NotImplementedError(
-                f"H100 token DiT requires {detail}; no Triton fallback"
+                f"H100 token DiT requires {detail}; no portable fallback on this card"
             )
 
-    require(not settings.current().force_triton_kernels, "the CUDA backend")
+    require(not settings.current().force_portable_kernels, "the CUDA backend")
     require(
         single.dtype in (torch.bfloat16, torch.float32)
         and compute_dtype in (None, single.dtype),
@@ -167,7 +167,7 @@ def require_hopper_native(module, single, cond, pair, mask, compute_dtype=None)
 
 def _check_native_fp32(module, single, cond, pair, compute_dtype):
     """Reject unsupported Hopper FP32 calls instead of entering a portable fallback."""
-    if settings.current().force_triton_kernels:
+    if settings.current().force_portable_kernels:
         raise ValueError("Hopper FP32 token inference requires the native CUDA backend")
     if compute_dtype not in (None, torch.float32):
         raise ValueError("Hopper FP32 token inference requires FP32 compute operands")
@@ -230,14 +230,14 @@ def serves(module, single, cond, pair, compute_dtype=None, extra=None):
             # no CUDA path for this call: the block runs its own statements (H100 has no Triton fallback; they are PyTorch there)
             return False
         return True
-    if torch.is_grad_enabled() or settings.current().force_triton_kernels:
+    if torch.is_grad_enabled() or settings.current().force_portable_kernels:
         return False
     a = module.attention
-    # the engine's kernels (implementation TRITON or MINIWORLD resolve to them), as the attention cores and the training
+    # the engine's kernels (implementation MINIWORLD resolve to them), as the attention cores and the training
     # path gate on; PYTORCH keeps the reference
     from miniworld_engine.modules.dispatch import KernelBackend
 
-    if a._backend != KernelBackend.TRITON:
+    if a._backend != KernelBackend.PORTABLE:
         return False
     if not single.is_cuda or single.dtype not in (torch.bfloat16, torch.float32):
         return False

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/token_dit_train.py

@@ -21,7 +21,7 @@ bf16 (bf16 inputs, or ``compute_dtype=bf16``) or fp32 (fp32 inputs, no ``compute
     kernels, graph-owned cuBLAS workspaces for the qualified buckets, and the caller-gradient hooks (``_native_caller_*``);
   * the residual stream fp32 inside the block, the output in the input's dtype.
 
-``serves()`` is the whole gate: autograd on, the engine's kernel backend (implementation TRITON or MINIWORLD), H100 or B200, a
+``serves()`` is the whole gate: autograd on, the engine's kernel backend (implementation MINIWORLD), H100 or B200, a
 bf16 or fp32 input (bf16 operands when the input or ``compute_dtype`` is bf16, else fp32), the token widths (cond 384 / pair
 128 / transition n = 2) at a head layout of LAYOUTS (B200: 16 x 48, 24 x 32, 12 x 64 at d 768, 16 x 64 at d 1024; H100: 16 x 48
 only; bf16 and fp32 alike), B == 1, a key mask of [B, L] or none (``DiTBlock`` hands an [A, B, L] mask shared by the samples
@@ -92,13 +92,13 @@ TRN = (
 def serves(module, single, cond, pair, mask, compute_dtype=None) -> bool:
     if (not settings.current().token_dit_train) or not torch.is_grad_enabled():
         return False
-    if settings.current().force_triton_kernels:
+    if settings.current().force_portable_kernels:
         return False
     a = module.attention
-    # the engine's kernels (TRITON or MINIWORLD resolve to them), as the sm_90 / sm_100 attention cores gate on
+    # the engine's kernels (MINIWORLD resolve to them), as the sm_90 / sm_100 attention cores gate on
     from miniworld_engine.modules.dispatch import KernelBackend
 
-    if a._backend != KernelBackend.TRITON:
+    if a._backend != KernelBackend.PORTABLE:
         return False
     cap = torch.cuda.get_device_capability(single.device) if single.is_cuda else None
     if cap not in ((9, 0), (10, 0)):
@@ -1411,12 +1411,12 @@ def _serves_psb_core(module, single, cond, mask, compute_dtype=None) -> bool:
     and a key mask that is one [1, L] row or a row per sample [A, L]."""
     if not settings.current().token_dit_train:
         return False
-    if settings.current().force_triton_kernels:
+    if settings.current().force_portable_kernels:
         return False
     a = module.attention
     from miniworld_engine.modules.dispatch import KernelBackend
 
-    if a._backend != KernelBackend.TRITON or not single.is_cuda or not _sm90(single.device):
+    if a._backend != KernelBackend.PORTABLE or not single.is_cuda or not _sm90(single.device):
         return False
     if single.dtype not in (BF, torch.float32) or operand_dtype(single, compute_dtype) is torch.float32:
         return False

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/triattn_b200.py

@@ -13,12 +13,12 @@ from miniworld_engine.modules.dispatch import KernelBackend
 
 def serves(module, pair: torch.Tensor, mask: torch.Tensor | None = None) -> bool:
     """Check the mathematical and resource contract before touching the CUDA builder."""
-    # The module resolves `miniworld` (and an explicit `triton`) to its TRITON backend, which also hosts the H100 CUDA paths;
+    # The module resolves `miniworld` to its PORTABLE backend, which also hosts the H100 CUDA paths;
     # `_b200_cuda = False` keeps the Triton kernels (the benchmark baseline), as the `_fuse_*` switches do on H100.
     if (
-        getattr(module, "_backend", None) != KernelBackend.TRITON
+        getattr(module, "_backend", None) != KernelBackend.PORTABLE
         or not getattr(module, "_b200_cuda", True)
-        or settings.current().force_triton_kernels
+        or settings.current().force_portable_kernels
     ):
         return False
     if not module.use_self_attention or module.use_qk_norm or module.n_head != 4:
@@ -64,9 +64,9 @@ def forward(module, pair: torch.Tensor, mask: torch.Tensor | None) -> torch.Tens
 def serves_wide(module, pair: torch.Tensor, mask: torch.Tensor | None = None) -> bool:
     """The other widths (d_pair 64 .. 512, heads of 16 / 32 channels), inference and training (with the module's dropout)."""
     if (
-        getattr(module, "_backend", None) != KernelBackend.TRITON
+        getattr(module, "_backend", None) != KernelBackend.PORTABLE
         or not getattr(module, "_b200_cuda", True)
-        or settings.current().force_triton_kernels
+        or settings.current().force_portable_kernels
     ):
         return False
     if not module.use_self_attention or module.use_qk_norm:

{miniworld_engine-2.3.11 → miniworld_engine-2.3.12}/src/miniworld_engine/integrations/triattn_h100.py

@@ -18,7 +18,7 @@ def native_requested(module, pair):
     """Hopper engine calls require native execution or a contract error."""
     from miniworld_engine.modules.exceptions import ImplementationType
 
-    # The MiniWorld label resolves to the TRITON family backend (module._backend); on Hopper it dispatches into this CUDA implementation.
+    # The MiniWorld label resolves to the PORTABLE family backend (module._backend); on Hopper it dispatches into this CUDA implementation.
     return (
         module.implementation == ImplementationType.MINIWORLD
         and pair.is_cuda
@@ -31,8 +31,8 @@ def serves(module, pair, mask=None):
     if not (validated or getattr(module, "_h100_b200style_cuda", False)):
         return False
     if (
-        module._backend != KernelBackend.TRITON
-        or settings.current().force_triton_kernels
+        module._backend != KernelBackend.PORTABLE
+        or settings.current().force_portable_kernels
     ):
         return False
     if not module.use_self_attention or module.use_qk_norm: