2026: What to Do About the PyTorch 2.15 MPS Double-Precision Error?

The PyTorch MPS backend documentation states that MPS does not support float64 or complex128. So if your PyTorch 2.15 job fails when a double-precision tensor is sent to MPS, keep that calculation on CPU; do not silently convert it to float32 unless your research or application can accept the change and you validate the output against a CPU reference.

This week’s action: reproduce the failing operation with the original dtype, check whether MPS is available, then decide whether to keep the step on CPU or test a separate float32 MPS path.

This guide is for graduate students whose scripts fail on a Mac when handling double or float64 tensors.
It also helps researchers and model developers assess precision requirements and MPS operator support.
Lab administrators can use it to define a reproducible Apple Silicon test and review process.

Last updated November 11, 2026. Version and support details checked against the PyTorch 2.15 release notes and the PyTorch 2.15 MPS backend documentation.

Diagnosing the PyTorch 2.15 MPS double-precision error

Start with the error itself and the tensor’s actual dtype and device. Messages mentioning float64, double, Double, or a failed move to an MPS device point toward a dtype or device-placement issue. They do not, by themselves, prove that PyTorch was installed incorrectly.

PyTorch 2.15’s release information lists updates to MPS for Apple Silicon. That release note does not mean every dtype or operator is supported. The MPS documentation still identifies float64 and complex128 as unsupported on that backend. Treat the release announcement and the dtype support boundary as separate pieces of information: new MPS functionality does not establish universal support for every model, operation, or tensor type.

Why doesn’t PyTorch MPS support float64? The actionable answer is that the documented MPS backend does not support that dtype. You do not need to infer the cause from a particular traceback or assume the restriction will disappear because the framework has a newer release. If your computation requires double precision, keep it on CPU unless the official support documentation changes.

A useful first check is to print the objects at the failing boundary:

print("input:", input_tensor.dtype, input_tensor.device)
print("parameter:", next(model.parameters()).dtype,
      next(model.parameters()).device)

Check intermediate tensors too. A CPU float64 input can fail when moved to MPS even if the model was created on MPS; alternatively, a model and input can reach an operation with mismatched devices or dtypes. The important question is not just “Is MPS enabled?” but “Which exact tensor is being sent to which device, with what dtype?”

Backend availability versus dtype support

MPS availability and float64 support are different checks. If the backend is unavailable, no MPS computation can start. If it is available, an unsupported dtype or operator can still fail. The official MPS backend notes explain the backend checks and requirements; use them to diagnose availability rather than treating every device-related error as an installation failure.

Run the availability checks directly:

import torch

print("MPS built:", torch.backends.mps.is_built())
print("MPS available:", torch.backends.mps.is_available())

The distinction matters. is_built() checks whether the PyTorch library was built with MPS support; is_available() checks whether MPS is usable in the current environment. A successful availability check does not certify that every model operation or dtype will run on MPS.

Does passing the MPS check mean the whole model uses the GPU? No. The check is about backend availability, not an audit of the model’s execution. Operations may have different support, and a workflow may deliberately leave some work on CPU. Inspect the model’s device placement, the tensors entering each operation, and any fallback behavior rather than treating one successful check as proof of end-to-end GPU execution.

Choosing CPU, MPS, or a split workflow

For a precision-sensitive scientific calculation, the conservative choice is CPU double precision. If the project can tolerate single precision for a particular stage, test that stage on MPS independently. A split workflow can be appropriate, but it requires explicit control of data movement and dtype: do not assume that moving a model alone also moves every tensor or fixes precision requirements.

Which scientific steps should stay on CPU in double precision? Keep a step on CPU when your method, numerical analysis, downstream use, or team acceptance rules require float64. That can include the specific operation that triggers the error, as well as data preparation or later calculations whose precision requirements are documented by your project. Do not decide from a broad label such as “training” or “analysis”; decide at the operation and output level.

To keep a required CPU stage from being pulled onto MPS accidentally, check the device after conversions and before operations. PyTorch’s Tensor.to() documentation describes how to specify a device and dtype. Make those choices explicit at the boundary instead of relying on implicit assumptions:

# Keep a precision-critical calculation on CPU.
precise_input = input_tensor.to(device="cpu", dtype=torch.float64)
precise_result = scientific_step(precise_input)

# Only use this separate path if the project allows float32
# and the resulting MPS workflow passes validation.
mps_input = input_tensor.to(device="mps", dtype=torch.float32)
mps_result = candidate_step(mps_input)

These examples are patterns, not universal drop-in fixes. Your model parameters, buffers, intermediate tensors, and custom operations must also be consistent with the intended device and dtype. If only one stage is eligible for MPS, return to CPU deliberately at the boundary and check the resulting tensor before continuing.

Important: Changing float64 to float32 is a numerical change, not just a device fix. Preserve the original CPU path as a reference until the project’s own validation criteria accept the alternative.

The environment variable PYTORCH_ENABLE_MPS_FALLBACK is documented among the MPS environment variables. Fallback can be relevant when an operation is unsupported on MPS, but it is not a general conversion from float64 to a supported MPS dtype. Do not set it and assume that a double-precision tensor will become valid on MPS. Confirm which operation is failing and where it actually runs.

What should you do when a double tensor error appears in PyTorch 2.15? First isolate the operation and verify the tensor’s dtype and device. If the computation needs double precision, run it on CPU. If single precision is acceptable, convert only the candidate path, verify its operator coverage, and compare its results with the CPU reference before adopting it.

Validating a float32 MPS path against CPU

A successful run is not enough to show that a lower-precision result is scientifically acceptable. Compare both paths under the same project conditions: use the same input data, preprocessing, model state, and relevant settings. Record the CPU output before changing the existing reference implementation.

Use a small reproduction that includes the operation involved in the real failure. A test that only creates a tensor or runs a different model stage cannot establish that the failing path is supported. Check each operation in the actual route, including preprocessing, model execution, and any post-processing that affects reported findings.

A practical review sequence:

• Preserve the baseline. Run the original CPU double-precision calculation and save the input, configuration, and output needed to reproduce it.
• Isolate the boundary. Record the dtype and device immediately before the failing operation. Reduce the case without removing the operation that triggers the error.
• Check the backend. Use the MPS built and available checks. If availability fails, investigate the environment separately from dtype support.
• Create a candidate path. Convert only the stage you intend to test to float32 and MPS. Keep required double-precision work on CPU.
• Exercise the complete target route. Check every operation in that stage. A supported model entry point does not establish that all later operators are supported.
• Compare outputs. Review absolute or relative error measures appropriate to the problem, key statistics, and any quantities used in downstream interpretation.
• Apply the project’s acceptance rule. Use thresholds defined by the research design, validation plan, or team before adopting the result. There is no general error percentage that is safe for every scientific task.

Check for invalid values as well as differences. PyTorch provides torch.isfinite() to test for finite values. That check can reveal NaN or infinite outputs, but it does not prove that a result is accurate or scientifically acceptable. Use it as one diagnostic alongside the comparison and the project’s substantive checks.

For numerical behavior, consult the PyTorch numerical accuracy notes. The relevant tolerance depends on your calculation and how its output is used. A discrepancy that is immaterial for one exploratory workflow may alter a threshold, ranking, or downstream conclusion in another. Write down the criterion before reviewing the candidate result; otherwise, it is easy to choose a tolerance after seeing what the run produced.

A reproducible Mac validation environment

A remote Mac can help when your lab has no Apple Silicon machine but your project must verify a macOS MPS route. It cannot substitute for the CPU reference, a precision review, or institutional approval. Before using any remote environment, confirm the actual macOS version, chip, PyTorch build, and access method available to you. Do not infer these details from the phrase “Mac environment.”

For a reproducible test, record the environment alongside the run: macOS version, chip information, PyTorch version, relevant package versions, MPS availability output, dtype and device checks, and the test inputs or their controlled identifiers. Preserve the exact code revision and the CPU comparison. This makes it easier for another lab member to distinguish a backend availability change from a dtype or operator failure.

If your team has no suitable Mac, compare the cost and effort of using an existing institutional machine, purchasing a Mac, and arranging temporary remote access. An existing lab device may be the simplest choice if it meets your requirements and can be booked reliably. Purchasing makes more sense when the team needs sustained access or physical interfaces. Remote access may suit a bounded compatibility test, but you should first verify its actual system and chip details and confirm that its interaction method works for your workflow.

VpsHold’s available Mac environment information is a place to check what is currently described before deciding whether a remote test can meet your requirements. Use the details shown there to verify the environment; do not treat remote access as evidence that a float32 result is valid or that a required float64 calculation can run on MPS.

The alternatives have real trade-offs. An institutional machine may be unavailable when needed. Buying hardware ties up a larger budget and requires local administration. A remote Mac avoids some local hardware management, but depends on the stated system, chip, and access method, and may not suit work requiring physical peripherals or continuous, controlled access. Compare those constraints against your project’s schedule and reproducibility needs using VpsHold’s Mac options comparison.

The decision for your next run

If the failing operation genuinely requires double precision, keep it on CPU and make that placement explicit. If your research permits float32, treat MPS as a candidate path: test the actual operators, compare against a CPU reference, and accept it only under criteria your project defines in advance. Backend availability is a separate question from dtype support, operator coverage, and result quality.

When your current setup is an overbooked lab Mac or no local Apple Silicon machine at all, those constraints can make repeatable macOS verification difficult: you may have to wait for access, share an environment with other work, or postpone a needed compatibility check. For a bounded validation task, renting a Mac through VpsHold may offer a more direct way to access a macOS test environment without buying a machine. Check the actual system and chip information first, then use the same CPU reference and acceptance process; rental provides access to an environment, not a shortcut around numerical validation.