Your compare function is not strictly equivalent to bytes.Compare because the latter guarantees a return value of -1, 0, or +1, while yours just returns the diff. If I change it to follow the bytes.Compare interface:

func uuidCmpByte2(a, b uuid.UUID) int {
	for i := 0; i < 16; i++ {
		d := int(a[i]) - int(b[i])
		if d < 0 {
			return -1
		} else if d > 0 {
			return 1
		}
	}
	return 0
}

I get:

name             time/op
BytesCompare-4   5.03ms ± 1%
ArrayCompare-4   1.59ms ± 1%
ArrayCompare2-4  5.08ms ± 2%

This largely has to do with how different the UUIDs are.
When they differ on the first byte, then your hand-written comparison will be really fast because it exits the loop immediately.
When they differ later in the UUID, or are in fact equal, then the bytes version will be faster. I measure more than a factor of 2 faster. (e.g. change from uuid.New to uuid.UUID{}.)

Of course, it would be nice to have the best of both worlds. Maybe there is some early-exit things we can do to improve the obviously-different case.

I was also hoping to find a way to cast (without a performance hit) the [16]byte into [2]uint64 thinking that would improve things. I figure the internal implementation of bytes.Compare did that. I'd assumed that some of the performance gains came from being able to unroll the loop.

I agree that the ratio of hits to misses is influential. Thanks for taking a look.

I was also hoping to find a way to cast (without a performance hit) the [16]byte into [2]uint64

There is no penalty with binary.LittleEndian.Uint64(x[0:8]) on amd64.

See https://godbolt.org/z/hxbeYE5E9 - both parts are loaded with a single MOVQ and no bounds checks are needed.

This is because of the hand written function is inlined.

goos: darwin
goarch: arm64
pkg: go-playground/pkg
BenchmarkBytesCompare
BenchmarkBytesCompare-8                  	10990532	       106.1 ns/op
BenchmarkArrayCompare
BenchmarkArrayCompare-8                  	13332518	        89.93 ns/op
BenchmarkArrayCompareNoInline
BenchmarkArrayCompareNoInline-8          	 8318890	       138.7 ns/op
BenchmarkBytesCompareAllSame
BenchmarkBytesCompareAllSame-8           	 9992674	       119.0 ns/op
BenchmarkArrayCompareAllSame
BenchmarkArrayCompareAllSame-8           	 3212157	       371.1 ns/op
BenchmarkArrayCompareAllSameNoInline
BenchmarkArrayCompareAllSameNoInline-8   	 2865070	       487.5 ns/op

We use "compare_native" to compare the bytes using architeture specific optimizations, but ASM commands cannot be inlined.

If the UUIDs are different, the overhead of the call is more significant than when they are the same at which the loop is more prominent.

I don't think there is a good way to inline ASM instructions as of today.