diff --git a/.azure/gpu-tests-fabric.yml b/.azure/gpu-tests-fabric.yml
index 3c01e47a09f99..c584f5bcbd3a2 100644
--- a/.azure/gpu-tests-fabric.yml
+++ b/.azure/gpu-tests-fabric.yml
@@ -60,13 +60,13 @@ jobs:
           image: "pytorchlightning/pytorch_lightning:base-cuda-py3.10-torch2.1-cuda12.1.1"
           PACKAGE_NAME: "fabric"
         "Fabric | latest":
-          image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.7-cuda12.6.3"
+          image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.8-cuda12.6.3"
           PACKAGE_NAME: "fabric"
         #"Fabric | future":
         #  image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.7-cuda12.6.3"
         #  PACKAGE_NAME: "fabric"
         "Lightning | latest":
-          image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.7-cuda12.6.3"
+          image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.8-cuda12.6.3"
           PACKAGE_NAME: "lightning"
     workspace:
       clean: all
diff --git a/.azure/gpu-tests-pytorch.yml b/.azure/gpu-tests-pytorch.yml
index 820831aae83f9..16ac6beb34841 100644
--- a/.azure/gpu-tests-pytorch.yml
+++ b/.azure/gpu-tests-pytorch.yml
@@ -53,13 +53,13 @@ jobs:
           image: "pytorchlightning/pytorch_lightning:base-cuda-py3.10-torch2.1-cuda12.1.1"
           PACKAGE_NAME: "pytorch"
         "PyTorch | latest":
-          image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.7-cuda12.6.3"
+          image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.8-cuda12.6.3"
           PACKAGE_NAME: "pytorch"
         #"PyTorch | future":
         #  image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.7-cuda12.6.3"
         #  PACKAGE_NAME: "pytorch"
         "Lightning | latest":
-          image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.7-cuda12.6.3"
+          image: "pytorchlightning/pytorch_lightning:base-cuda-py3.12-torch2.8-cuda12.6.3"
           PACKAGE_NAME: "lightning"
     pool: lit-rtx-3090
     variables:
diff --git a/.github/workflows/ci-tests-fabric.yml b/.github/workflows/ci-tests-fabric.yml
index 37bbdf91bd57e..c8b6d1e71a910 100644
--- a/.github/workflows/ci-tests-fabric.yml
+++ b/.github/workflows/ci-tests-fabric.yml
@@ -64,13 +64,13 @@ jobs:
           - { os: "ubuntu-22.04", pkg-name: "fabric", pytorch-version: "2.1", requires: "oldest" }
           - { os: "windows-2022", pkg-name: "fabric", pytorch-version: "2.1", requires: "oldest" }
           # "fabric" installs the standalone package
-          - { os: "macOS-14", pkg-name: "fabric", python-version: "3.10", pytorch-version: "2.5" }
-          - { os: "ubuntu-22.04", pkg-name: "fabric", python-version: "3.10", pytorch-version: "2.5" }
-          - { os: "windows-2022", pkg-name: "fabric", python-version: "3.10", pytorch-version: "2.5" }
+          - { os: "macOS-14", pkg-name: "fabric", python-version: "3.10", pytorch-version: "2.7" }
+          - { os: "ubuntu-22.04", pkg-name: "fabric", python-version: "3.10", pytorch-version: "2.7" }
+          - { os: "windows-2022", pkg-name: "fabric", python-version: "3.10", pytorch-version: "2.7" }
           # adding recently cut Torch 2.7 - FUTURE
-          - { os: "macOS-14", pkg-name: "fabric", python-version: "3.12", pytorch-version: "2.7" }
-          - { os: "ubuntu-22.04", pkg-name: "fabric", python-version: "3.12", pytorch-version: "2.7" }
-          - { os: "windows-2022", pkg-name: "fabric", python-version: "3.12", pytorch-version: "2.7" }
+          - { os: "macOS-14", pkg-name: "fabric", python-version: "3.12", pytorch-version: "2.8" }
+          - { os: "ubuntu-22.04", pkg-name: "fabric", python-version: "3.12", pytorch-version: "2.8" }
+          - { os: "windows-2022", pkg-name: "fabric", python-version: "3.12", pytorch-version: "2.8" }
     timeout-minutes: 25 # because of building grpcio on Mac
     env:
       PACKAGE_NAME: ${{ matrix.pkg-name }}
diff --git a/.github/workflows/ci-tests-pytorch.yml b/.github/workflows/ci-tests-pytorch.yml
index 1368da7b4377f..72a966812397e 100644
--- a/.github/workflows/ci-tests-pytorch.yml
+++ b/.github/workflows/ci-tests-pytorch.yml
@@ -68,13 +68,13 @@ jobs:
           - { os: "ubuntu-22.04", pkg-name: "pytorch", pytorch-version: "2.1", requires: "oldest" }
           - { os: "windows-2022", pkg-name: "pytorch", pytorch-version: "2.1", requires: "oldest" }
           # "pytorch" installs the standalone package
-          - { os: "macOS-14", pkg-name: "pytorch", python-version: "3.10", pytorch-version: "2.5" }
-          - { os: "ubuntu-22.04", pkg-name: "pytorch", python-version: "3.10", pytorch-version: "2.5" }
-          - { os: "windows-2022", pkg-name: "pytorch", python-version: "3.10", pytorch-version: "2.5" }
+          - { os: "macOS-14", pkg-name: "pytorch", python-version: "3.10", pytorch-version: "2.7" }
+          - { os: "ubuntu-22.04", pkg-name: "pytorch", python-version: "3.10", pytorch-version: "2.7" }
+          - { os: "windows-2022", pkg-name: "pytorch", python-version: "3.10", pytorch-version: "2.7" }
           # adding recently cut Torch 2.7 - FUTURE
-          - { os: "macOS-14", pkg-name: "pytorch", python-version: "3.12", pytorch-version: "2.7" }
-          - { os: "ubuntu-22.04", pkg-name: "pytorch", python-version: "3.12", pytorch-version: "2.7" }
-          - { os: "windows-2022", pkg-name: "pytorch", python-version: "3.12", pytorch-version: "2.7" }
+          - { os: "macOS-14", pkg-name: "pytorch", python-version: "3.12", pytorch-version: "2.8" }
+          - { os: "ubuntu-22.04", pkg-name: "pytorch", python-version: "3.12", pytorch-version: "2.8" }
+          - { os: "windows-2022", pkg-name: "pytorch", python-version: "3.12", pytorch-version: "2.8" }
     timeout-minutes: 50
     env:
       PACKAGE_NAME: ${{ matrix.pkg-name }}
diff --git a/requirements/fabric/examples.txt b/requirements/fabric/examples.txt
index 0d0356b706d08..ab6ffb8b137df 100644
--- a/requirements/fabric/examples.txt
+++ b/requirements/fabric/examples.txt
@@ -1,5 +1,5 @@
 # NOTE: the upper bound for the package version is only set for CI stability, and it is dropped while installing this package
 #  in case you want to preserve/enforce restrictions on the latest compatible version, add "strict" as an in-line comment
 
-torchvision >=0.16.0, <0.23.0
+torchvision >=0.16.0, <0.24.0
 torchmetrics >=0.10.0, <1.9.0
diff --git a/requirements/pytorch/base.txt b/requirements/pytorch/base.txt
index c5157430c9e2a..ef798883c12ef 100644
--- a/requirements/pytorch/base.txt
+++ b/requirements/pytorch/base.txt
@@ -1,7 +1,7 @@
 # NOTE: the upper bound for the package version is only set for CI stability, and it is dropped while installing this package
 #  in case you want to preserve/enforce restrictions on the latest compatible version, add "strict" as an in-line comment
 
-torch >=2.1.0, <=2.8.0
+torch >=2.1.0, <2.9.0
 tqdm >=4.57.0, <4.68.0
 PyYAML >5.4, <6.1.0
 fsspec[http] >=2022.5.0, <2025.8.0
diff --git a/requirements/pytorch/examples.txt b/requirements/pytorch/examples.txt
index cc40e86e3abfa..84ea80df6ff0c 100644
--- a/requirements/pytorch/examples.txt
+++ b/requirements/pytorch/examples.txt
@@ -2,6 +2,6 @@
 #  in case you want to preserve/enforce restrictions on the latest compatible version, add "strict" as an in-line comment
 
 requests <2.33.0
-torchvision >=0.16.0, <0.23.0
+torchvision >=0.16.0, <0.24.0
 ipython[all] <8.19.0
 torchmetrics >=0.10.0, <1.9.0
diff --git a/src/lightning/fabric/utilities/imports.py b/src/lightning/fabric/utilities/imports.py
index 1962e336b3eb9..70239baac0e6d 100644
--- a/src/lightning/fabric/utilities/imports.py
+++ b/src/lightning/fabric/utilities/imports.py
@@ -36,5 +36,5 @@
 _TORCH_GREATER_EQUAL_2_4_1 = compare_version("torch", operator.ge, "2.4.1")
 _TORCH_GREATER_EQUAL_2_5 = compare_version("torch", operator.ge, "2.5.0")
 _TORCH_LESS_EQUAL_2_6 = compare_version("torch", operator.le, "2.6.0")
-
+_TORCHMETRICS_GREATER_EQUAL_1_0_0 = compare_version("torchmetrics", operator.ge, "1.0.0")
 _PYTHON_GREATER_EQUAL_3_10_0 = (sys.version_info.major, sys.version_info.minor) >= (3, 10)
diff --git a/src/lightning/fabric/utilities/spike.py b/src/lightning/fabric/utilities/spike.py
index e96eccd75b1a2..9c1b0a2a00572 100644
--- a/src/lightning/fabric/utilities/spike.py
+++ b/src/lightning/fabric/utilities/spike.py
@@ -1,19 +1,16 @@
 import json
-import operator
 import os
 import warnings
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 import torch
-from lightning_utilities.core.imports import compare_version
 
+from lightning.fabric.utilities.imports import _TORCHMETRICS_GREATER_EQUAL_1_0_0
 from lightning.fabric.utilities.types import _PATH
 
 if TYPE_CHECKING:
     from lightning.fabric.fabric import Fabric
 
-_TORCHMETRICS_GREATER_EQUAL_1_0_0 = compare_version("torchmetrics", operator.ge, "1.0.0")
-
 
 class SpikeDetection:
     """Spike Detection Callback.
diff --git a/src/lightning/fabric/utilities/testing/_runif.py b/src/lightning/fabric/utilities/testing/_runif.py
index 597584dff7085..ec980693b75f3 100644
--- a/src/lightning/fabric/utilities/testing/_runif.py
+++ b/src/lightning/fabric/utilities/testing/_runif.py
@@ -40,6 +40,7 @@ def _runif_reasons(
     standalone: bool = False,
     deepspeed: bool = False,
     dynamo: bool = False,
+    linux_only: bool = False,
 ) -> tuple[list[str], dict[str, bool]]:
     """Construct reasons for pytest skipif.
 
@@ -121,4 +122,7 @@ def _runif_reasons(
         if not is_dynamo_supported():
             reasons.append("torch.dynamo")
 
+    if linux_only and sys.platform != "linux":
+        reasons.append("only linux")
+
     return reasons, kwargs
diff --git a/src/lightning/pytorch/trainer/connectors/logger_connector/result.py b/src/lightning/pytorch/trainer/connectors/logger_connector/result.py
index 90ae28bb8c7ee..1a4aa7c401960 100644
--- a/src/lightning/pytorch/trainer/connectors/logger_connector/result.py
+++ b/src/lightning/pytorch/trainer/connectors/logger_connector/result.py
@@ -25,9 +25,9 @@
 from lightning.fabric.utilities import move_data_to_device
 from lightning.fabric.utilities.apply_func import convert_tensors_to_scalars
 from lightning.fabric.utilities.distributed import _distributed_is_initialized
+from lightning.fabric.utilities.imports import _TORCHMETRICS_GREATER_EQUAL_1_0_0
 from lightning.pytorch.utilities.data import extract_batch_size
 from lightning.pytorch.utilities.exceptions import MisconfigurationException
-from lightning.pytorch.utilities.imports import _TORCHMETRICS_GREATER_EQUAL_1_0_0
 from lightning.pytorch.utilities.memory import recursive_detach
 from lightning.pytorch.utilities.rank_zero import WarningCache, rank_zero_warn
 from lightning.pytorch.utilities.warnings import PossibleUserWarning
diff --git a/src/lightning/pytorch/utilities/imports.py b/src/lightning/pytorch/utilities/imports.py
index 2d3855994a078..5572f1d20d3d6 100644
--- a/src/lightning/pytorch/utilities/imports.py
+++ b/src/lightning/pytorch/utilities/imports.py
@@ -27,6 +27,7 @@
 _TORCHMETRICS_GREATER_EQUAL_0_9_1 = RequirementCache("torchmetrics>=0.9.1")
 _TORCHMETRICS_GREATER_EQUAL_0_11 = RequirementCache("torchmetrics>=0.11.0")  # using new API with task
 _TORCHMETRICS_GREATER_EQUAL_1_0_0 = RequirementCache("torchmetrics>=1.0.0")
+_TORCH_EQUAL_2_8 = RequirementCache("torch>=2.8.0,<2.9.0")
 
 _OMEGACONF_AVAILABLE = package_available("omegaconf")
 _TORCHVISION_AVAILABLE = RequirementCache("torchvision")
diff --git a/src/lightning/pytorch/utilities/testing/_runif.py b/src/lightning/pytorch/utilities/testing/_runif.py
index 5256935f3a870..0d25cfd1b86ee 100644
--- a/src/lightning/pytorch/utilities/testing/_runif.py
+++ b/src/lightning/pytorch/utilities/testing/_runif.py
@@ -15,7 +15,7 @@
 
 from lightning_utilities.core.imports import RequirementCache
 
-from lightning.fabric.utilities.testing import _runif_reasons as fabric_run_if
+from lightning.fabric.utilities.testing import _runif_reasons as _fabric_run_if
 from lightning.pytorch.accelerators.cpu import _PSUTIL_AVAILABLE
 from lightning.pytorch.callbacks.progress.rich_progress import _RICH_AVAILABLE
 from lightning.pytorch.core.module import _ONNX_AVAILABLE, _ONNXSCRIPT_AVAILABLE
@@ -42,6 +42,7 @@ def _runif_reasons(
     psutil: bool = False,
     sklearn: bool = False,
     onnx: bool = False,
+    linux_only: bool = False,
     onnxscript: bool = False,
 ) -> tuple[list[str], dict[str, bool]]:
     """Construct reasons for pytest skipif.
@@ -69,7 +70,7 @@ def _runif_reasons(
 
     """
 
-    reasons, kwargs = fabric_run_if(
+    reasons, kwargs = _fabric_run_if(
         min_cuda_gpus=min_cuda_gpus,
         min_torch=min_torch,
         max_torch=max_torch,
@@ -81,6 +82,7 @@ def _runif_reasons(
         standalone=standalone,
         deepspeed=deepspeed,
         dynamo=dynamo,
+        linux_only=linux_only,
     )
 
     if rich and not _RICH_AVAILABLE:
diff --git a/tests/tests_fabric/plugins/precision/test_amp_integration.py b/tests/tests_fabric/plugins/precision/test_amp_integration.py
index bcbd9435d47ac..a01a597811a63 100644
--- a/tests/tests_fabric/plugins/precision/test_amp_integration.py
+++ b/tests/tests_fabric/plugins/precision/test_amp_integration.py
@@ -42,8 +42,8 @@ def forward(self, x):
 @pytest.mark.parametrize(
     ("accelerator", "precision", "expected_dtype"),
     [
-        ("cpu", "16-mixed", torch.bfloat16),
-        ("cpu", "bf16-mixed", torch.bfloat16),
+        pytest.param("cpu", "16-mixed", torch.bfloat16, marks=RunIf(skip_windows=True)),
+        pytest.param("cpu", "bf16-mixed", torch.bfloat16, marks=RunIf(skip_windows=True)),
         pytest.param("cuda", "16-mixed", torch.float16, marks=RunIf(min_cuda_gpus=2)),
         pytest.param("cuda", "bf16-mixed", torch.bfloat16, marks=RunIf(min_cuda_gpus=2, bf16_cuda=True)),
     ],
diff --git a/tests/tests_fabric/strategies/launchers/test_multiprocessing_integration.py b/tests/tests_fabric/strategies/launchers/test_multiprocessing_integration.py
index 6ae96b9bcafc6..2abfe73c92dec 100644
--- a/tests/tests_fabric/strategies/launchers/test_multiprocessing_integration.py
+++ b/tests/tests_fabric/strategies/launchers/test_multiprocessing_integration.py
@@ -29,7 +29,8 @@ def __init__(self):
         self.register_buffer("buffer", torch.ones(3))
 
 
-@pytest.mark.parametrize("strategy", ["ddp_spawn", pytest.param("ddp_fork", marks=RunIf(skip_windows=True))])
+@RunIf(skip_windows=True)
+@pytest.mark.parametrize("strategy", ["ddp_spawn", "ddp_fork"])
 def test_memory_sharing_disabled(strategy):
     """Test that the multiprocessing launcher disables memory sharing on model parameters and buffers to avoid race
     conditions on model updates."""
diff --git a/tests/tests_fabric/strategies/test_ddp_integration.py b/tests/tests_fabric/strategies/test_ddp_integration.py
index 9d43724228cd2..241d624483b1e 100644
--- a/tests/tests_fabric/strategies/test_ddp_integration.py
+++ b/tests/tests_fabric/strategies/test_ddp_integration.py
@@ -36,7 +36,7 @@
 @pytest.mark.parametrize(
     "accelerator",
     [
-        "cpu",
+        pytest.param("cpu", marks=RunIf(skip_windows=True)),
         pytest.param("cuda", marks=RunIf(min_cuda_gpus=2)),
     ],
 )
diff --git a/tests/tests_fabric/utilities/test_distributed.py b/tests/tests_fabric/utilities/test_distributed.py
index 5c6570eae9b0e..d65eaa810ff4d 100644
--- a/tests/tests_fabric/utilities/test_distributed.py
+++ b/tests/tests_fabric/utilities/test_distributed.py
@@ -128,9 +128,10 @@ def test_collective_operations(devices, process):
 
 
 @pytest.mark.skipif(
-    RequirementCache("torch<2.4") and RequirementCache("numpy>=2.0"),
+    RequirementCache("numpy>=2.0"),
     reason="torch.distributed not compatible with numpy>=2.0",
 )
+@RunIf(min_torch="2.4", skip_windows=True)
 @pytest.mark.flaky(reruns=3)  # flaky with "process 0 terminated with signal SIGABRT" (GLOO)
 def test_is_shared_filesystem(tmp_path, monkeypatch):
     # In the non-distributed case, every location is interpreted as 'shared'
diff --git a/tests/tests_fabric/utilities/test_spike.py b/tests/tests_fabric/utilities/test_spike.py
index 6054bf224d3df..e96a5f77df384 100644
--- a/tests/tests_fabric/utilities/test_spike.py
+++ b/tests/tests_fabric/utilities/test_spike.py
@@ -1,11 +1,12 @@
 import contextlib
-import sys
 
 import pytest
 import torch
 
 from lightning.fabric import Fabric
-from lightning.fabric.utilities.spike import _TORCHMETRICS_GREATER_EQUAL_1_0_0, SpikeDetection, TrainingSpikeException
+from lightning.fabric.utilities.imports import _TORCHMETRICS_GREATER_EQUAL_1_0_0
+from lightning.fabric.utilities.spike import SpikeDetection, TrainingSpikeException
+from tests_fabric.helpers.runif import RunIf
 
 
 def spike_detection_test(fabric, global_rank_spike, spike_value, should_raise):
@@ -32,6 +33,8 @@ def spike_detection_test(fabric, global_rank_spike, spike_value, should_raise):
 @pytest.mark.flaky(max_runs=3)
 @pytest.mark.parametrize(
     ("global_rank_spike", "num_devices", "spike_value", "finite_only"),
+    # NOTE FOR ALL FOLLOWING TESTS:
+    # adding run on linux only because multiprocessing on other platforms takes forever
     [
         pytest.param(0, 1, None, True),
         pytest.param(0, 1, None, False),
@@ -41,150 +44,22 @@ def spike_detection_test(fabric, global_rank_spike, spike_value, should_raise):
         pytest.param(0, 1, float("-inf"), False),
         pytest.param(0, 1, float("NaN"), True),
         pytest.param(0, 1, float("NaN"), False),
-        pytest.param(
-            0,
-            2,
-            None,
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            None,
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            None,
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            None,
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("inf"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("inf"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("inf"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("inf"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("-inf"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("-inf"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("-inf"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("-inf"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("NaN"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("NaN"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("NaN"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("NaN"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
+        pytest.param(0, 2, None, True, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, None, False, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, None, True, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, None, False, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("inf"), True, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("inf"), False, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("inf"), True, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("inf"), False, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("-inf"), True, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("-inf"), False, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("-inf"), True, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("-inf"), False, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("NaN"), True, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("NaN"), False, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("NaN"), True, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("NaN"), False, marks=RunIf(linux_only=True)),
     ],
 )
 @pytest.mark.skipif(not _TORCHMETRICS_GREATER_EQUAL_1_0_0, reason="requires torchmetrics>=1.0.0")
diff --git a/tests/tests_pytorch/callbacks/test_spike.py b/tests/tests_pytorch/callbacks/test_spike.py
index 692a28dcc38c4..f61a6c59ca9db 100644
--- a/tests/tests_pytorch/callbacks/test_spike.py
+++ b/tests/tests_pytorch/callbacks/test_spike.py
@@ -1,12 +1,13 @@
 import contextlib
-import sys
 
 import pytest
 import torch
 
-from lightning.fabric.utilities.spike import _TORCHMETRICS_GREATER_EQUAL_1_0_0, TrainingSpikeException
+from lightning.fabric.utilities.imports import _TORCHMETRICS_GREATER_EQUAL_1_0_0
+from lightning.fabric.utilities.spike import TrainingSpikeException
 from lightning.pytorch import LightningModule, Trainer
 from lightning.pytorch.callbacks.spike import SpikeDetection
+from tests_pytorch.helpers.runif import RunIf, _xfail_gloo_windows
 
 
 class IdentityModule(LightningModule):
@@ -50,159 +51,33 @@ def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx):
 @pytest.mark.flaky(max_runs=3)
 @pytest.mark.parametrize(
     ("global_rank_spike", "num_devices", "spike_value", "finite_only"),
+    # NOTE FOR ALL FOLLOWING TESTS:
+    # adding run on linux only because multiprocessing on other platforms takes forever
     [
-        pytest.param(0, 1, None, True),
-        pytest.param(0, 1, None, False),
-        pytest.param(0, 1, float("inf"), True),
-        pytest.param(0, 1, float("inf"), False),
-        pytest.param(0, 1, float("-inf"), True),
-        pytest.param(0, 1, float("-inf"), False),
-        pytest.param(0, 1, float("NaN"), True),
-        pytest.param(0, 1, float("NaN"), False),
-        pytest.param(
-            0,
-            2,
-            None,
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            None,
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            None,
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            None,
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("inf"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("inf"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("inf"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("inf"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("-inf"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("-inf"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("-inf"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("-inf"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("NaN"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            0,
-            2,
-            float("NaN"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("NaN"),
-            True,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
-        pytest.param(
-            1,
-            2,
-            float("NaN"),
-            False,
-            marks=pytest.mark.skipif(
-                sys.platform != "linux", reason="multiprocessing on other platforms takes forever"
-            ),
-        ),
+        pytest.param(0, 1, None, True, marks=_xfail_gloo_windows),
+        pytest.param(0, 1, None, False, marks=_xfail_gloo_windows),
+        pytest.param(0, 1, float("inf"), True, marks=_xfail_gloo_windows),
+        pytest.param(0, 1, float("inf"), False, marks=_xfail_gloo_windows),
+        pytest.param(0, 1, float("-inf"), True, marks=_xfail_gloo_windows),
+        pytest.param(0, 1, float("-inf"), False, marks=_xfail_gloo_windows),
+        pytest.param(0, 1, float("NaN"), True, marks=_xfail_gloo_windows),
+        pytest.param(0, 1, float("NaN"), False, marks=_xfail_gloo_windows),
+        pytest.param(0, 2, None, True, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, None, False, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, None, True, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, None, False, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("inf"), True, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("inf"), False, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("inf"), True, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("inf"), False, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("-inf"), True, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("-inf"), False, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("-inf"), True, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("-inf"), False, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("NaN"), True, marks=RunIf(linux_only=True)),
+        pytest.param(0, 2, float("NaN"), False, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("NaN"), True, marks=RunIf(linux_only=True)),
+        pytest.param(1, 2, float("NaN"), False, marks=RunIf(linux_only=True)),
     ],
 )
 @pytest.mark.skipif(not _TORCHMETRICS_GREATER_EQUAL_1_0_0, reason="requires torchmetrics>=1.0.0")
diff --git a/tests/tests_pytorch/helpers/runif.py b/tests/tests_pytorch/helpers/runif.py
index 25fadd524adf8..372f493a1fb67 100644
--- a/tests/tests_pytorch/helpers/runif.py
+++ b/tests/tests_pytorch/helpers/runif.py
@@ -13,9 +13,20 @@
 # limitations under the License.
 import pytest
 
+from lightning.fabric.utilities.imports import _IS_WINDOWS
+from lightning.pytorch.utilities.imports import _TORCH_EQUAL_2_8
 from lightning.pytorch.utilities.testing import _runif_reasons
 
 
 def RunIf(**kwargs):
     reasons, marker_kwargs = _runif_reasons(**kwargs)
     return pytest.mark.skipif(condition=len(reasons) > 0, reason=f"Requires: [{' + '.join(reasons)}]", **marker_kwargs)
+
+
+# todo: RuntimeError: makeDeviceForHostname(): unsupported gloo device
+_xfail_gloo_windows = pytest.mark.xfail(
+    RuntimeError,
+    strict=True,
+    condition=(_IS_WINDOWS and _TORCH_EQUAL_2_8),
+    reason="makeDeviceForHostname(): unsupported gloo device",
+)
diff --git a/tests/tests_pytorch/loops/test_prediction_loop.py b/tests/tests_pytorch/loops/test_prediction_loop.py
index 470cbcdc195f5..2ca05e243df8f 100644
--- a/tests/tests_pytorch/loops/test_prediction_loop.py
+++ b/tests/tests_pytorch/loops/test_prediction_loop.py
@@ -19,6 +19,7 @@
 from lightning.pytorch import LightningModule, Trainer
 from lightning.pytorch.demos.boring_classes import BoringModel, RandomDataset
 from lightning.pytorch.overrides.distributed import _IndexBatchSamplerWrapper
+from tests_pytorch.helpers.runif import _xfail_gloo_windows
 
 
 def test_prediction_loop_stores_predictions(tmp_path):
@@ -51,6 +52,7 @@ def predict_step(self, batch, batch_idx):
     assert trainer.predict_loop.predictions == []
 
 
+@_xfail_gloo_windows
 @pytest.mark.parametrize("use_distributed_sampler", [False, True])
 def test_prediction_loop_batch_sampler_set_epoch_called(tmp_path, use_distributed_sampler):
     """Tests that set_epoch is called on the dataloader's batch sampler (if any) during prediction."""
diff --git a/tests/tests_pytorch/models/test_amp.py b/tests/tests_pytorch/models/test_amp.py
index 24323f5c1d691..3262365fff2af 100644
--- a/tests/tests_pytorch/models/test_amp.py
+++ b/tests/tests_pytorch/models/test_amp.py
@@ -22,7 +22,7 @@
 from lightning.fabric.plugins.environments import SLURMEnvironment
 from lightning.pytorch import Trainer
 from lightning.pytorch.demos.boring_classes import BoringModel, RandomDataset
-from tests_pytorch.helpers.runif import RunIf
+from tests_pytorch.helpers.runif import RunIf, _xfail_gloo_windows
 
 
 class AMPTestModel(BoringModel):
@@ -53,7 +53,7 @@ def _assert_autocast_enabled(self):
     [
         ("single_device", "16-mixed", 1),
         ("single_device", "bf16-mixed", 1),
-        ("ddp_spawn", "16-mixed", 2),
+        pytest.param("ddp_spawn", "16-mixed", 2, marks=_xfail_gloo_windows),
         pytest.param("ddp_spawn", "bf16-mixed", 2, marks=RunIf(skip_windows=True)),
     ],
 )
diff --git a/tests/tests_pytorch/serve/test_servable_module_validator.py b/tests/tests_pytorch/serve/test_servable_module_validator.py
index ba90949132ba2..c20621c72ff88 100644
--- a/tests/tests_pytorch/serve/test_servable_module_validator.py
+++ b/tests/tests_pytorch/serve/test_servable_module_validator.py
@@ -5,6 +5,7 @@
 from lightning.pytorch import Trainer
 from lightning.pytorch.demos.boring_classes import BoringModel
 from lightning.pytorch.serve.servable_module_validator import ServableModule, ServableModuleValidator
+from tests_pytorch.helpers.runif import _xfail_gloo_windows
 
 
 class ServableBoringModel(BoringModel, ServableModule):
@@ -28,13 +29,14 @@ def configure_response(self):
         return {"output": [0, 1]}
 
 
-@pytest.mark.xfail(strict=False, reason="test is too flaky in CI")  # todo
+@pytest.mark.flaky(reruns=3)
 def test_servable_module_validator():
     model = ServableBoringModel()
     callback = ServableModuleValidator()
     callback.on_train_start(Trainer(accelerator="cpu"), model)
 
 
+@_xfail_gloo_windows
 @pytest.mark.flaky(reruns=3)
 def test_servable_module_validator_with_trainer(tmp_path, mps_count_0):
     callback = ServableModuleValidator()
diff --git a/tests/tests_pytorch/strategies/launchers/test_multiprocessing.py b/tests/tests_pytorch/strategies/launchers/test_multiprocessing.py
index d0b4ab617df66..f729b521dc5d6 100644
--- a/tests/tests_pytorch/strategies/launchers/test_multiprocessing.py
+++ b/tests/tests_pytorch/strategies/launchers/test_multiprocessing.py
@@ -25,7 +25,7 @@
 from lightning.pytorch.strategies import DDPStrategy
 from lightning.pytorch.strategies.launchers.multiprocessing import _GlobalStateSnapshot, _MultiProcessingLauncher
 from lightning.pytorch.trainer.states import TrainerFn
-from tests_pytorch.helpers.runif import RunIf
+from tests_pytorch.helpers.runif import RunIf, _xfail_gloo_windows
 
 
 @mock.patch("lightning.pytorch.strategies.launchers.multiprocessing.mp.get_all_start_methods", return_value=[])
@@ -194,6 +194,8 @@ def on_fit_start(self) -> None:
         assert torch.equal(self.layer.weight.data, self.tied_layer.weight.data)
 
 
+@_xfail_gloo_windows
+@pytest.mark.flaky(reruns=3)
 def test_memory_sharing_disabled(tmp_path):
     """Test that the multiprocessing launcher disables memory sharing on model parameters and buffers to avoid race
     conditions on model updates."""
@@ -219,6 +221,7 @@ def test_check_for_missing_main_guard():
         launcher.launch(function=Mock())
 
 
+@_xfail_gloo_windows
 def test_fit_twice_raises(mps_count_0):
     model = BoringModel()
     trainer = Trainer(
diff --git a/tests/tests_pytorch/trainer/connectors/test_data_connector.py b/tests/tests_pytorch/trainer/connectors/test_data_connector.py
index 1bb0d1478e7d3..367c2340ce542 100644
--- a/tests/tests_pytorch/trainer/connectors/test_data_connector.py
+++ b/tests/tests_pytorch/trainer/connectors/test_data_connector.py
@@ -37,7 +37,7 @@
 from lightning.pytorch.utilities.combined_loader import CombinedLoader
 from lightning.pytorch.utilities.data import _update_dataloader
 from lightning.pytorch.utilities.exceptions import MisconfigurationException
-from tests_pytorch.helpers.runif import RunIf
+from tests_pytorch.helpers.runif import RunIf, _xfail_gloo_windows
 
 
 @RunIf(skip_windows=True)
@@ -123,6 +123,7 @@ def on_train_end(self):
             self.ctx.__exit__(None, None, None)
 
 
+@_xfail_gloo_windows
 @pytest.mark.parametrize("num_workers", [0, 1, 2])
 def test_dataloader_persistent_workers_performance_warning(num_workers, tmp_path):
     """Test that when the multiprocessing start-method is 'spawn', we recommend setting `persistent_workers=True`."""
diff --git a/tests/tests_pytorch/trainer/logging_/test_train_loop_logging.py b/tests/tests_pytorch/trainer/logging_/test_train_loop_logging.py
index be99489cfdf89..6916eae68e9c0 100644
--- a/tests/tests_pytorch/trainer/logging_/test_train_loop_logging.py
+++ b/tests/tests_pytorch/trainer/logging_/test_train_loop_logging.py
@@ -35,7 +35,7 @@
 from lightning.pytorch.trainer.states import RunningStage
 from lightning.pytorch.utilities.exceptions import MisconfigurationException
 from lightning.pytorch.utilities.imports import _TORCHMETRICS_GREATER_EQUAL_0_11 as _TM_GE_0_11
-from tests_pytorch.helpers.runif import RunIf
+from tests_pytorch.helpers.runif import RunIf, _xfail_gloo_windows
 
 
 def test__training_step__log(tmp_path):
@@ -346,7 +346,7 @@ def validation_step(self, batch, batch_idx):
     ("devices", "accelerator"),
     [
         (1, "cpu"),
-        (2, "cpu"),
+        pytest.param(2, "cpu", marks=_xfail_gloo_windows),
         pytest.param(2, "gpu", marks=RunIf(min_cuda_gpus=2)),
     ],
 )
diff --git a/tests/tests_pytorch/trainer/test_trainer.py b/tests/tests_pytorch/trainer/test_trainer.py
index 18ae7ce77bdfc..da79e2fdc411b 100644
--- a/tests/tests_pytorch/trainer/test_trainer.py
+++ b/tests/tests_pytorch/trainer/test_trainer.py
@@ -55,7 +55,7 @@
 from lightning.pytorch.strategies.launchers import _MultiProcessingLauncher, _SubprocessScriptLauncher
 from lightning.pytorch.trainer.states import RunningStage, TrainerFn
 from lightning.pytorch.utilities.exceptions import MisconfigurationException
-from lightning.pytorch.utilities.imports import _OMEGACONF_AVAILABLE
+from lightning.pytorch.utilities.imports import _OMEGACONF_AVAILABLE, _TORCH_EQUAL_2_8
 from tests_pytorch.conftest import mock_cuda_count, mock_mps_count
 from tests_pytorch.helpers.datamodules import ClassifDataModule
 from tests_pytorch.helpers.runif import RunIf
@@ -1729,6 +1729,8 @@ def test_exception_when_lightning_module_is_not_set_on_trainer(fn):
 
 
 @RunIf(min_cuda_gpus=1)
+# FixMe: the memory raises to 1024 from expected 512
+@pytest.mark.xfail(AssertionError, strict=True, condition=_TORCH_EQUAL_2_8, reason="temporarily disabled for torch 2.8")
 def test_multiple_trainer_constant_memory_allocated(tmp_path):
     """This tests ensures calling the trainer several times reset the memory back to 0."""
 
@@ -1750,8 +1752,6 @@ def current_memory():
         gc.collect()
         return torch.cuda.memory_allocated(0)
 
-    initial = current_memory()
-
     model = TestModel()
     trainer_kwargs = {
         "default_root_dir": tmp_path,
@@ -1763,6 +1763,7 @@ def current_memory():
         "callbacks": Check(),
     }
     trainer = Trainer(**trainer_kwargs)
+    initial = current_memory()
     trainer.fit(model)
 
     assert trainer.strategy.model is model