diff --git a/include/coreinit/cache.h b/include/coreinit/cache.h
index c9c7bf4..96bfa6a 100644
--- a/include/coreinit/cache.h
+++ b/include/coreinit/cache.h
@@ -4,6 +4,8 @@
 /**
  * \defgroup coreinit_cache Cache
  * \ingroup coreinit
+ *
+ * Cache synchronisation functions.
  * @{
  */
 
@@ -11,34 +13,67 @@
 extern "C" {
 #endif
 
+
+/**
+ * Equivalent to dcbi instruction.
+ */
 void
 DCInvalidateRange(void *addr,
                   uint32_t size);
 
+
+/**
+ * Equivalent to dcbf, sync, eieio.
+ */
 void
 DCFlushRange(void *addr,
              uint32_t size);
 
+
+/**
+ * Equivalent to dcbst, sync, eieio.
+ */
 void
 DCStoreRange(void *addr,
              uint32_t size);
 
+
+/**
+ * Equivalent to dcbf.
+ *
+ * Does not perform sync, eieio like DCFlushRange.
+ */
 void
 DCFlushRangeNoSync(void *addr,
                    uint32_t size);
 
+
+/**
+ * Equivalent to dcbst.
+ *
+ * Does not perform sync, eieio like DCStoreRange.
+ */
 void
 DCStoreRangeNoSync(void *addr,
                    uint32_t size);
 
+
+/**
+ * Equivalent to dcbz instruction.
+ */
 void
 DCZeroRange(void *addr,
             uint32_t size);
 
+
+/**
+ * Equivalent to dcbt instruction.
+ */
 void
 DCTouchRange(void *addr,
              uint32_t size);
 
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/coreinit/condition.h b/include/coreinit/condition.h
index 7cd3cf1..de2b18c 100644
--- a/include/coreinit/condition.h
+++ b/include/coreinit/condition.h
@@ -5,6 +5,10 @@
 /**
  * \defgroup coreinit_cond Condition Variable
  * \ingroup coreinit
+ *
+ * Standard condition variable implementation.
+ *
+ * Similar to <a href="http://en.cppreference.com/w/cpp/thread/condition_variable">std::condition_variable</a>.
  * @{
  */
 
@@ -35,20 +39,44 @@ CHECK_OFFSET(OSCondition, 0x04, name);
 CHECK_OFFSET(OSCondition, 0x0c, queue);
 CHECK_SIZE(OSCondition, 0x1c);
 
+
+/**
+ * Initialise a condition variable structure.
+ */
 void
 OSInitCond(OSCondition *condition);
 
+
+/**
+ * Initialise a condition variable structure with a name.
+ */
 void
 OSInitCondEx(OSCondition *condition,
              const char *name);
 
+
+/**
+ * Sleep the current thread until the condition variable has been signalled.
+ *
+ * The mutex must be locked when entering this function.
+ * Will unlock the mutex and then sleep, reacquiring the mutex when woken.
+ *
+ * Similar to <a href="http://en.cppreference.com/w/cpp/thread/condition_variable/wait">std::condition_variable::wait</a>.
+ */
 void
 OSWaitCond(OSCondition *condition,
            OSMutex *mutex);
 
+
+/**
+ * Will wake up any threads waiting on the condition with OSWaitCond.
+ *
+ * Similar to <a href="http://en.cppreference.com/w/cpp/thread/condition_variable/notify_all">std::condition_variable::notify_all</a>.
+ */
 void
 OSSignalCond(OSCondition *condition);
 
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/coreinit/event.h b/include/coreinit/event.h
index f97a157..9600195 100644
--- a/include/coreinit/event.h
+++ b/include/coreinit/event.h
@@ -6,6 +6,10 @@
 /**
  * \defgroup coreinit_event Event Object
  * \ingroup coreinit
+ *
+ * Standard event object implementation. There are two supported event object modes, check OSEventMode.
+ *
+ * Similar to Windows <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms682655(v=vs.85).aspx">Event Objects</a>.
  * @{
  */
 
@@ -18,7 +22,10 @@ typedef uint32_t OSEventMode;
 
 enum OSEventMode
 {
+   //! A manual event will only reset when OSResetEvent is called.
    OS_EVENT_MODE_MANUAL    = 0,
+
+   //! An auto event will reset everytime a thread is woken.
    OS_EVENT_MODE_AUTO      = 1,
 };
 
@@ -26,11 +33,21 @@ enum OSEventMode
 
 struct OSEvent
 {
+   //! Should always be set to the value OS_EVENT_TAG.
    uint32_t tag;
+
+   //! Name set by OSInitEventEx.
    const char *name;
+
    UNKNOWN(4);
+
+   //! The current value of the event object.
    BOOL value;
+
+   //! The threads currently waiting on this event object with OSWaitEvent.
    OSThreadQueue queue;
+
+   //! The mode of the event object, set by OSInitEvent.
    OSEventMode mode;
 };
 CHECK_OFFSET(OSEvent, 0x0, tag);
@@ -42,29 +59,85 @@ CHECK_SIZE(OSEvent, 0x24);
 
 #pragma pack(pop)
 
+
+/**
+ * Initialise an event object with value and mode.
+ */
 void
 OSInitEvent(OSEvent *event,
             BOOL value,
             OSEventMode mode);
 
+
+/**
+ * Initialise an event object with value, mode and name.
+ */
 void
 OSInitEventEx(OSEvent *event,
               BOOL value,
               OSEventMode mode,
               char *name);
 
+
+/**
+ * Signals the event.
+ *
+ * If no threads are waiting the event value is set.
+ *
+ * If the event mode is OS_EVENT_MODE_MANUAL this will wake all waiting threads
+ * and the event will remain set until OSResetEvent is called.
+ *
+ * If the event mode is OS_EVENT_MODE_AUTO this will wake only one thread
+ * and the event will be reset immediately.
+ *
+ * Similar to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms686211(v=vs.85).aspx">SetEvent</a>.
+ */
 void
 OSSignalEvent(OSEvent *event);
 
+/**
+ * Signals all threads waiting on an event.
+ *
+ * If no threads are waiting the event value is set.
+ *
+ * If the event mode is OS_EVENT_MODE_MANUAL this will wake all waiting threads
+ * and the event will remain set until OSResetEvent is called.
+ *
+ * If the event mode is OS_EVENT_MODE_AUTO this will wake all waiting threads
+ * and the event will be reset.
+ */
 void
 OSSignalEventAll(OSEvent *event);
 
+
+/**
+ * Wait until an event is signalled.
+ *
+ * If the event is already set, this returns immediately.
+ *
+ * If the event mode is OS_EVENT_MODE_AUTO the event will be reset before
+ * returning from this method.
+ *
+ * Similar to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx">WaitForSingleObject</a>.
+ */
 void
 OSWaitEvent(OSEvent *event);
 
+
+/**
+ * Resets the event object.
+ *
+ * Similar to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms685081(v=vs.85).aspx">ResetEvent</a>.
+ */
 void
 OSResetEvent(OSEvent *event);
 
+
+/**
+ * Wait until an event is signalled or a timeout has occurred.
+ *
+ * Similar to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx">WaitForSingleObject</a>.
+ */
 BOOL
 OSWaitEventWithTimeout(OSEvent *event,
                        OSTime timeout);
diff --git a/include/coreinit/fastmutex.h b/include/coreinit/fastmutex.h
index 7e70388..98dd477 100644
--- a/include/coreinit/fastmutex.h
+++ b/include/coreinit/fastmutex.h
@@ -5,6 +5,9 @@
 /**
  * \defgroup coreinit_fastmutex Fast Mutex
  * \ingroup coreinit
+ *
+ * Similar to OSMutex but tries to acquire the mutex without using the global
+ * scheduler lock, and does not test for thread cancel.
  * @{
  */
 
@@ -43,7 +46,8 @@ CHECK_OFFSET(OSFastMutex, 0x14, link);
 CHECK_SIZE(OSFastMutex, 0x2c);
 
 void
-OSFastMutex_Init(OSFastMutex *mutex, const char *name);
+OSFastMutex_Init(OSFastMutex *mutex,
+                 const char *name);
 
 void
 OSFastMutex_Lock(OSFastMutex *mutex);
diff --git a/include/coreinit/mutex.h b/include/coreinit/mutex.h
index c0c2a0a..9aa90fa 100644
--- a/include/coreinit/mutex.h
+++ b/include/coreinit/mutex.h
@@ -5,6 +5,10 @@
 /**
  * \defgroup coreinit_mutex Mutex
  * \ingroup coreinit
+ *
+ * Standard mutex object, supports recursive locking.
+ *
+ * Similar to <a href="http://en.cppreference.com/w/cpp/thread/recursive_mutex">std::recursive_mutex</a>.
  * @{
  */
 
@@ -31,23 +35,24 @@ CHECK_SIZE(OSMutexLink, 0x8);
 
 struct OSMutex
 {
-   // OSMutex::Tag
+   //! Should always be set to the value OS_MUTEX_TAG.
    uint32_t tag;
 
-   // Name set by OSInitMutexEx(mutex, name)
+   //! Name set by OSInitMutexEx.
    const char *name;
+
    UNKNOWN(4);
 
-   // Queue of threads waiting for this mutex to unlock
+   //! Queue of threads waiting for this mutex to unlock.
    OSThreadQueue queue;
 
-   // Current owner of mutex
+   //! Current owner of mutex.
    OSThread *owner;
 
-   // Current recursion lock count of mutex
+   //! Current recursion lock count of mutex.
    int32_t count;
 
-   // Link used inside OSThread's mutex queue
+   //! Link used inside OSThread's mutex queue.
    OSMutexLink link;
 };
 CHECK_OFFSET(OSMutex, 0x00, tag);
@@ -58,21 +63,68 @@ CHECK_OFFSET(OSMutex, 0x20, count);
 CHECK_OFFSET(OSMutex, 0x24, link);
 CHECK_SIZE(OSMutex, 0x2c);
 
+
+/**
+ * Initialise a mutex structure.
+ */
 void
 OSInitMutex(OSMutex *mutex);
 
+
+/**
+ * Initialise a mutex structure with a name.
+ */
 void
 OSInitMutexEx(OSMutex *mutex,
               const char *name);
 
+
+/**
+ * Lock the mutex.
+ *
+ * If no one owns the mutex, set current thread as owner.
+ *
+ * If the lock is owned by the current thread, increase the recursion count.
+ *
+ * If the lock is owned by another thread, the current thread will sleep until
+ * the owner has unlocked this mutex.
+ *
+ * Similar to <a href="http://en.cppreference.com/w/cpp/thread/recursive_mutex/lock">std::recursive_mutex::lock</a>.
+ */
 void
 OSLockMutex(OSMutex *mutex);
 
+
+/**
+ * Try to lock a mutex.
+ *
+ * If no one owns the mutex, set current thread as owner.
+ *
+ * If the lock is owned by the current thread, increase the recursion count.
+ *
+ * If the lock is owned by another thread, do not block, return FALSE.
+ *
+ * \return TRUE if the mutex is locked, FALSE if the mutex is owned by another thread.
+ *
+ * Similar to <a href="http://en.cppreference.com/w/cpp/thread/recursive_mutex/try_lock">std::recursive_mutex::try_lock</a>.
+ */
+BOOL
+OSTryLockMutex(OSMutex *mutex);
+
+
+/**
+ * Unlocks the mutex.
+ *
+ * Will decrease the recursion count, will only unlock the mutex when the
+ * recursion count reaches 0.
+ *
+ * If any other threads are waiting to lock the mutex they will be woken.
+ *
+ * Similar to <a href="http://en.cppreference.com/w/cpp/thread/recursive_mutex/unlock">std::recursive_mutex::unlock</a>.
+ */
 void
 OSUnlockMutex(OSMutex *mutex);
 
-BOOL
-OSTryLockMutex(OSMutex *mutex);
 
 #ifdef __cplusplus
 }
diff --git a/include/coreinit/semaphore.h b/include/coreinit/semaphore.h
index 972a042..2d1b0f9 100644
--- a/include/coreinit/semaphore.h
+++ b/include/coreinit/semaphore.h
@@ -5,6 +5,8 @@
 /**
  * \defgroup coreinit_semaphore Semaphore
  * \ingroup coreinit
+ *
+ * Similar to Windows <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms685129(v=vs.85).aspx">Semaphore Objects</a>.
  * @{
  */
 
@@ -18,10 +20,18 @@ typedef struct OSSemaphore OSSemaphore;
 
 struct OSSemaphore
 {
+   //! Should always be set to the value OS_SEMAPHORE_TAG.
    uint32_t tag;
+
+   //! Name set by OSInitMutexEx.
    const char *name;
+
    UNKNOWN(4);
+
+   //! Current count of semaphore
    int32_t count;
+
+   //! Queue of threads waiting on semaphore object with OSWaitSemaphore
    OSThreadQueue queue;
 };
 CHECK_OFFSET(OSSemaphore, 0x00, tag);
@@ -30,27 +40,63 @@ CHECK_OFFSET(OSSemaphore, 0x0C, count);
 CHECK_OFFSET(OSSemaphore, 0x10, queue);
 CHECK_SIZE(OSSemaphore, 0x20);
 
+
+/**
+ * Initialise semaphore object with count.
+ */
 void
 OSInitSemaphore(OSSemaphore *semaphore,
                 int32_t count);
 
+
+/**
+ * Initialise semaphore object with count and name.
+ */
 void
 OSInitSemaphoreEx(OSSemaphore *semaphore,
                   int32_t count,
                   const char *name);
 
+
+/**
+ * Get the current semaphore count.
+ */
 int32_t
 OSGetSemaphoreCount(OSSemaphore *semaphore);
 
+
+/**
+ * Increase the semaphore value.
+ *
+ * If any threads are waiting for semaphore, they are woken.
+ */
 int32_t
 OSSignalSemaphore(OSSemaphore *semaphore);
 
+
+/**
+ * Decrease the semaphore value.
+ *
+ * If the value is less than or equal to zero the current thread will be put to
+ * sleep until the count is above zero and it can decrement it safely.
+ */
 int32_t
 OSWaitSemaphore(OSSemaphore *semaphore);
 
+
+/**
+ * Try to decrease the semaphore value.
+ *
+ * If the value is greater than zero then it will be decremented, else the function
+ * will return immediately with a value <= 0 indicating a failure.
+ *
+ * \return Returns previous semaphore count, before the decrement in this function.
+ *         If the value is >0 then it means the call was succesful.
+ */
 int32_t
 OSTryWaitSemaphore(OSSemaphore *semaphore);
 
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/coreinit/thread.h b/include/coreinit/thread.h
index 98fb09f..492e9be 100644
--- a/include/coreinit/thread.h
+++ b/include/coreinit/thread.h
@@ -6,6 +6,20 @@
 /**
  * \defgroup coreinit_thread Thread
  * \ingroup coreinit
+ *
+ * The thread scheduler in the Wii U uses co-operative scheduling, this is different
+ * to the usual pre-emptive scheduling that most operating systems use (such as
+ * Windows, Linux, etc). In co-operative scheduling threads must voluntarily yield
+ * execution to other threads. In pre-emptive threads are switched by the operating
+ * system after an amount of time.
+ *
+ * With the Wii U's scheduling model the thread with the highest priority which
+ * is in a non-waiting state will always be running (where 0 is the highest
+ * priority and 31 is the lowest). Execution will only switch to other threads
+ * once this thread has been forced to wait, such as when waiting to acquire a
+ * mutex, or when the thread voluntarily yields execution to other threads which
+ * have the same priority using OSYieldThread. OSYieldThread will never yield to
+ * a thread with lower priority than the current thread.
  * @{
  */
 
@@ -31,9 +45,17 @@ typedef void (*OSThreadDeallocatorFn)(OSThread *thread, void *stack);
 enum OSThreadState
 {
    OS_THREAD_STATE_NONE             = 0,
+
+   //! Thread is ready to run
    OS_THREAD_STATE_READY            = 1 << 0,
+
+   //! Thread is running
    OS_THREAD_STATE_RUNNING          = 1 << 1,
+
+   //! Thread is waiting, i.e. on a mutex
    OS_THREAD_STATE_WAITING          = 1 << 2,
+
+   //! Thread is about to terminate
    OS_THREAD_STATE_MORIBUND         = 1 << 3,
 };
 
@@ -46,18 +68,32 @@ enum OSThreadRequest
 
 enum OSThreadAttributes
 {
+   //! Allow the thread to run on CPU0.
    OS_THREAD_ATTRIB_AFFINITY_CPU0   = 1 << 0,
+
+   //! Allow the thread to run on CPU1.
    OS_THREAD_ATTRIB_AFFINITY_CPU1   = 1 << 1,
+
+   //! Allow the thread to run on CPU2.
    OS_THREAD_ATTRIB_AFFINITY_CPU2   = 1 << 2,
-   OS_THREAD_ATTRIB_AFFINITY_ANY    = 1 << 3,
-   OS_THREAD_ATTRIB_DETACHED        = 1 << 4
+
+   //! Allow the thread to run any CPU.
+   OS_THREAD_ATTRIB_AFFINITY_ANY    = ((1 << 0) | (1 << 1) | (1 << 2)),
+
+   //! Start the thread detached.
+   OS_THREAD_ATTRIB_DETACHED        = 1 << 3,
+
+   //! Enables tracking of stack usage.
+   OS_THREAD_ATTRIB_STACK_USAGE     = 1 << 5
 };
 
 #define OS_CONTEXT_TAG 0x4F53436F6E747874ull
 
 struct OSContext
 {
+   //! Should always be set to the value OS_CONTEXT_TAG.
    uint64_t tag;
+
    uint32_t gpr[32];
    uint32_t cr;
    uint32_t lr;
@@ -132,7 +168,6 @@ CHECK_SIZE(OSFastMutexQueue, 0x08);
 
 #define OS_THREAD_TAG 0x74487244u
 
-#pragma pack(push, 1)
 struct OSThread
 {
    OSContext context;
@@ -140,36 +175,85 @@ struct OSThread
    OSThreadState state;
    OSThreadAttributes attr;
    uint16_t id;
+
+   //! Suspend count (increased by OSSuspendThread).
    int32_t suspendCounter;
-   int32_t priority;                      // Actual priority of thread
-   int32_t basePriority;                  // Base priority of thread
-   int32_t exitValue;                     // Value from OSExitThread
+
+   //! Actual priority of thread.
+   int32_t priority;
+
+   //! Base priority of thread, 0 is highest priority, 31 is lowest priority.
+   int32_t basePriority;
+
+   //! Exit value
+   int32_t exitValue;
+
    UNKNOWN(0x35C - 0x338);
-   OSThreadQueue *queue;                  // Queue the thread is on
-   OSThreadLink link;                     // Thread queue link
-   OSThreadQueue joinQueue;               // Queue of threads waiting to join this
-   OSMutex *mutex;                        // Mutex we are waiting to lock
-   OSMutexQueue mutexQueue;               // Mutexes owned by this thread
-   OSThreadLink activeLink;               // Link on active thread queue
-   void *stackStart;                      // Stack starting value (top, highest address)
-   void *stackEnd;                        // Stack end value (bottom, lowest address)
-   OSThreadEntryPointFn entryPoint;       // Entry point from OSCreateThread
+
+   //! Queue the thread is currently waiting on
+   OSThreadQueue *queue;
+
+   //! Link used for thread queue
+   OSThreadLink link;
+
+   //! Queue of threads waiting to join this thread
+   OSThreadQueue joinQueue;
+
+   //! Mutex this thread is waiting to lock
+   OSMutex *mutex;
+
+   //! Queue of mutexes this thread owns
+   OSMutexQueue mutexQueue;
+
+   //! Link for global active thread queue
+   OSThreadLink activeLink;
+
+   //! Stack start (top, highest address)
+   void *stackStart;
+
+   //! Stack end (bottom, lowest address)
+   void *stackEnd;
+
+   //! Thread entry point
+   OSThreadEntryPointFn entryPoint;
+
    UNKNOWN(0x57c - 0x3a0);
-   uint32_t specific[0x10];               // OSSetThreadSpecific / OSGetThreadSpecific
+
+   //! Thread specific values, accessed with OSSetThreadSpecific and OSGetThreadSpecific.
+   uint32_t specific[0x10];
+
    UNKNOWN(0x5c0 - 0x5bc);
-   const char *name;                      // Thread name
+
+   //! Thread name, accessed with OSSetThreadName and OSGetThreadName.
+   const char *name;
+
    UNKNOWN(0x4);
-   void *userStackPointer;                // The stack specified in OSCreateThread
-   OSThreadCleanupCallbackFn cleanupCallback; // Set with OSSetThreadCleanupCallback
-   OSThreadDeallocatorFn deallocator;     // Set with OSSetThreadDeallocator
-   uint32_t cancelState;                  // Is listening to requestFlag enabled
-   OSThreadRequest requestFlag;           // Request flag for cancel or suspend
-   int32_t needSuspend;                   // How many pending suspends we have
-   int32_t suspendResult;                 // Result of suspend
-   OSThreadQueue suspendQueue;            // Queue of threads waiting for suspend to finish
+
+   //! The stack pointer passed in OSCreateThread.
+   void *userStackPointer;
+
+   //! Called just before thread is terminated, set with OSSetThreadCleanupCallback
+   OSThreadCleanupCallbackFn cleanupCallback;
+
+   //! Called just after a thread is terminated, set with OSSetThreadDeallocator
+   OSThreadDeallocatorFn deallocator;
+
+   //! If TRUE then a thread can be cancelled or suspended, set with OSSetThreadCancelState
+   BOOL cancelState;
+
+   //! Current thread request, used for cancelleing and suspending the thread.
+   OSThreadRequest requestFlag;
+
+   //! Pending suspend request count
+   int32_t needSuspend;
+
+   //! Result of thread suspend
+   int32_t suspendResult;
+
+   //! Queue of threads waiting for a thread to be suspended.
+   OSThreadQueue suspendQueue;
    UNKNOWN(0x69c - 0x5f4);
 };
-#pragma pack(pop)
 CHECK_OFFSET(OSThread, 0x320, tag);
 CHECK_OFFSET(OSThread, 0x324, state);
 CHECK_OFFSET(OSThread, 0x325, attr);
@@ -199,21 +283,57 @@ CHECK_OFFSET(OSThread, 0x5e0, suspendResult);
 CHECK_OFFSET(OSThread, 0x5e4, suspendQueue);
 CHECK_SIZE(OSThread, 0x69c);
 
+
+/**
+ * Cancels a thread.
+ *
+ * This sets the threads requestFlag to OS_THREAD_REQUEST_CANCEL, the thread will
+ * be terminated next time OSTestThreadCancel is called.
+ */
 void
 OSCancelThread(OSThread *thread);
 
+
+/**
+ * Returns the count of active threads.
+ */
 int32_t
 OSCheckActiveThreads();
 
+
+/**
+ * Get the maximum amount of stack the thread has used.
+ */
 int32_t
 OSCheckThreadStackUsage(OSThread *thread);
 
+
+/**
+ * Disable tracking of thread stack usage
+ */
 void
 OSClearThreadStackUsage(OSThread *thread);
 
+
+/**
+ * Clears a thread's suspend counter and resumes it.
+ */
 void
 OSContinueThread(OSThread *thread);
 
+
+/**
+ * Create a new thread.
+ *
+ * \param thread Thread to initialise.
+ * \param entry Thread entry point.
+ * \param argc argc argument passed to entry point.
+ * \param argv argv argument passed to entry point.
+ * \param stack Top of stack (highest address).
+ * \param stackSize Size of stack.
+ * \param priority Thread priority, 0 is highest priorty, 31 is lowest.
+ * \param attributes Thread attributes, see OSThreadAttributes.
+ */
 BOOL
 OSCreateThread(OSThread *thread,
                OSThreadEntryPointFn entry,
@@ -224,111 +344,277 @@ OSCreateThread(OSThread *thread,
                int32_t priority,
                OSThreadAttributes attributes);
 
+
+/**
+ * Detach thread.
+ */
 void
 OSDetachThread(OSThread *thread);
 
+
+/**
+ * Exit the current thread with a exit code.
+ *
+ * This function is implicitly called when the thread entry point returns.
+ */
 void
 OSExitThread(int32_t result);
 
+
+/**
+ * Get the next and previous thread in the thread's active queue.
+ */
 void
 OSGetActiveThreadLink(OSThread *thread,
                       OSThreadLink *link);
 
+
+/**
+ * Return pointer to OSThread object for the current thread.
+ */
 OSThread *
 OSGetCurrentThread();
 
+
+/**
+ * Returns the default thread for a specific core.
+ *
+ * Each core has 1 default thread created before the game boots. The default
+ * thread for core 1 calls the RPX entry point, the default threads for core 0
+ * and 2 are suspended and can be used with OSRunThread.
+ */
 OSThread *
 OSGetDefaultThread(uint32_t coreID);
 
+
+/**
+ * Return current stack pointer, value of r1 register.
+ */
 uint32_t
 OSGetStackPointer();
 
+
+/**
+ * Get a thread's affinity.
+ */
 uint32_t
 OSGetThreadAffinity(OSThread *thread);
 
+
+/**
+ * Get a thread's name.
+ */
 const char *
 OSGetThreadName(OSThread *thread);
 
+
+/**
+ * Get a thread's base priority.
+ */
 int32_t
 OSGetThreadPriority(OSThread *thread);
 
+
+/**
+ * Get a thread's specific value set by OSSetThreadSpecific.
+ */
 uint32_t
 OSGetThreadSpecific(uint32_t id);
 
+
+/**
+ * Returns TRUE if a thread is suspended.
+ */
 BOOL
 OSIsThreadSuspended(OSThread *thread);
 
+
+/**
+ * Returns TRUE if a thread is terminated.
+ */
 BOOL
 OSIsThreadTerminated(OSThread *thread);
 
+
+/**
+ * Wait until thread is terminated.
+ *
+ * If the target thread is detached, returns FALSE.
+ *
+ * \param thread Thread to wait for
+ * \param threadResult Pointer to store thread exit value in.
+ * \returns Returns TRUE if thread has terminated, FALSE if thread is detached.
+ */
 BOOL
 OSJoinThread(OSThread *thread,
              int *threadResult);
 
-void
-OSPrintCurrentThreadState();
 
+/**
+ * Resumes a thread.
+ *
+ * Decrements the thread's suspend counter, if the counter reaches 0 the thread
+ * is resumed.
+ *
+ * \returns Returns the previous value of the suspend counter.
+ */
 int32_t
 OSResumeThread(OSThread *thread);
 
+
+/**
+ * Run a function on an already created thread.
+ *
+ * Can only be used on idle threads.
+ */
 BOOL
 OSRunThread(OSThread *thread,
             OSThreadEntryPointFn entry,
             int argc,
             const char **argv);
 
+
+/**
+ * Set a thread's affinity.
+ */
 BOOL
 OSSetThreadAffinity(OSThread *thread,
                     uint32_t affinity);
 
+
+/**
+ * Set a thread's cancellation state.
+ *
+ * If the state is TRUE then the thread can be suspended or cancelled when
+ * OSTestThreadCancel is called.
+ */
 BOOL
 OSSetThreadCancelState(BOOL state);
 
+
+/**
+ * Set the callback to be called just before a thread is terminated.
+ */
 OSThreadCleanupCallbackFn
 OSSetThreadCleanupCallback(OSThread *thread,
                            OSThreadCleanupCallbackFn callback);
 
+
+/**
+ * Set the callback to be called just after a thread is terminated.
+ */
 OSThreadDeallocatorFn
 OSSetThreadDeallocator(OSThread *thread,
                        OSThreadDeallocatorFn deallocator);
 
+
+/**
+ * Set a thread's name.
+ */
 void
 OSSetThreadName(OSThread *thread,
                 const char *name);
 
+
+/**
+ * Set a thread's priority.
+ */
 BOOL
 OSSetThreadPriority(OSThread *thread,
                     int32_t priority);
 
+
+/**
+ * Set a thread's run quantum.
+ *
+ * This is the maximum amount of time the thread can run for before being forced
+ * to yield.
+ */
 BOOL
 OSSetThreadRunQuantum(OSThread *thread,
                       uint32_t quantum);
 
+/**
+ * Set a thread specific value.
+ *
+ * Can be read with OSGetThreadSpecific.
+ */
 void
 OSSetThreadSpecific(uint32_t id,
                     uint32_t value);
 
+
+/**
+ * Set thread stack usage tracking.
+ */
 BOOL
 OSSetThreadStackUsage(OSThread *thread);
 
+
+/**
+ * Sleep the current thread and add it to a thread queue.
+ *
+ * Will sleep until the thread queue is woken with OSWakeupThread.
+ */
 void
 OSSleepThread(OSThreadQueue *queue);
 
+
+/**
+ * Sleep the current thread for a period of time.
+ */
 void
 OSSleepTicks(OSTime ticks);
 
+
+/**
+ * Suspend a thread.
+ *
+ * Increases a thread's suspend counter, if the counter is >0 then the thread is
+ * suspended.
+ *
+ * \returns Returns the thread's previous suspend counter value
+ */
 uint32_t
 OSSuspendThread(OSThread *thread);
 
+
+/**
+ * Check to see if the current thread should be cancelled or suspended.
+ *
+ * This is implicitly called in:
+ * - OSLockMutex
+ * - OSTryLockMutex
+ * - OSUnlockMutex
+ * - OSAcquireSpinLock
+ * - OSTryAcquireSpinLock
+ * - OSTryAcquireSpinLockWithTimeout
+ * - OSReleaseSpinLock
+ * - OSCancelThread
+ */
 void
 OSTestThreadCancel();
 
+
+/**
+ * Wake up all threads in queue.
+ *
+ * Clears the thread queue.
+ */
 void
 OSWakeupThread(OSThreadQueue *queue);
 
+
+/**
+ * Yield execution to waiting threads with same priority.
+ *
+ * This will never switch to a thread with a lower priority than the current
+ * thread.
+ */
 void
 OSYieldThread();
 
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/rpl/libcoreinit/exports.h b/rpl/libcoreinit/exports.h
index dbc4202..19a789c 100644
--- a/rpl/libcoreinit/exports.h
+++ b/rpl/libcoreinit/exports.h
@@ -218,7 +218,6 @@ EXPORT(OSGetThreadSpecific);
 EXPORT(OSIsThreadSuspended);
 EXPORT(OSIsThreadTerminated);
 EXPORT(OSJoinThread);
-EXPORT(OSPrintCurrentThreadState);
 EXPORT(OSResumeThread);
 EXPORT(OSRunThread);
 EXPORT(OSSetThreadAffinity);