readonly is not quite the same thing as immutable in the sense you mean. readonly means you cannot assign to a variable. So you couldn't do

public static readonly Cord3 zero = new Cord3(0, 0, 0);

zero = new Cord3(0, 0, 1);

In order to achieve the effect you want, you could need to create a class, struct or record with readonly properties or fields. There's no way to achieve that effect with a type defined in an internal library. If the type allows mutability on a field or property, that field or property is mutable.

Maybe I am misunderstanding readonly?

Yeah, readonly means you can't change the reference of your variable. In other words, you can't write Coord3.zero = new(...);

Now, the way these things are usually written is as structs, where fields are by default immutable. That would solve your problem right there. That is also how it's done in Unity. Note that you can also do this with classes, by having only getters on your properties and filling them in once from your constructor, but classes are very heavy weight for these small types.

Marking zero as readonly indeed prevents you from changing what zero stores. You cannot reassign it.

zero = new Coord3(1, 1, 1); // error

Note that since Coord3 is a class, zero.x = 5; isn't actually changing what zero stores. You are just changing some property of the object that zero is referring to. zero is still storing the same reference to the same old object.

You could prevent this by not providing any public API in Coord3 that would change its fields' values - for example, by making x, y, z all read-only properties:

public int X { get; }
public int Y { get; }
public int Z { get; }

Of course, this wouldn't work if you just want to prevent setting the properties on zero, but allow the modification of Coord3 on other objects.

I would suggest that you make Coord3 a struct:

public struct Coord3 {
    public int X { get; set; }
    public int Y { get; set; }
    public int Z { get; set; }
}

Now zero stores the fields' values directly, rather than a reference to an object. zero.x = 5; would produce an error, because you are modifying what zero directly stores.

Note that Unity's Vector3 for example, is also a struct.

I think you can make an immutable base class and your Coord3 inheriting this class.

public class BaseCoord3
{
    // protected means it can only be used by BaseCoord3 and Coord3
    protected int x;

    // equivalent to public int X { get { return x; } }
    public int X => x;  
}

public class Coord3 : BaseCoord3
{
    public override int X
    {
        get { return x; }
        set { x = value; }
    }
    public static BaseCoord3 Zero => new BaseCoord3(0,0,0);
}

This should work similar to the way with Readonly versions of collections in c#. I think the struct solutions are the way to go though.

How about you just use a get-property to never change the zero object?

public class Coord3
{
    public static Coord3 Zero => new Coord3(0,0,0);
}

Then you won't be able to change the values of Zero, but you will maintain the functionality of Coord3 objects.

Coord3 a = Coord3.Zero;
a.x = 2; // changes a.x, but not Coord3.Zero.x