It is safe to say that CPUs are relatively good at multiplying floating-point numbers together, but relatively dreadful at calculating square roots from them. Every time we ask a Vector3 to calculate a distance with the magnitude property or with the Distance() method, we're asking it to perform a square root calculation (as per the Pythagorean theorem), which can cost a lot of CPU overhead compared to many other types of vector math calculations.

However, the Vector3 class also offers a sqrMagnitude property, which is the same as distance, only squared. This lets us perform essentially the same comparison check without the expensive square root included, so long as we also square the value we're trying to compare it against; or, to describe this mathematically, if the magnitude of A is less than the magnitude of B, then A² will be less than B².

For example, consider code like the following:

float distance = (transform.position – other.transform.position).Distance();
if (distance < targetDistance) {
  // do stuff
}

This can be replaced with the following and achieve a nearly identical result:

float distanceSqrd = (transform.position – other.transform.position).sqrMagnitude;
if (distanceSqrd < targetDistance * targetDistance) {
  // do stuff
}

The reason the result is nearly identical is because of floating-point precision. We're likely to lose some of the precision that we would have had from using the square-root values, since the value will be adjusted to an area with a different density of representable numbers; it can land exactly on, or closer to, a more accurate representable number, or, more likely, it will land on a number with less accuracy. As a result, the comparison is not exactly the same, but in most cases, it is close enough to be unnoticeable, and the performance gain can be quite significant for each instruction we replace in this manner.

If this minor precision loss is not important to you, then this performance trick should be considered. However, if precision is very important to you (such as running an accurate large-scale galactic space simulation), then you might want to look elsewhere for performance improvements.

Note that this technique can be used for any square-root calculations; not just for distance. This is simply the most common example you might run across, and bring to light the important sqrMagnitude property of the Vector3 class—a property which Unity Technologies intentionally exposed for us to make use of in this manner.