Point distance program written without a framework
It's an interesting idea to write Windows code in Objective-C. If you were using NeXTStep frameworks (or GNUStep) it would make a little more sense. I don't understand your desire to avoid frameworks,  which tend to be force multipliers saving you time and effort. (And of course, you are using OpenGL and GLFW, so this seems like an arbitrary choice.) Regardless, given those constraints, here are my thoughts.
Language
In my opinion Objective-C is the wrong choice for this particular project. I say that as someone who makes a living programming largely in Objective-C. The problem, as I see it, is that you lose 2 important things that you would get from other languages:

The ability to use objects or structs for doing your work and passing them directly to OpenGL/GLFW.
The ability to use operator overloading.

OpenGL expects to receive geometry as an array of vertex attributes (or several different arrays – one for each attribute). That's going to be impossible using the class as you've written it. Each Objective-C object is its own entity on the heap. If  you have an array of them, it's really just an array of pointers to the objects, which may or may not be contiguous in memory. You won't be able to just call glVertexAttribPointer() or other similar functions and pass a pointer to the array since the array will just be an array of other pointers. In C you'd have an array of Point structs either on the stack or the heap and could just pass the address of the first element to the above function. Likewise with something like a C++ std::vector&lt;Point&gt; you'd be able to pass the address of the first element (assuming Point had no v-table). In addition to  making it harder to send  the data to the GPU, it also makes processing the data on the CPU slower because you lose cache coherency when the data isn't contiguous.
You'll also want to do math on your Point objects. While you can write methods on your Objective-C class to add, subtract, etc., it's not as natural as using a language that allows you to overload operators. In particular, C++ and Swift both allow this and it makes writing graphics code feel much more natural.
Class
This class is rather thin. It doesn't do very much that's useful. What it does do, it appears to do correctly. It might be useful to swap the sqrt() call with a call to hypot(x,y) instead.
At a minimum, if you're doing 2D graphics, you'll probably want to add the following methods:
- (void)add:(Point*)p;
- (void)subtract:(Point*)p;
- (float)dotProduct:(Point*)p;
- (void)normalize;
- (void)multiplyScalar:(float)s;
- (void)multiplyVector:(Point*)p;
- (void)divideScalar:(float)s;
- (void)divideVector:(Point*)p;

And eventually, you'll probably want a Matrix class for things like scaling and rotation operations.