Index: src/OFApplication.h
==================================================================
--- src/OFApplication.h
+++ src/OFApplication.h
@@ -182,12 +182,12 @@
  * @brief Gets args and argv.
  *
  * @param argc A pointer where a pointer to argc should be stored
  * @param argv A pointer where a pointer to argv should be stored
  */
-- (void)getArgumentCount: (int *OF_NONNULL *OF_NONNULL)argc
-       andArgumentValues: (char *OF_NONNULL *OF_NONNULL *OF_NONNULL[])argv;
+- (void)getArgumentCount: (int *_Nonnull *_Nonnull)argc
+       andArgumentValues: (char *_Nonnull *_Nonnull *_Nonnull[])argv;
 
 /*!
  * @brief Returns the name of the program (argv[0]).
  *
  * @return The name of the program (argv[0])
@@ -239,12 +239,12 @@
 @end
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern int of_application_main(int *OF_NONNULL, char *OF_NONNULL *OF_NONNULL[],
+extern int of_application_main(int *_Nonnull, char *_Nonnull *_Nonnull[],
     Class);
 #ifdef __cplusplus
 }
 #endif
 
 OF_ASSUME_NONNULL_END

Index: src/OFArray.h
==================================================================
--- src/OFArray.h
+++ src/OFArray.h
@@ -67,20 +67,20 @@
  *
  * @param object The object to map
  * @param index The index of the object to map
  * @return The object to map to
  */
-typedef id OF_NONNULL (^of_array_map_block_t)(id object, size_t index);
+typedef id _Nonnull (^of_array_map_block_t)(id object, size_t index);
 
 /*!
  * @brief A block for folding an OFArray.
  *
  * @param left The object to which the object has been folded so far
  * @param right The object that should be added to the left object
  * @return The left and right side folded into one object
  */
-typedef id OF_NULLABLE (^of_array_fold_block_t)(id OF_NULLABLE left, id right);
+typedef id _Nullable (^of_array_fold_block_t)(id _Nullable left, id right);
 #endif
 
 /*!
  * @class OFArray OFArray.h ObjFW/OFArray.h
  *
@@ -138,11 +138,11 @@
  * @param objects A C array of objects
  * @param count The length of the C array
  * @return A new autoreleased OFArray
  */
 + (instancetype)
-    arrayWithObjects: (ObjectType const OF_NONNULL *OF_NONNULL)objects
+    arrayWithObjects: (ObjectType const _Nonnull *_Nonnull)objects
 	       count: (size_t)count;
 
 /*!
  * @brief Initializes an OFArray with the specified object.
  *
@@ -183,11 +183,11 @@
  *
  * @param objects A C array of objects
  * @param count The length of the C array
  * @return An initialized OFArray
  */
-- initWithObjects: (ObjectType const OF_NONNULL *OF_NONNULL)objects
+- initWithObjects: (ObjectType const _Nonnull *_Nonnull)objects
 	    count: (size_t)count;
 
 /*!
  * @brief Returns the object at the specified index in the array.
  *
@@ -204,20 +204,19 @@
  * @brief Copies the objects at the specified range to the specified buffer.
  *
  * @param buffer The buffer to copy the objects to
  * @param range The range to copy
  */
-- (void)getObjects: (ObjectType __unsafe_unretained OF_NONNULL *OF_NONNULL)
-			buffer
+- (void)getObjects: (ObjectType __unsafe_unretained _Nonnull *_Nonnull)buffer
 	   inRange: (of_range_t)range;
 
 /*!
  * @brief Returns the objects of the array as a C array.
  *
  * @return The objects of the array as a C array
  */
-- (ObjectType const __unsafe_unretained OF_NONNULL *OF_NONNULL)objects;
+- (ObjectType const __unsafe_unretained _Nonnull *_Nonnull)objects;
 
 /*!
  * @brief Returns the index of the first object that is equivalent to the
  *	  specified object or `OF_NOT_FOUND` if it was not found.
  *
@@ -469,11 +468,11 @@
 	unsigned long *_mutationsPtr;
 	size_t	      _position;
 }
 
 - initWithArray: (OFArray*)data
-   mutationsPtr: (unsigned long *OF_NULLABLE)mutationsPtr;
+   mutationsPtr: (unsigned long *_Nullable)mutationsPtr;
 @end
 
 OF_ASSUME_NONNULL_END
 
 #import "OFMutableArray.h"

Index: src/OFDictionary.h
==================================================================
--- src/OFDictionary.h
+++ src/OFDictionary.h
@@ -36,11 +36,11 @@
 
 #ifdef OF_HAVE_BLOCKS
 typedef void (^of_dictionary_enumeration_block_t)(id key, id object,
      bool *stop);
 typedef bool (^of_dictionary_filter_block_t)(id key, id object);
-typedef id OF_NONNULL (^of_dictionary_map_block_t)(id key, id object);
+typedef id _Nonnull (^of_dictionary_map_block_t)(id key, id object);
 #endif
 
 /*!
  * @class OFDictionary OFDictionary.h ObjFW/OFDictionary.h
  *
@@ -106,12 +106,12 @@
  * @param objects An array of objects
  * @param count The number of objects in the arrays
  * @return A new autoreleased OFDictionary
  */
 + (instancetype)
-    dictionaryWithObjects: (ObjectType const OF_NONNULL *OF_NONNULL)objects
-		  forKeys: (KeyType const OF_NONNULL *OF_NONNULL)keys
+    dictionaryWithObjects: (ObjectType const _Nonnull *_Nonnull)objects
+		  forKeys: (KeyType const _Nonnull *_Nonnull)keys
 		    count: (size_t)count;
 
 /*!
  * @brief Creates a new OFDictionary with the specified keys objects.
  *
@@ -159,12 +159,12 @@
  * @param keys An array of keys
  * @param objects An array of objects
  * @param count The number of objects in the arrays
  * @return An initialized OFDictionary
  */
-- initWithObjects: (ObjectType const OF_NONNULL *OF_NONNULL)objects
-	  forKeys: (KeyType const OF_NONNULL *OF_NONNULL)keys
+- initWithObjects: (ObjectType const _Nonnull *_Nonnull)objects
+	  forKeys: (KeyType const _Nonnull *_Nonnull)keys
 	    count: (size_t)count;
 
 /*!
  * @brief Initializes an already allocated OFDictionary with the specified keys
  *	  and objects.

Index: src/OFEnumerator.h
==================================================================
--- src/OFEnumerator.h
+++ src/OFEnumerator.h
@@ -90,13 +90,13 @@
 #ifndef NSINTEGER_DEFINED
 typedef struct {
 	/// Arbitrary state information for the enumeration
 	unsigned long state;
 	/// Pointer to a C array of objects to return
-	id __unsafe_unretained OF_NULLABLE *OF_NULLABLE itemsPtr;
+	id __unsafe_unretained _Nullable *_Nullable itemsPtr;
 	/// Arbitrary state information to detect mutations
-	unsigned long *OF_NULLABLE mutationsPtr;
+	unsigned long *_Nullable mutationsPtr;
 	/// Additional arbitrary state information
 	unsigned long extra[5];
 } of_fast_enumeration_state_t;
 #endif
 
@@ -118,11 +118,11 @@
  * @param count The number of objects that can be stored at objects
  * @return The number of objects returned in objects or 0 when the enumeration
  *	   finished.
  */
 - (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
-			   objects: (id __unsafe_unretained OF_NONNULL
-					*OF_NONNULL)objects
+			   objects: (id __unsafe_unretained _Nonnull *_Nonnull)
+					objects
 			     count: (int)count;
 @end
 
 OF_ASSUME_NONNULL_END

Index: src/OFHTTPRequest.h
==================================================================
--- src/OFHTTPRequest.h
+++ src/OFHTTPRequest.h
@@ -239,11 +239,11 @@
  * @brief Returns a C string describing the specified request method.
  *
  * @param method The request method which should be described as a C string
  * @return A C string describing the specified request method
  */
-extern const char *OF_NULLABLE of_http_request_method_to_string(
+extern const char *_Nullable of_http_request_method_to_string(
     of_http_request_method_t method);
 
 /*!
  * @brief Returns the request method for the specified string.
  *

Index: src/OFMapTable.h
==================================================================
--- src/OFMapTable.h
+++ src/OFMapTable.h
@@ -26,17 +26,17 @@
  *
  * @brief A struct describing the functions to be used by the map table.
  */
 typedef struct {
 	/// The function to retain keys / values
-	void *OF_NONNULL (*OF_NULLABLE retain)(void *value);
+	void *_Nonnull (*_Nullable retain)(void *value);
 	/// The function to release keys / values
-	void (*OF_NULLABLE release)(void *value);
+	void (*_Nullable release)(void *value);
 	/// The function to hash keys
-	uint32_t (*OF_NULLABLE hash)(void *value);
+	uint32_t (*_Nullable hash)(void *value);
 	/// The function to compare keys / values
-	bool (*OF_NULLABLE equal)(void *value1, void *value2);
+	bool (*_Nullable equal)(void *value1, void *value2);
 } of_map_table_functions_t;
 
 #ifdef OF_HAVE_BLOCKS
 /*!
  * @brief A block for enumerating an OFMapTable.
@@ -54,12 +54,11 @@
  *
  * @param key The key of the value to replace
  * @param value The value to replace
  * @return The value to replace the value with
  */
-typedef void *OF_NONNULL (^of_map_table_replace_block_t)(
-    void *key, void *value);
+typedef void *_Nonnull (^of_map_table_replace_block_t)(void *key, void *value);
 #endif
 
 @class OFMapTableEnumerator;
 
 /*!

Index: src/OFMutableArray.h
==================================================================
--- src/OFMutableArray.h
+++ src/OFMutableArray.h
@@ -26,11 +26,11 @@
  *
  * @param object The object to replace
  * @param index The index of the object to replace
  * @return The object to replace the object with
  */
-typedef id OF_NONNULL (^of_array_replace_block_t)(id object, size_t index);
+typedef id _Nonnull (^of_array_replace_block_t)(id object, size_t index);
 #endif
 
 /*!
  * @class OFMutableArray OFArray.h ObjFW/OFArray.h
  *

Index: src/OFMutableDictionary.h
==================================================================
--- src/OFMutableDictionary.h
+++ src/OFMutableDictionary.h
@@ -26,11 +26,11 @@
  *
  * @param key The key of the object to replace
  * @param object The object to replace
  * @return The object to replace the object with
  */
-typedef id OF_NONNULL (^of_dictionary_replace_block_t)(id key, id object);
+typedef id _Nonnull (^of_dictionary_replace_block_t)(id key, id object);
 #endif
 
 /*!
  * @class OFMutableDictionary OFDictionary.h ObjFW/OFDictionary.h
  *

Index: src/OFObject.h
==================================================================
--- src/OFObject.h
+++ src/OFObject.h
@@ -941,11 +941,11 @@
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 extern id of_alloc_object(Class class_, size_t extraSize,
-    size_t extraAlignment, void *OF_NULLABLE *OF_NULLABLE extra);
+    size_t extraAlignment, void *_Nullable *_Nullable extra);
 extern void OF_NO_RETURN_FUNC of_method_not_found(id self, SEL _cmd);
 extern uint32_t of_hash_seed;
 #ifdef __cplusplus
 }
 #endif

Index: src/OFSet.h
==================================================================
--- src/OFSet.h
+++ src/OFSet.h
@@ -105,11 +105,11 @@
  *
  * @param objects An array of objects for the set
  * @param count The number of objects in the specified array
  * @return A new, autoreleased set with the specified objects
  */
-+ (instancetype)setWithObjects: (ObjectType const OF_NONNULL *OF_NONNULL)objects
++ (instancetype)setWithObjects: (ObjectType const _Nonnull *_Nonnull)objects
 			 count: (size_t)count;
 
 /*!
  * @brief Initializes an already allocated set with the specified set.
  *
@@ -139,11 +139,11 @@
  *
  * @param objects An array of objects for the set
  * @param count The number of objects in the specified array
  * @return An initialized set with the specified objects
  */
-- initWithObjects: (ObjectType const OF_NONNULL *OF_NONNULL)objects
+- initWithObjects: (ObjectType const _Nonnull *_Nonnull)objects
 	    count: (size_t)count;
 
 /*!
  * @brief Initializes an already allocated set with the specified object and
  *	  va_list.

Index: src/OFStdIOStream.h
==================================================================
--- src/OFStdIOStream.h
+++ src/OFStdIOStream.h
@@ -40,21 +40,21 @@
 /*! @file */
 
 /*!
  * @brief The standard input as an OFStream.
  */
-extern OFStdIOStream *OF_NULLABLE of_stdin;
+extern OFStdIOStream *_Nullable of_stdin;
 
 /*!
  * @brief The standard output as an OFStream.
  */
-extern OFStdIOStream *OF_NULLABLE of_stdout;
+extern OFStdIOStream *_Nullable of_stdout;
 
 /*!
  * @brief The standard error as an OFStream.
  */
-extern OFStdIOStream *OF_NULLABLE of_stderr;
+extern OFStdIOStream *_Nullable of_stderr;
 
 extern void of_log(OFConstantString*, ...);
 #ifdef __cplusplus
 }
 #endif

Index: src/OFStream.h
==================================================================
--- src/OFStream.h
+++ src/OFStream.h
@@ -46,11 +46,11 @@
  * @param length The length of the data that has been read
  * @param exception An exception which occurred while reading or nil on success
  * @return A bool whether the same block should be used for the next read
  */
 typedef bool (^of_stream_async_read_block_t)(OFStream *stream, void *buffer,
-    size_t length, OFException *OF_NULLABLE exception);
+    size_t length, OFException *_Nullable exception);
 
 /*!
  * @brief A block which is called when a line was read from the stream.
  *
  * @param stream The stream on which a line was read
@@ -58,11 +58,11 @@
  *	       occurred
  * @param exception An exception which occurred while reading or nil on success
  * @return A bool whether the same block should be used for the next read
  */
 typedef bool (^of_stream_async_read_line_block_t)(OFStream *stream,
-    OFString *OF_NULLABLE line, OFException *OF_NULLABLE exception);
+    OFString *_Nullable line, OFException *_Nullable exception);
 #endif
 
 /*!
  * @class OFStream OFStream.h ObjFW/OFStream.h
  *

Index: src/OFString+XMLUnescaping.h
==================================================================
--- src/OFString+XMLUnescaping.h
+++ src/OFString+XMLUnescaping.h
@@ -35,11 +35,11 @@
  *
  * @param string The XML string which contains an unknown entity
  * @param entity The XML entity which is unknown
  * @return A replacement string for the unknown entity
  */
-typedef OFString *OF_NULLABLE (^of_string_xml_unescaping_block_t)(
+typedef OFString *_Nullable (^of_string_xml_unescaping_block_t)(
     OFString *string, OFString *entity);
 #endif
 
 /*!
  * @protocol OFStringXMLUnescapingDelegate OFString.h ObjFW/OFString.h

Index: src/OFTCPSocket.h
==================================================================
--- src/OFTCPSocket.h
+++ src/OFTCPSocket.h
@@ -32,11 +32,11 @@
  * @param socket The socket which connected
  * @param exception An exception which occurred while connecting the socket or
  *		    nil on success
  */
 typedef void (^of_tcp_socket_async_connect_block_t)(OFTCPSocket *socket,
-    OFException *OF_NULLABLE exception);
+    OFException *_Nullable exception);
 
 /*!
  * @brief A block which is called when the socket accepted a connection.
  *
  * @param socket The socket which accepted the connection
@@ -45,11 +45,11 @@
  *		    nil on success
  * @return A bool whether the same block should be used for the next incoming
  *	   connection
  */
 typedef bool (^of_tcp_socket_async_accept_block_t)(OFTCPSocket *socket,
-    OFTCPSocket *acceptedSocket, OFException *OF_NULLABLE exception);
+    OFTCPSocket *acceptedSocket, OFException *_Nullable exception);
 #endif
 
 /*!
  * @class OFTCPSocket OFTCPSocket.h ObjFW/OFTCPSocket.h
  *
@@ -279,11 +279,11 @@
 @end
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern Class OF_NULLABLE of_tls_socket_class;
+extern Class _Nullable of_tls_socket_class;
 #ifdef __cplusplus
 }
 #endif
 
 OF_ASSUME_NONNULL_END

Index: src/OFThread.h
==================================================================
--- src/OFThread.h
+++ src/OFThread.h
@@ -32,11 +32,11 @@
 /*!
  * @brief A block to be executed in a new thread.
  *
  * @return The object which should be returned when the thread is joined
  */
-typedef id OF_NULLABLE (^of_thread_block_t)(void);
+typedef id _Nullable (^of_thread_block_t)(void);
 #endif
 
 /*!
  * @class OFThread OFThread.h ObjFW/OFThread.h
  *

Index: src/OFUDPSocket.h
==================================================================
--- src/OFUDPSocket.h
+++ src/OFUDPSocket.h
@@ -47,11 +47,11 @@
  * @param exception An exception which occurred while resolving or nil on
  *		    success
  */
 typedef void (^of_udp_socket_async_resolve_block_t)(OFString *host,
     uint16_t port, of_udp_socket_address_t address,
-    OFException *OF_NULLABLE exception);
+    OFException *_Nullable exception);
 
 /*!
  * @brief A block which is called when a packet has been received.
  *
  * @param socket The UDP which received a packet
@@ -62,11 +62,11 @@
  *		    success
  * @return A bool whether the same block should be used for the next receive
  */
 typedef bool (^of_udp_socket_async_receive_block_t)(OFUDPSocket *socket,
     void *buffer, size_t length, of_udp_socket_address_t sender,
-    OFException *OF_NULLABLE exception);
+    OFException *_Nullable exception);
 #endif
 
 /*!
  * @class OFUDPSocket OFUDPSocket.h ObjFW/OFUDPSocket.h
  *
@@ -155,12 +155,12 @@
  *	       the host of the host / port pair.
  * @param port A pointer to an uint16_t. If it is not NULL, the port of the
  *	       host / port pair will be written to it.
  * @param address The address for which the host and port should be retrieved
  */
-+ (void)getHost: (OFString *__autoreleasing OF_NONNULL *OF_NULLABLE)host
-	andPort: (uint16_t *OF_NULLABLE)port
++ (void)getHost: (OFString *__autoreleasing _Nonnull *_Nullable)host
+	andPort: (uint16_t *_Nullable)port
      forAddress: (of_udp_socket_address_t*)address;
 
 /*!
  * @brief Binds the socket to the specified host and port.
  *

Index: src/OFZIPArchiveEntry.h
==================================================================
--- src/OFZIPArchiveEntry.h
+++ src/OFZIPArchiveEntry.h
@@ -233,11 +233,11 @@
  * @param data A pointer to a pointer that should be set to the start of the
  *	       extra field with the specified tag
  * @param size A pointer to an uint16_t that should be set to the size
  */
 extern void of_zip_archive_entry_extra_field_find(OFDataArray *extraField,
-    uint16_t tag, uint8_t *OF_NONNULL *OF_NONNULL data, uint16_t *size);
+    uint16_t tag, uint8_t *_Nonnull *_Nonnull data, uint16_t *size);
 #ifdef __cplusplus
 }
 #endif
 
 OF_ASSUME_NONNULL_END

Index: src/atomic.h
==================================================================
--- src/atomic.h
+++ src/atomic.h
@@ -27,11 +27,11 @@
 #endif
 
 OF_ASSUME_NONNULL_BEGIN
 
 static OF_INLINE int
-of_atomic_int_add(volatile int *OF_NONNULL p, int i)
+of_atomic_int_add(volatile int *_Nonnull p, int i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p += i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_add_and_fetch(p, i);
@@ -76,11 +76,11 @@
 # error of_atomic_int_add not implemented!
 #endif
 }
 
 static OF_INLINE int32_t
-of_atomic_int32_add(volatile int32_t *OF_NONNULL p, int32_t i)
+of_atomic_int32_add(volatile int32_t *_Nonnull p, int32_t i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p += i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_add_and_fetch(p, i);
@@ -112,11 +112,11 @@
 # error of_atomic_int32_add not implemented!
 #endif
 }
 
 static OF_INLINE void*
-of_atomic_ptr_add(void *volatile OF_NULLABLE *OF_NONNULL p, intptr_t i)
+of_atomic_ptr_add(void *volatile _Nullable *_Nonnull p, intptr_t i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*(char* volatile*)p += i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_add_and_fetch(p, (void*)i);
@@ -162,11 +162,11 @@
 # error of_atomic_ptr_add not implemented!
 #endif
 }
 
 static OF_INLINE int
-of_atomic_int_sub(volatile int *OF_NONNULL p, int i)
+of_atomic_int_sub(volatile int *_Nonnull p, int i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p -= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_sub_and_fetch(p, i);
@@ -213,11 +213,11 @@
 # error of_atomic_int_sub not implemented!
 #endif
 }
 
 static OF_INLINE int32_t
-of_atomic_int32_sub(volatile int32_t *OF_NONNULL p, int32_t i)
+of_atomic_int32_sub(volatile int32_t *_Nonnull p, int32_t i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p -= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_sub_and_fetch(p, i);
@@ -250,11 +250,11 @@
 # error of_atomic_int32_sub not implemented!
 #endif
 }
 
 static OF_INLINE void*
-of_atomic_ptr_sub(void *volatile OF_NULLABLE *OF_NONNULL p, intptr_t i)
+of_atomic_ptr_sub(void *volatile _Nullable *_Nonnull p, intptr_t i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*(char* volatile*)p -= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_sub_and_fetch(p, (void*)i);
@@ -302,11 +302,11 @@
 # error of_atomic_ptr_sub not implemented!
 #endif
 }
 
 static OF_INLINE int
-of_atomic_int_inc(volatile int *OF_NONNULL p)
+of_atomic_int_inc(volatile int *_Nonnull p)
 {
 #if !defined(OF_HAVE_THREADS)
 	return ++*p;
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_add_and_fetch(p, 1);
@@ -359,11 +359,11 @@
 # error of_atomic_int_inc not implemented!
 #endif
 }
 
 static OF_INLINE int32_t
-of_atomic_int32_inc(volatile int32_t *OF_NONNULL p)
+of_atomic_int32_inc(volatile int32_t *_Nonnull p)
 {
 #if !defined(OF_HAVE_THREADS)
 	return ++*p;
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_add_and_fetch(p, 1);
@@ -401,11 +401,11 @@
 # error of_atomic_int32_inc not implemented!
 #endif
 }
 
 static OF_INLINE int
-of_atomic_int_dec(volatile int *OF_NONNULL p)
+of_atomic_int_dec(volatile int *_Nonnull p)
 {
 #if !defined(OF_HAVE_THREADS)
 	return --*p;
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_sub_and_fetch(p, 1);
@@ -458,11 +458,11 @@
 # error of_atomic_int_dec not implemented!
 #endif
 }
 
 static OF_INLINE int32_t
-of_atomic_int32_dec(volatile int32_t *OF_NONNULL p)
+of_atomic_int32_dec(volatile int32_t *_Nonnull p)
 {
 #if !defined(OF_HAVE_THREADS)
 	return --*p;
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_sub_and_fetch(p, 1);
@@ -500,11 +500,11 @@
 # error of_atomic_int32_dec not implemented!
 #endif
 }
 
 static OF_INLINE unsigned int
-of_atomic_int_or(volatile unsigned int *OF_NONNULL p, unsigned int i)
+of_atomic_int_or(volatile unsigned int *_Nonnull p, unsigned int i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p |= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_or_and_fetch(p, i);
@@ -559,11 +559,11 @@
 # error of_atomic_int_or not implemented!
 #endif
 }
 
 static OF_INLINE uint32_t
-of_atomic_int32_or(volatile uint32_t *OF_NONNULL p, uint32_t i)
+of_atomic_int32_or(volatile uint32_t *_Nonnull p, uint32_t i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p |= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_or_and_fetch(p, i);
@@ -600,11 +600,11 @@
 # error of_atomic_int32_or not implemented!
 #endif
 }
 
 static OF_INLINE unsigned int
-of_atomic_int_and(volatile unsigned int *OF_NONNULL p, unsigned int i)
+of_atomic_int_and(volatile unsigned int *_Nonnull p, unsigned int i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p &= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_and_and_fetch(p, i);
@@ -659,11 +659,11 @@
 # error of_atomic_int_and not implemented!
 #endif
 }
 
 static OF_INLINE uint32_t
-of_atomic_int32_and(volatile uint32_t *OF_NONNULL p, uint32_t i)
+of_atomic_int32_and(volatile uint32_t *_Nonnull p, uint32_t i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p &= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_and_and_fetch(p, i);
@@ -700,11 +700,11 @@
 # error of_atomic_int32_and not implemented!
 #endif
 }
 
 static OF_INLINE unsigned int
-of_atomic_int_xor(volatile unsigned int *OF_NONNULL p, unsigned int i)
+of_atomic_int_xor(volatile unsigned int *_Nonnull p, unsigned int i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p ^= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_xor_and_fetch(p, i);
@@ -759,11 +759,11 @@
 # error of_atomic_int_xor not implemented!
 #endif
 }
 
 static OF_INLINE uint32_t
-of_atomic_int32_xor(volatile uint32_t *OF_NONNULL p, uint32_t i)
+of_atomic_int32_xor(volatile uint32_t *_Nonnull p, uint32_t i)
 {
 #if !defined(OF_HAVE_THREADS)
 	return (*p ^= i);
 #elif defined(OF_HAVE_GCC_ATOMIC_OPS)
 	return __sync_xor_and_fetch(p, i);
@@ -800,11 +800,11 @@
 # error of_atomic_int32_xor not implemented!
 #endif
 }
 
 static OF_INLINE bool
-of_atomic_int_cmpswap(volatile int *OF_NONNULL p, int o, int n)
+of_atomic_int_cmpswap(volatile int *_Nonnull p, int o, int n)
 {
 #if !defined(OF_HAVE_THREADS)
 	if (*p == o) {
 		*p = n;
 		return true;
@@ -855,11 +855,11 @@
 # error of_atomic_int_cmpswap not implemented!
 #endif
 }
 
 static OF_INLINE bool
-of_atomic_int32_cmpswap(volatile int32_t *OF_NONNULL p, int32_t o, int32_t n)
+of_atomic_int32_cmpswap(volatile int32_t *_Nonnull p, int32_t o, int32_t n)
 {
 #if !defined(OF_HAVE_THREADS)
 	if (*p == o) {
 		*p = n;
 		return true;
@@ -910,12 +910,12 @@
 # error of_atomic_int32_cmpswap not implemented!
 #endif
 }
 
 static OF_INLINE bool
-of_atomic_ptr_cmpswap(void *volatile OF_NULLABLE *OF_NONNULL p,
-    void *OF_NULLABLE o, void *OF_NULLABLE n)
+of_atomic_ptr_cmpswap(void *volatile _Nullable *_Nonnull p,
+    void *_Nullable o, void *_Nullable n)
 {
 #if !defined(OF_HAVE_THREADS)
 	if (*p == o) {
 		*p = n;
 		return true;

Index: src/instance.h
==================================================================
--- src/instance.h
+++ src/instance.h
@@ -19,11 +19,11 @@
 OF_ASSUME_NONNULL_BEGIN
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern id objc_constructInstance(Class OF_NULLABLE, void *OF_NULLABLE);
+extern id objc_constructInstance(Class _Nullable, void *_Nullable);
 extern void* objc_destructInstance(id);
 #ifdef __cplusplus
 }
 #endif
 

Index: src/macros.h
==================================================================
--- src/macros.h
+++ src/macros.h
@@ -168,18 +168,17 @@
 #endif
 
 #if __has_feature(nullability)
 # define OF_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin")
 # define OF_ASSUME_NONNULL_END _Pragma("clang assume_nonnull end")
-# define OF_NONNULL _Nonnull
-# define OF_NULLABLE _Nullable
 # define OF_NULLABLE_PROPERTY(...) (__VA_ARGS__, nullable)
 #else
 # define OF_ASSUME_NONNULL_BEGIN
 # define OF_ASSUME_NONNULL_END
-# define OF_NONNULL
-# define OF_NULLABLE
+# define _Nonnull
+# define _Nullable
+# define _Null_unspecified
 # define OF_NULLABLE_PROPERTY
 # define nonnull
 # define nullable
 #endif
 

Index: src/of_asprintf.h
==================================================================
--- src/of_asprintf.h
+++ src/of_asprintf.h
@@ -29,13 +29,13 @@
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 extern int of_asprintf(
-    char *OF_NULLABLE *OF_NONNULL, const char *OF_NONNULL, ...);
+    char *_Nullable *_Nonnull, const char *_Nonnull, ...);
 extern int of_vasprintf(
-    char *OF_NULLABLE *OF_NONNULL, const char *OF_NONNULL, va_list);
+    char *_Nullable *_Nonnull, const char *_Nonnull, va_list);
 #ifdef __cplusplus
 }
 #endif
 
 OF_ASSUME_NONNULL_END

Index: src/resolver.h
==================================================================
--- src/resolver.h
+++ src/resolver.h
@@ -47,12 +47,12 @@
  *		   address struct
  *
  * @return An array of results. The list is terminated by NULL and should be
  *	   free'd after use.
  */
-extern of_resolver_result_t *OF_NULLABLE *OF_NONNULL
-    of_resolve_host(OFString *host, uint16_t port, int protocol);
+extern of_resolver_result_t *_Nullable *_Nonnull of_resolve_host(OFString *host,
+    uint16_t port, int protocol);
 
 /*!
  * @brief Converts the specified address to a string and port pair.
  *
  * @param address The address to convert to a string
@@ -62,20 +62,20 @@
  * @param port A pointer to an uint16_t which should be set to the port of the
  *	       address or NULL if the port is not needed
  */
 extern void of_address_to_string_and_port(struct sockaddr *address,
     socklen_t addressLength,
-    OFString *__autoreleasing OF_NONNULL *OF_NULLABLE host,
-    uint16_t *OF_NULLABLE port);
+    OFString *__autoreleasing _Nonnull *_Nullable host,
+    uint16_t *_Nullable port);
 
 /*!
  * @brief Frees the results returned by @ref of_resolve_host.
  *
  * @param results The results returned by @ref of_resolve_host
  */
 extern void of_resolver_free(
-    of_resolver_result_t *OF_NULLABLE *OF_NONNULL results);
+    of_resolver_result_t *_Nullable *_Nonnull results);
 #ifdef __cplusplus
 }
 #endif
 
 OF_ASSUME_NONNULL_END