Rename, cleanup and pass on readability

Signed-off-by: Andrew Opalach <andrew@akon.city>

16 files changed, 329 insertions, 328 deletions

diff --git a/src/util/buffer.c b/src/util/buffer.c
index 32a8230..1d343e3 100644
--- a/src/util/buffer.c
+++ b/src/util/buffer.c
@@ -1,58 +1,62 @@
+#include <al/macros.h>
+
 #include "buffer.h"
 
-#define BUFFER_INITIAL_SIZE 128
+#define NNWT_BUFFER_SIZE KB(1)
+#define NNWT_BUFFER_GROW ((size_t)al_grow_step)
 
-void aki_buffer_ensure_space(struct aki_buffer *buf, size_t size)
+void nn_buffer_ensure_space(struct nn_buffer *buf, size_t size)
 {
     if (size > buf->alloc) {
-        if (size < BUFFER_INITIAL_SIZE) buf->alloc = BUFFER_INITIAL_SIZE;
-        else buf->alloc = al_next_power_of_two(size);
-        buf->data = buf->data ? al_realloc(buf->data, buf->alloc) : al_malloc(buf->alloc);
+        buf->alloc = size < NNWT_BUFFER_SIZE ? NNWT_BUFFER_SIZE :
+            (size + NNWT_BUFFER_GROW) & ~NNWT_BUFFER_GROW;
+        buf->data = (u8 *)(buf->data ? al_realloc(buf->data, buf->alloc) : al_malloc(buf->alloc));
     }
 }
 
-void aki_buffer_init(struct aki_buffer *buf)
+void nn_buffer_init(struct nn_buffer *buf)
 {
-    buf->data = NULL;
     buf->size = 0;
     buf->alloc = 0;
+    buf->data = NULL;
 }
 
-size_t aki_buffer_get_size(struct aki_buffer *buf)
+size_t nn_buffer_get_size(struct nn_buffer *buf)
 {
     return buf->size;
 }
 
-void aki_buffer_set_size(struct aki_buffer *buf, size_t size)
+void nn_buffer_set_size(struct nn_buffer *buf, size_t size)
 {
     buf->size = size;
 }
 
-void aki_buffer_write(struct aki_buffer *buf, void *data, size_t index, size_t size)
+void nn_buffer_write(struct nn_buffer *buf, void *data, size_t index, size_t size)
 {
     size_t reach = index + size;
-    aki_buffer_ensure_space(buf, reach);
-    if (reach > buf->size) buf->size = reach;
+    nn_buffer_ensure_space(buf, reach);
+    if (reach > buf->size)
+        buf->size = reach;
     al_memcpy(&buf->data[index], data, size);
 }
 
-void aki_buffer_append(struct aki_buffer *buf, void *data, size_t size)
+void nn_buffer_append(struct nn_buffer *buf, void *data, size_t size)
 {
-    aki_buffer_write(buf, data, buf->size, size);
+    nn_buffer_write(buf, data, buf->size, size);
 }
 
-u8 *aki_buffer_get_ptr(struct aki_buffer *buf, size_t index)
+u8 *nn_buffer_get_ptr(struct nn_buffer *buf, size_t index)
 {
     return &buf->data[index];
 }
 
-void aki_buffer_read(struct aki_buffer *buf, void *ptr, size_t index, size_t size)
+void nn_buffer_read(struct nn_buffer *buf, void *ptr, size_t index, size_t size)
 {
     al_assert(index + size <= buf->size);
     al_memcpy(ptr, &buf->data[index], size);
 }
 
-void aki_buffer_free(struct aki_buffer *buf)
+void nn_buffer_free(struct nn_buffer *buf)
 {
     if (buf->data && buf->alloc > 0) al_free(buf->data);
 }
diff --git a/src/util/buffer.h b/src/util/buffer.h
index 78d32d5..612aae4 100644
--- a/src/util/buffer.h
+++ b/src/util/buffer.h
@@ -3,18 +3,18 @@
 #include <al/types.h>
 #include <al/lib.h>
 
-struct aki_buffer {
-    u8 *data;
+struct nn_buffer {
     size_t size;
     size_t alloc;
+    u8 *data;
 };
 
-void aki_buffer_init(struct aki_buffer *buf);
-void aki_buffer_ensure_space(struct aki_buffer *buf, size_t size);
-size_t aki_buffer_get_size(struct aki_buffer *buf);
-void aki_buffer_set_size(struct aki_buffer *buf, size_t size);
-void aki_buffer_write(struct aki_buffer *buf, void *data, size_t index, size_t size);
-void aki_buffer_append(struct aki_buffer *buf, void *data, size_t size);
-u8 *aki_buffer_get_ptr(struct aki_buffer *buf, size_t index);
-void aki_buffer_read(struct aki_buffer *buf, void *ptr, size_t index, size_t size);
-void aki_buffer_free(struct aki_buffer *buf);
+void nn_buffer_init(struct nn_buffer *buf);
+void nn_buffer_ensure_space(struct nn_buffer *buf, size_t size);
+size_t nn_buffer_get_size(struct nn_buffer *buf);
+void nn_buffer_set_size(struct nn_buffer *buf, size_t size);
+void nn_buffer_write(struct nn_buffer *buf, void *data, size_t index, size_t size);
+void nn_buffer_append(struct nn_buffer *buf, void *data, size_t size);
+u8 *nn_buffer_get_ptr(struct nn_buffer *buf, size_t index);
+void nn_buffer_read(struct nn_buffer *buf, void *ptr, size_t index, size_t size);
+void nn_buffer_free(struct nn_buffer *buf);
diff --git a/src/util/error.c b/src/util/error.c
index c75696d..928e083 100644
--- a/src/util/error.c
+++ b/src/util/error.c
@@ -1,3 +1,3 @@
 #include "error.h"
 
-__thread char errorbuf[AKI_ERROR_STR_MAXLEN];
+__thread char errorbuf[NNWT_ERROR_STR_MAXLEN];
diff --git a/src/util/error.h b/src/util/error.h
index 7f63aee..898119c 100644
--- a/src/util/error.h
+++ b/src/util/error.h
@@ -4,20 +4,20 @@
 
 #include <errno.h>
 
-#define AKI_ERROR_STR_MAXLEN 94
+#define NNWT_ERROR_STR_MAXLEN 94
 
-extern __thread char errorbuf[AKI_ERROR_STR_MAXLEN];
+extern __thread char errorbuf[NNWT_ERROR_STR_MAXLEN];
 
-static inline char *aki_strerror(s32 errnum)
+static inline char *nn_strerror(s32 errnum)
 {
 #ifndef _WIN32
 #if (_POSIX_C_SOURCE >= 200112L) && ! _GNU_SOURCE
-    if (strerror_r(errnum, errorbuf, AKI_ERROR_STR_MAXLEN) != 0) errorbuf[0] = '\0';
+    if (strerror_r(errnum, errorbuf, NNWT_ERROR_STR_MAXLEN) != 0) errorbuf[0] = '\0';
 #else
-    return strerror_r(errnum, errorbuf, AKI_ERROR_STR_MAXLEN);
+    return strerror_r(errnum, errorbuf, NNWT_ERROR_STR_MAXLEN);
 #endif
 #else
-    strerror_s(errorbuf, AKI_ERROR_STR_MAXLEN, errnum);
+    strerror_s(errorbuf, NNWT_ERROR_STR_MAXLEN, errnum);
 #endif
     return errorbuf;
 }
diff --git a/src/util/file/file.h b/src/util/file/file.h
index 0544d3c..30b44b6 100644
--- a/src/util/file/file.h
+++ b/src/util/file/file.h
@@ -3,7 +3,7 @@
 #include <al/str.h>
 #include <al/lib.h>
 
-#ifdef AKIYO_FILE_STDIO_COMPAT
+#ifdef NAUNET_NEEDS_STDIO_ASSIST
 #include <stdio.h>
 #else
 #ifndef _WIN32
@@ -16,76 +16,73 @@
 #endif
 
 enum {
-    AKI_FILE_READONLY = 1,
-    AKI_FILE_CREATE = 1 << 1,
-    AKI_FILE_LOCK = 1 << 2
+    NNWT_FILE_READONLY = 1,
+    NNWT_FILE_CREATE = 1 << 1,
+    NNWT_FILE_LOCK = 1 << 2
 };
 
 enum {
-    AKI_ENTRY_FILE = 0,
-    AKI_ENTRY_DIR,
-    AKI_ENTRY_OTHER
+    NNWT_ENTRY_FILE = 0,
+    NNWT_ENTRY_DIR,
+    NNWT_ENTRY_OTHER
 };
 
-struct aki_file {
-#ifdef AKIYO_FILE_STDIO_COMPAT
+struct nn_file {
+#ifdef NAUNET_NEEDS_STDIO_ASSIST
     FILE *file;
 #else
 #ifndef _WIN32
     s32 fd;
 #else
-    // WINDOWS
 #endif
     bool locked;
 #endif
     size_t filesize;
 };
 
-struct aki_dir {
-#ifdef AKIYO_FILE_STDIO_COMPAT
+struct nn_dir {
+#ifdef NAUNET_NEEDS_STDIO_ASSIST
 #else
 #ifndef _WIN32
     DIR *dir;
 #else
-    // WINDOWS
 #endif
 #endif
     str path;
 };
 
-struct aki_dir_entry {
+struct nn_dir_entry {
     u8 type;
-#ifdef AKIYO_FILE_STDIO_COMPAT
+#ifdef NAUNET_NEEDS_STDIO_ASSIST
 #else
 #ifndef _WIN32
     struct dirent *entry;
 #else
-    // WINDOWS
 #endif
 #endif
     str name;
     str path;
 };
 
-bool aki_file_open(struct aki_file *file, str *path, s32 flags);
-bool aki_file_exists(str *path);
-bool aki_file_create(str *path);
-bool aki_file_truncate(struct aki_file *file, off_t size);
-off_t aki_file_seek(struct aki_file *file, off_t offset, s32 whence);
-size_t aki_file_get_filesize(struct aki_file *file);
-bool aki_file_write(struct aki_file *file, void *buf, size_t size);
-bool aki_file_read(struct aki_file *file, void *buf, size_t size);
-s32 aki_file_read_as_str(struct aki_file *file, str *out);
-s32 aki_file_read_as_c_str(struct aki_file *file, char **out);
-s32 aki_file_replace(struct aki_file *file, str *buf);
-void *aki_file_mmap(struct aki_file *file);
-void *aki_file_mremap(struct aki_file *file, size_t size, void *old_map);
-void aki_file_munmap(struct aki_file *file, void *map);
-void aki_file_close(struct aki_file *file);
+bool nn_file_open(struct nn_file *file, str *path, s32 flags);
+bool nn_file_exists(str *path);
+bool nn_file_create(str *path);
+bool nn_file_truncate(struct nn_file *file, off_t size);
+off_t nn_file_seek(struct nn_file *file, off_t offset, s32 whence);
+size_t nn_file_get_filesize(struct nn_file *file);
+bool nn_file_write(struct nn_file *file, void *buf, size_t size);
+bool nn_file_read(struct nn_file *file, void *buf, size_t size);
+s32 nn_file_read_as_str(struct nn_file *file, str *out);
+s32 nn_file_read_as_c_str(struct nn_file *file, char **out);
+s32 nn_file_replace(struct nn_file *file, str *buf);
+void *nn_file_mmap(struct nn_file *file);
+void *nn_file_mremap(struct nn_file *file, size_t size, void *old_map);
+void nn_file_munmap(struct nn_file *file, void *map);
+void nn_file_close(struct nn_file *file);
 
-bool aki_dir_open(struct aki_dir *dir, str *path);
-void aki_dir_close(struct aki_dir *dir);
-bool aki_dir_exists(str *path);
-bool aki_dir_create(str *path);
-bool aki_dir_read(struct aki_dir *dir, struct aki_dir_entry *entry);
-void aki_dir_entry_free(struct aki_dir_entry *entry);
+bool nn_dir_open(struct nn_dir *dir, str *path);
+void nn_dir_close(struct nn_dir *dir);
+bool nn_dir_exists(str *path);
+bool nn_dir_create(str *path);
+bool nn_dir_read(struct nn_dir *dir, struct nn_dir_entry *entry);
+void nn_dir_entry_free(struct nn_dir_entry *entry);
diff --git a/src/util/file/file_linux.c b/src/util/file/file_linux.c
index 977853c..9c6b1ce 100644
--- a/src/util/file/file_linux.c
+++ b/src/util/file/file_linux.c
@@ -9,7 +9,7 @@ static bool lock_file_internal(s32 fd, size_t size)
 {
     struct flock l = { .l_type = F_WRLCK, .l_whence = SEEK_SET, .l_start = 0, .l_len = size };
     if (fcntl(fd, F_SETLKW, &l) == -1) {
-        al_log_error("file", "fcntl(F_SETLKW, F_WRLCK) failed (%s).", aki_strerror(errno));
+        al_log_error("file", "fcntl(F_SETLKW, F_WRLCK) failed (%s).", nn_strerror(errno));
         close(fd);
         return false;
     }
@@ -20,41 +20,46 @@ static bool unlock_file_internal(s32 fd, size_t size)
 {
     struct flock l = { .l_type = F_ULOCK, .l_whence = SEEK_SET, .l_start = 0, .l_len = size };
     if (fcntl(fd, F_SETLKW, &l) == -1) {
-        al_log_error("file", "fcntl(F_SETLKW, F_ULOCK) failed (%s).", aki_strerror(errno));
+        al_log_error("file", "fcntl(F_SETLKW, F_ULOCK) failed (%s).", nn_strerror(errno));
         return false;
     }
     return true;
 }
 
-bool aki_file_open(struct aki_file *file, str *path, s32 flags)
+bool nn_file_open(struct nn_file *file, str *path, s32 flags)
 {
-    al_assert(!((flags & AKI_FILE_READONLY) && (flags & AKI_FILE_LOCK)));
+    al_assert(!((flags & NNWT_FILE_READONLY) && (flags & NNWT_FILE_LOCK)));
+    s32 oflags = flags & NNWT_FILE_READONLY ? O_RDONLY : O_RDWR;
+    if (flags & NNWT_FILE_CREATE)
+        oflags |= O_CREAT;
+
     char *c_str = al_str_to_c_str(path);
-    s32 oflags = (flags & AKI_FILE_READONLY) ? O_RDONLY : O_RDWR;
-    if (flags & AKI_FILE_CREATE) oflags |= O_CREAT;
     file->fd = open(c_str, oflags, 0644);
     al_free(c_str);
     if (file->fd == -1) {
-        al_log_error("file", "open(%.*s) failed (%d: %s).", AL_STR_PRINTF(path), errno, aki_strerror(errno));
+        al_log_error("file", "open(%.*s) failed (%d: %s).", AL_STR_PRINTF(path), errno, nn_strerror(errno));
         return false;
     }
+
     struct stat sb;
     s32 res = fstat(file->fd, &sb);
     if (res == -1) {
-        al_log_error("file", "fstat() failed (%s).", aki_strerror(errno));
+        al_log_error("file", "fstat() failed (%s).", nn_strerror(errno));
         close(file->fd);
         return false;
     }
     file->filesize = sb.st_size;
-    if (flags & AKI_FILE_LOCK) {
-        file->locked = lock_file_internal(file->fd, file->filesize);
-    } else {
-        file->locked = false;
+
+    file->locked = flags & NNWT_FILE_LOCK;
+    if (file->locked && !lock_file_internal(file->fd, file->filesize)) {
+        close(file->fd);
+        return false;
     }
+
     return true;
 }
 
-bool aki_file_exists(str *path)
+bool nn_file_exists(str *path)
 {
     char *c_str = al_str_to_c_str(path);
     s32 ret = access(c_str, F_OK);
@@ -62,37 +67,36 @@ bool aki_file_exists(str *path)
     return ret == 0;
 }
 
-bool aki_file_create(str *path)
+bool nn_file_create(str *path)
 {
-    struct aki_file file;
-    if (aki_file_open(&file, path, AKI_FILE_CREATE)) {
-        aki_file_close(&file);
+    struct nn_file file;
+    if (nn_file_open(&file, path, NNWT_FILE_CREATE)) {
+        nn_file_close(&file);
         return true;
     }
     return false;
 }
 
-off_t aki_file_seek(struct aki_file *file, off_t offset, s32 whence)
+off_t nn_file_seek(struct nn_file *file, off_t offset, s32 whence)
 {
     off_t res = lseek(file->fd, offset, whence);
-    if (res == (off_t)-1) {
-        al_log_error("file", "lseek(%jd, %d) failed (%s).", (intmax_t)offset, whence, aki_strerror(errno));
-    }
+    if (res == (off_t)-1)
+        al_log_error("file", "lseek(%jd, %d) failed (%s).", (intmax_t)offset, whence, nn_strerror(errno));
     return res;
 }
 
-bool aki_file_truncate(struct aki_file *file, off_t size)
+bool nn_file_truncate(struct nn_file *file, off_t size)
 {
     s32 ret = ftruncate(file->fd, size);
     if (ret != 0) {
-        al_log_error("file", "ftruncate(%jd) failed (%s).", (intmax_t)size, aki_strerror(errno));
+        al_log_error("file", "ftruncate(%jd) failed (%s).", (intmax_t)size, nn_strerror(errno));
         return false;
     }
     file->filesize = size;
     return true;
 }
 
-size_t aki_file_get_filesize(struct aki_file *file)
+size_t nn_file_get_filesize(struct nn_file *file)
 {
     return file->filesize;
 }
@@ -100,140 +104,136 @@ size_t aki_file_get_filesize(struct aki_file *file)
 #define file_io_loop(call, fail_case) \
     size_t bc = 0; \
     ssize_t res; \
-    do { \
+    for (;;) { \
         res = call(file->fd, buf, size - bc); \
         if (fail_case) { \
-            al_log_error("file", ""#call"() failed (%s).", aki_strerror(errno)); \
+            al_log_error("file", ""#call"() failed (%s).", nn_strerror(errno)); \
             return false; \
         } \
-        bc += res; \
-    } while (bc < size); \
+        if ((bc += res) >= size) break; \
+    } \
     return true
 
-bool aki_file_write(struct aki_file *file, void *buf, size_t size)
+bool nn_file_write(struct nn_file *file, void *buf, size_t size)
 {
     file_io_loop(write, (res == -1));
 }
 
-bool aki_file_read(struct aki_file *file, void *buf, size_t size)
+bool nn_file_read(struct nn_file *file, void *buf, size_t size)
 {
     file_io_loop(read, (res == -1));
 }
 
-void *aki_file_mmap(struct aki_file *file)
+void *nn_file_mmap(struct nn_file *file)
 {
     void *map = mmap(NULL, file->filesize, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd, 0L);
     if (map == MAP_FAILED) {
-        al_log_error("file", "mmap() failed (%s).", aki_strerror(errno));
+        al_log_error("file", "mmap() failed (%s).", nn_strerror(errno));
         return NULL;
     }
     return map;
 }
 
-void *aki_file_mremap(struct aki_file *file, size_t size, void *old_map)
+void *nn_file_mremap(struct nn_file *file, size_t size, void *old_map)
 {
     void *map = mremap(old_map, file->filesize, size, MREMAP_MAYMOVE);
     if (map == MAP_FAILED) {
-        al_log_error("file", "mremap(%p, %zu, %zu) failed (%s).", old_map,
-            file->filesize, size, aki_strerror(errno));
+        al_log_error("file", "mremap(%p, %zu, %zu) failed (%s).",
+            old_map, file->filesize, size, nn_strerror(errno));
         return NULL;
     }
     return map;
 }
 
-void aki_file_munmap(struct aki_file *file, void *map)
+void nn_file_munmap(struct nn_file *file, void *map)
 {
     s32 ret = munmap(map, file->filesize);
-    if (ret != 0) {
-        al_log_error("file", "munmap(%p, %zu) failed (%s).", map, file->filesize, aki_strerror(errno));
-    }
+    if (ret != 0)
+        al_log_error("file", "munmap(%p, %zu) failed (%s).", map, file->filesize, nn_strerror(errno));
 }
 
-void aki_file_close(struct aki_file *file)
+void nn_file_close(struct nn_file *file)
 {
-    if (file->locked) {
-        unlock_file_internal(file->fd, file->filesize);
-    }
+    if (file->locked) unlock_file_internal(file->fd, file->filesize);
     close(file->fd);
 }
 
-bool aki_dir_open(struct aki_dir *dir, str *path)
+bool nn_dir_open(struct nn_dir *dir, str *path)
 {
     char *c_str = al_str_to_c_str(path);
     dir->dir = opendir(c_str);
     al_free(c_str);
     if (!dir->dir) {
-        al_log_error("file", "opendir(%.*s) failed (%s).", AL_STR_PRINTF(path), aki_strerror(errno));
+        al_log_error("file", "opendir(%.*s) failed (%s).", AL_STR_PRINTF(path), nn_strerror(errno));
         return false;
     }
     al_str_clone(&dir->path, path);
     return true;
 }
 
-void aki_dir_close(struct aki_dir *dir)
+void nn_dir_close(struct nn_dir *dir)
 {
     al_str_free(&dir->path);
     closedir(dir->dir);
 }
 
-bool aki_dir_exists(str *path)
+bool nn_dir_exists(str *path)
 {
-    struct aki_dir dir;
+    struct nn_dir dir;
     char *c_str = al_str_to_c_str(path);
     dir.dir = opendir(c_str);
     al_free(c_str);
     if (!dir.dir) {
-        if (errno != ENOENT) {
-            al_log_error("file", "opendir(%.*s) failed (%s).", AL_STR_PRINTF(path), aki_strerror(errno));
-        }
+        if (errno != ENOENT)
+            al_log_error("file", "opendir(%.*s) failed (%s).", AL_STR_PRINTF(path), nn_strerror(errno));
         return false;
     }
     closedir(dir.dir);
     return true;
 }
 
-bool aki_dir_create(str *path)
+bool nn_dir_create(str *path)
 {
     char *c_str = al_str_to_c_str(path);
     s32 ret = mkdir(c_str, 0755);
     al_free(c_str);
     if (ret == -1) {
-        al_log_error("file", "mkdir(%.*s) failed (%s).", AL_STR_PRINTF(path), aki_strerror(errno));
+        al_log_error("file", "mkdir(%.*s) failed (%s).", AL_STR_PRINTF(path), nn_strerror(errno));
         return false;
     }
     return true;
 }
 
-bool aki_dir_read(struct aki_dir *dir, struct aki_dir_entry *entry)
+bool nn_dir_read(struct nn_dir *dir, struct nn_dir_entry *entry)
 {
-    errno = 0;
-    entry->entry = readdir(dir->dir);
-    if (!entry->entry) {
-        if (errno) {
-            al_log_error("file", "readdir() failed (%s).", aki_strerror(errno));
-        }
+    if (!(entry->entry = readdir(dir->dir))) {
+        if (errno)
+            al_log_error("file", "readdir() failed (%s).", nn_strerror(errno));
         return false;
     }
+
     switch (entry->entry->d_type) {
-    case DT_REG:
     case DT_UNKNOWN:
-        entry->type = AKI_ENTRY_FILE;
+        entry->type = NNWT_ENTRY_FILE;
         break;
+    case DT_REG:
     case DT_DIR:
-        entry->type = AKI_ENTRY_DIR;
+        entry->type = NNWT_ENTRY_DIR;
         break;
     default:
-        entry->type = AKI_ENTRY_OTHER;
+        entry->type = NNWT_ENTRY_OTHER;
         break;
     }
+
     al_str_clone(&entry->name, al_str_cr(entry->entry->d_name));
     al_str_clone(&entry->path, &dir->path);
     al_str_cat(&entry->path, al_str_c("/"));
     al_str_cat(&entry->path, &entry->name);
+
     return true;
 }
 
-void aki_dir_entry_free(struct aki_dir_entry *entry)
+void nn_dir_entry_free(struct nn_dir_entry *entry)
 {
     al_str_free(&entry->name);
     al_str_free(&entry->path);
diff --git a/src/util/file/file_stdio.c b/src/util/file/file_stdio.c
index fa1e4ff..8f6d7ae 100644
--- a/src/util/file/file_stdio.c
+++ b/src/util/file/file_stdio.c
@@ -4,10 +4,10 @@
 
 #include "file.h"
 
-bool aki_file_open(struct aki_file *file, str *path, s32 flags)
+bool nn_file_open(struct nn_file *file, str *path, s32 flags)
 {
+    const char *mode = flags & NNWT_FILE_CREATE ? "wb+" : "rb+";
     char *c_str = al_str_to_c_str(path);
-    const char *mode = (flags & AKI_FILE_CREATE) ? "wb+" : "rb+";
 #ifndef _WIN32
     file->file = fopen(c_str, mode);
 #else
@@ -19,82 +19,84 @@ bool aki_file_open(struct aki_file *file, str *path, s32 flags)
 #else
     if (ret != 0) {
 #endif
-        al_log_error("file_stdio", "fopen(%.*s) failed (%s).", AL_STR_PRINTF(path), aki_strerror(errno));
+        al_log_error("file_stdio", "fopen(%.*s) failed (%s).", AL_STR_PRINTF(path), nn_strerror(errno));
         return false;
     }
-    off_t pos = aki_file_seek(file, 0, SEEK_END);
+
+    off_t pos = nn_file_seek(file, 0, SEEK_END);
     if (pos == -1) {
-        aki_file_close(file);
+        nn_file_close(file);
         return false;
     }
     file->filesize = pos;
     rewind(file->file);
+
     return true;
 }
 
-bool aki_file_exists(str *path)
+bool nn_file_exists(str *path)
 {
     (void)path;
     return false;
 }
 
-off_t aki_file_seek(struct aki_file *file, off_t offset, s32 whence)
+off_t nn_file_seek(struct nn_file *file, off_t offset, s32 whence)
 {
     if (fseek(file->file, offset, whence) != 0) {
-        al_log_error("file_stdio", "fseek(%jd, %d) failed (%s).", (intmax_t)offset,
-            whence, aki_strerror(errno));
+        al_log_error("file_stdio", "fseek(%jd, %d) failed (%s).",
+            (intmax_t)offset, whence, nn_strerror(errno));
         return -1;
     }
     return ftell(file->file);
 }
 
-bool aki_file_truncate(struct aki_file *file, off_t size)
+bool nn_file_truncate(struct nn_file *file, off_t size)
 {
     (void)file;
     (void)size;
     return true;
 }
 
-size_t aki_file_get_filesize(struct aki_file *file)
+size_t nn_file_get_filesize(struct nn_file *file)
 {
     return file->filesize;
 }
 
-bool aki_file_write(struct aki_file *file, void *buf, size_t size)
+bool nn_file_write(struct nn_file *file, void *buf, size_t size)
 {
     size_t ret = fwrite(buf, size, 1, file->file);
     if (ret == 0) {
-        al_log_error("file_stdio", "fwrite(%zu) failed (%s).", size, aki_strerror(errno));
+        al_log_error("file_stdio", "fwrite(%zu) failed (%s).", size, nn_strerror(errno));
         return false;
     }
     return true;
 }
 
-bool aki_file_read(struct aki_file *file, void *buf, size_t size)
+bool nn_file_read(struct nn_file *file, void *buf, size_t size)
 {
     size_t ret = fread(buf, size, 1, file->file);
     if (ret == 0) {
-        al_log_error("file_stdio", "fread(%zu) failed (%s).", size, aki_strerror(errno));
+        al_log_error("file_stdio", "fread(%zu) failed (%s).", size, nn_strerror(errno));
         return false;
     }
     return true;
 }
 
-void *aki_file_mmap(struct aki_file *file)
+void *nn_file_mmap(struct nn_file *file)
 {
     (void)file;
     al_assert(false);
     return NULL;
 }
 
-void aki_file_close(struct aki_file *file)
+void nn_file_close(struct nn_file *file)
 {
     fclose(file->file);
 }
 
-bool aki_dir_open(struct aki_dir *dir, str *path) { (void)dir; (void)path; return false; }
-void aki_dir_close(struct aki_dir *dir) { (void)dir; }
-bool aki_dir_exists(str *path) { (void)path; return false; }
-bool aki_dir_create(str *path) { (void)path; return false; }
-bool aki_dir_read(struct aki_dir *dir, struct aki_dir_entry *entry) { (void)dir; (void)entry; return false; }
-void aki_dir_entry_free(struct aki_dir_entry *entry) { (void)entry; }
+bool nn_dir_open(struct nn_dir *dir, str *path) { (void)dir; (void)path; return false; }
+void nn_dir_close(struct nn_dir *dir) { (void)dir; }
+bool nn_dir_exists(str *path) { (void)path; return false; }
+bool nn_dir_create(str *path) { (void)path; return false; }
+bool nn_dir_read(struct nn_dir *dir, struct nn_dir_entry *entry) { (void)dir; (void)entry; return false; }
+void nn_dir_entry_free(struct nn_dir_entry *entry) { (void)entry; }
diff --git a/src/util/file/util.c b/src/util/file/util.c
index fe7785f..50e2c4a 100644
--- a/src/util/file/util.c
+++ b/src/util/file/util.c
@@ -1,10 +1,10 @@
 #include "file.h"
 
-s32 aki_file_read_as_str(struct aki_file *file, str *out)
+s32 nn_file_read_as_str(struct nn_file *file, str *out)
 {
     size_t size = file->filesize;
     al_str_sized(out, size);
-    if (!aki_file_read(file, (void *)out->data, size)) {
+    if (!nn_file_read(file, (void *)out->data, size)) {
         al_str_free(out);
         return -1;
     }
@@ -12,11 +12,11 @@ s32 aki_file_read_as_str(struct aki_file *file, str *out)
     return size;
 }
 
-s32 aki_file_read_as_c_str(struct aki_file *file, char **out)
+s32 nn_file_read_as_c_str(struct nn_file *file, char **out)
 {
     size_t size = file->filesize;
     *out = al_malloc(size + 1);
-    if (!aki_file_read(file, (void *)*out, size)) {
+    if (!nn_file_read(file, (void *)*out, size)) {
         al_free(*out);
         return -1;
     }
@@ -24,11 +24,11 @@ s32 aki_file_read_as_c_str(struct aki_file *file, char **out)
     return size;
 }
 
-s32 aki_file_replace(struct aki_file *file, str *buf)
+s32 nn_file_replace(struct nn_file *file, str *buf)
 {
-    if (aki_file_seek(file, 0, SEEK_SET) == (off_t)-1 ||
-        !aki_file_write(file, buf->data, buf->len) ||
-        !aki_file_truncate(file, buf->len)) {
+    if (nn_file_seek(file, 0, SEEK_SET) == (off_t)-1 ||
+        !nn_file_write(file, buf->data, buf->len) ||
+        !nn_file_truncate(file, buf->len)) {
         return -1;
     }
     return buf->len;
diff --git a/src/util/packet.c b/src/util/packet.c
index 2658d38..900016c 100644
--- a/src/util/packet.c
+++ b/src/util/packet.c
@@ -1,44 +1,44 @@
 #include "packet.h"
 
-struct aki_packet *aki_packet_create(void)
+struct nn_packet *nn_packet_create(void)
 {
-    struct aki_packet *packet = (struct aki_packet *)al_malloc(sizeof(struct aki_packet));
-    aki_buffer_init(&packet->buffer);
-    aki_packet_reset(packet);
+    struct nn_packet *packet = (struct nn_packet *)al_malloc(sizeof(struct nn_packet));
+    nn_buffer_init(&packet->buffer);
+    nn_packet_reset(packet);
     return packet;
 }
 
-struct aki_packet *aki_packet_clone(struct aki_packet *packet)
+struct nn_packet *nn_packet_clone(struct nn_packet *packet)
 {
-    struct aki_packet *c = aki_packet_create();
-    aki_buffer_ensure_space(&c->buffer, packet->buffer.size);
-    al_memcpy(aki_buffer_get_ptr(&c->buffer, 0), aki_buffer_get_ptr(&packet->buffer, 0), packet->buffer.size);
+    struct nn_packet *c = nn_packet_create();
+    nn_buffer_ensure_space(&c->buffer, packet->buffer.size);
+    al_memcpy(nn_buffer_get_ptr(&c->buffer, 0), nn_buffer_get_ptr(&packet->buffer, 0), packet->buffer.size);
     c->windex = packet->windex;
     c->rindex = packet->rindex;
     return c;
 }
 
-void aki_packet_reset(struct aki_packet *packet)
+void nn_packet_reset(struct nn_packet *packet)
 {
-    aki_buffer_ensure_space(&packet->buffer, AKI_PACKET_HEADER_LENGTH);
-    packet->rindex = AKI_PACKET_HEADER_LENGTH;
-    packet->windex = AKI_PACKET_HEADER_LENGTH;
+    nn_buffer_ensure_space(&packet->buffer, NNWT_PACKET_HEADER_LENGTH);
+    packet->rindex = NNWT_PACKET_HEADER_LENGTH;
+    packet->windex = NNWT_PACKET_HEADER_LENGTH;
 }
 
-void aki_packet_write_size(struct aki_packet *packet)
+void nn_packet_write_size(struct nn_packet *packet)
 {
-    *((u32 *)aki_buffer_get_ptr(&packet->buffer, 0)) = packet->windex;
+    *((u32 *)nn_buffer_get_ptr(&packet->buffer, 0)) = packet->windex;
 }
 
-u32 aki_packet_get_size(struct aki_packet *packet)
+u32 nn_packet_get_size(struct nn_packet *packet)
 {
-    return *((u32 *)aki_buffer_get_ptr(&packet->buffer, 0));
+    return *((u32 *)nn_buffer_get_ptr(&packet->buffer, 0));
 }
 
 #define DEFINE_PACKET_WRITE_FUNC(type) \
-    void aki_packet_write_##type(struct aki_packet *packet, type v) \
+    void nn_packet_write_##type(struct nn_packet *packet, type v) \
     { \
-        AKI_PACKET_WRITE_TYPE(packet, type, v); \
+        NNWT_PACKET_WRITE_TYPE(packet, type, v); \
     }
 
 DEFINE_PACKET_WRITE_FUNC(bool)
@@ -53,25 +53,25 @@ DEFINE_PACKET_WRITE_FUNC(s64)
 DEFINE_PACKET_WRITE_FUNC(f32)
 DEFINE_PACKET_WRITE_FUNC(f64)
 
-void aki_packet_write_str(struct aki_packet *packet, str *s)
+void nn_packet_write_str(struct nn_packet *packet, str *s)
 {
-    AKI_PACKET_WRITE_TYPE(packet, u32, s->len);
-    AKI_PACKET_WRITE_DATA(packet, s->data, s->len);
+    NNWT_PACKET_WRITE_TYPE(packet, u32, s->len);
+    NNWT_PACKET_WRITE_DATA(packet, s->data, s->len);
 }
 
-void aki_packet_write_buffer(struct aki_packet *packet, struct aki_buffer *buf)
+void nn_packet_write_buffer(struct nn_packet *packet, struct nn_buffer *buf)
 {
     u64 size = (u64)buf->size;
-    AKI_PACKET_WRITE_TYPE(packet, u64, size);
-    AKI_PACKET_WRITE_DATA(packet, aki_buffer_get_ptr(buf, 0), buf->size);
+    NNWT_PACKET_WRITE_TYPE(packet, u64, size);
+    NNWT_PACKET_WRITE_DATA(packet, nn_buffer_get_ptr(buf, 0), buf->size);
 }
 
 #define DEFINE_PACKET_READ_FUNC(type) \
-    type aki_packet_read_##type(struct aki_packet *packet) \
+    type nn_packet_read_##type(struct nn_packet *packet) \
     { \
-      type r; \
-      AKI_PACKET_READ_TYPE(packet, type, r); \
-      return r; \
+        type r; \
+        NNWT_PACKET_READ_TYPE(packet, type, r); \
+        return r; \
     }
 
 DEFINE_PACKET_READ_FUNC(bool)
@@ -86,38 +86,38 @@ DEFINE_PACKET_READ_FUNC(s64)
 DEFINE_PACKET_READ_FUNC(f32)
 DEFINE_PACKET_READ_FUNC(f64)
 
-void aki_packet_read_str(struct aki_packet *packet, str *s)
+void nn_packet_read_str(struct nn_packet *packet, str *s)
 {
-    AKI_PACKET_READ_TYPE(packet, u32, s->len);
-    AKI_PACKET_READ_DATA(packet, s->len, s->data);
+    NNWT_PACKET_READ_TYPE(packet, u32, s->len);
+    NNWT_PACKET_READ_DATA(packet, s->len, s->data);
     s->alloc = 0;
 }
 
-void aki_packet_read_buffer(struct aki_packet *packet, struct aki_buffer *buf)
+void nn_packet_read_buffer(struct nn_packet *packet, struct nn_buffer *buf)
 {
     u64 size;
-    AKI_PACKET_READ_TYPE(packet, u64, size);
+    NNWT_PACKET_READ_TYPE(packet, u64, size);
     al_assert((sizeof(size_t) > 4 || size <= INT32_MAX));
     buf->size = (size_t)size;
-    AKI_PACKET_READ_DATA(packet, buf->size, buf->data);
+    NNWT_PACKET_READ_DATA(packet, buf->size, buf->data);
     buf->alloc = 0;
 }
 
-void aki_packet_write_wstr(struct aki_packet *packet, wstr *w)
+void nn_packet_write_wstr(struct nn_packet *packet, wstr *w)
 {
-    AKI_PACKET_WRITE_TYPE(packet, u32, w->len);
-    AKI_PACKET_WRITE_DATA(packet, w->data, w->len * sizeof(wchar_t));
+    NNWT_PACKET_WRITE_TYPE(packet, u32, w->len);
+    NNWT_PACKET_WRITE_DATA(packet, w->data, w->len * sizeof(wchar_t));
 }
 
-void aki_packet_read_wstr(struct aki_packet *packet, wstr *w)
+void nn_packet_read_wstr(struct nn_packet *packet, wstr *w)
 {
-    AKI_PACKET_READ_TYPE(packet, u32, w->len);
-    AKI_PACKET_READ_DATA(packet, w->len * sizeof(wchar_t), w->data);
+    NNWT_PACKET_READ_TYPE(packet, u32, w->len);
+    NNWT_PACKET_READ_DATA(packet, w->len * sizeof(wchar_t), w->data);
     w->alloc = 0;
 }
 
-void aki_packet_free(struct aki_packet *packet)
+void nn_packet_free(struct nn_packet *packet)
 {
-    aki_buffer_free(&packet->buffer);
+    nn_buffer_free(&packet->buffer);
     al_free(packet);
 }
diff --git a/src/util/packet.h b/src/util/packet.h
index 72543a6..41f0a77 100644
--- a/src/util/packet.h
+++ b/src/util/packet.h
@@ -7,69 +7,69 @@
 
 #include "../util/buffer.h"
 
-#define AKI_PACKET_HEADER_LENGTH (u32)(sizeof(u32))
+#define NNWT_PACKET_HEADER_LENGTH (u32)(sizeof(u32))
 
-struct aki_packet {
-    struct aki_buffer buffer;
+struct nn_packet {
+    struct nn_buffer buffer;
     u32 rindex;
     u32 windex;
 };
 
-#define AKI_PACKET_GET_ID(p) \
-    *((u32 *)aki_buffer_get_ptr(&p->buffer, AKI_PACKET_HEADER_LENGTH + sizeof(s8)))
+#define NNWT_PACKET_GET_ID(p) \
+    *((u32 *)nn_buffer_get_ptr(&p->buffer, NNWT_PACKET_HEADER_LENGTH + sizeof(s8)))
 
-#define AKI_PACKET_WRITE_TYPE(p, type, v) \
-    aki_buffer_write(&(p)->buffer, &(v), (p)->windex, sizeof(type)); \
+#define NNWT_PACKET_WRITE_TYPE(p, type, v) \
+    nn_buffer_write(&(p)->buffer, &(v), (p)->windex, sizeof(type)); \
     (p)->windex += (u32)sizeof(type)
 
-#define AKI_PACKET_WRITE_DATA(p, data, len) \
-    aki_buffer_write(&(p)->buffer, (data), (p)->windex, (len)); \
+#define NNWT_PACKET_WRITE_DATA(p, data, len) \
+    nn_buffer_write(&(p)->buffer, (data), (p)->windex, (len)); \
     (p)->windex += (u32)len
 
-#define AKI_PACKET_READ_TYPE(p, type, r) \
-    r = *((type *)aki_buffer_get_ptr(&(p)->buffer, (p)->rindex)); \
+#define NNWT_PACKET_READ_TYPE(p, type, r) \
+    r = *((type *)nn_buffer_get_ptr(&(p)->buffer, (p)->rindex)); \
     (p)->rindex += (u32)sizeof(type);
 
-#define AKI_PACKET_READ_DATA(p, len, r) \
-    r = (void *)aki_buffer_get_ptr(&(p)->buffer, (p)->rindex);  \
+#define NNWT_PACKET_READ_DATA(p, len, r) \
+    r = (void *)nn_buffer_get_ptr(&(p)->buffer, (p)->rindex);  \
     (p)->rindex += (u32)len;
 
-struct aki_packet *aki_packet_create(void);
-struct aki_packet *aki_packet_clone(struct aki_packet *packet);
-void aki_packet_reset(struct aki_packet *packet);
+struct nn_packet *nn_packet_create(void);
+struct nn_packet *nn_packet_clone(struct nn_packet *packet);
+void nn_packet_reset(struct nn_packet *packet);
 
-void aki_packet_write_size(struct aki_packet *packet);
-u32 aki_packet_get_size(struct aki_packet *packet);
+void nn_packet_write_size(struct nn_packet *packet);
+u32 nn_packet_get_size(struct nn_packet *packet);
 
-void aki_packet_write_bool(struct aki_packet *packet, bool v);
-void aki_packet_write_s8(struct aki_packet *packet, s8 v);
-void aki_packet_write_u8(struct aki_packet *packet, u8 v);
-void aki_packet_write_s16(struct aki_packet *packet, s16 v);
-void aki_packet_write_u16(struct aki_packet *packet, u16 v);
-void aki_packet_write_s32(struct aki_packet *packet, s32 v);
-void aki_packet_write_u32(struct aki_packet *packet, u32 v);
-void aki_packet_write_s64(struct aki_packet *packet, s64 v);
-void aki_packet_write_u64(struct aki_packet *packet, u64 v);
-void aki_packet_write_f32(struct aki_packet *packet, f32 v);
-void aki_packet_write_f64(struct aki_packet *packet, f64 v);
-void aki_packet_write_str(struct aki_packet *packet, str *s);
-void aki_packet_write_buffer(struct aki_packet *packet, struct aki_buffer *buf);
+void nn_packet_write_bool(struct nn_packet *packet, bool v);
+void nn_packet_write_s8(struct nn_packet *packet, s8 v);
+void nn_packet_write_u8(struct nn_packet *packet, u8 v);
+void nn_packet_write_s16(struct nn_packet *packet, s16 v);
+void nn_packet_write_u16(struct nn_packet *packet, u16 v);
+void nn_packet_write_s32(struct nn_packet *packet, s32 v);
+void nn_packet_write_u32(struct nn_packet *packet, u32 v);
+void nn_packet_write_s64(struct nn_packet *packet, s64 v);
+void nn_packet_write_u64(struct nn_packet *packet, u64 v);
+void nn_packet_write_f32(struct nn_packet *packet, f32 v);
+void nn_packet_write_f64(struct nn_packet *packet, f64 v);
+void nn_packet_write_str(struct nn_packet *packet, str *s);
+void nn_packet_write_buffer(struct nn_packet *packet, struct nn_buffer *buf);
 
-bool aki_packet_read_bool(struct aki_packet *packet);
-s8 aki_packet_read_s8(struct aki_packet *packet);
-u8 aki_packet_read_u8(struct aki_packet *packet);
-s16 aki_packet_read_s16(struct aki_packet *packet);
-u16 aki_packet_read_u16(struct aki_packet *packet);
-s32 aki_packet_read_s32(struct aki_packet *packet);
-u32 aki_packet_read_u32(struct aki_packet *packet);
-s64 aki_packet_read_s64(struct aki_packet *packet);
-u64 aki_packet_read_u64(struct aki_packet *packet);
-f32 aki_packet_read_f32(struct aki_packet *packet);
-f64 aki_packet_read_f64(struct aki_packet *packet);
-void aki_packet_read_str(struct aki_packet *packet, str *s);
-void aki_packet_read_buffer(struct aki_packet *packet, struct aki_buffer *buf);
+bool nn_packet_read_bool(struct nn_packet *packet);
+s8 nn_packet_read_s8(struct nn_packet *packet);
+u8 nn_packet_read_u8(struct nn_packet *packet);
+s16 nn_packet_read_s16(struct nn_packet *packet);
+u16 nn_packet_read_u16(struct nn_packet *packet);
+s32 nn_packet_read_s32(struct nn_packet *packet);
+u32 nn_packet_read_u32(struct nn_packet *packet);
+s64 nn_packet_read_s64(struct nn_packet *packet);
+u64 nn_packet_read_u64(struct nn_packet *packet);
+f32 nn_packet_read_f32(struct nn_packet *packet);
+f64 nn_packet_read_f64(struct nn_packet *packet);
+void nn_packet_read_str(struct nn_packet *packet, str *s);
+void nn_packet_read_buffer(struct nn_packet *packet, struct nn_buffer *buf);
 
-void aki_packet_write_wstr(struct aki_packet *packet, wstr *w);
-void aki_packet_read_wstr(struct aki_packet *packet, wstr *w);
+void nn_packet_write_wstr(struct nn_packet *packet, wstr *w);
+void nn_packet_read_wstr(struct nn_packet *packet, wstr *w);
 
-void aki_packet_free(struct aki_packet *packet);
+void nn_packet_free(struct nn_packet *packet);
diff --git a/src/util/thread/thread.h b/src/util/thread/thread.h
index 5975c84..921de23 100644
--- a/src/util/thread/thread.h
+++ b/src/util/thread/thread.h
@@ -8,14 +8,14 @@
 #include "../../winwrap.h"
 #endif
 
-#ifdef AKIYO_HAS_THREAD_CANCEL
+#ifdef NAUNET_HAS_THREAD_CANCEL
 enum {
-    AKI_THREAD_CANCEL_DEFERRED = PTHREAD_CANCEL_DEFERRED,
-    AKI_THREAD_CANCEL_ASYNCHRONOUS = PTHREAD_CANCEL_ASYNCHRONOUS
+    NNWT_THREAD_CANCEL_DEFERRED = PTHREAD_CANCEL_DEFERRED,
+    NNWT_THREAD_CANCEL_ASYNCHRONOUS = PTHREAD_CANCEL_ASYNCHRONOUS
 };
 #endif
 
-struct aki_thread {
+struct nn_thread {
 #ifndef _WIN32
     pthread_t thread;
 #else
@@ -23,7 +23,7 @@ struct aki_thread {
 #endif
 };
 
-struct aki_mutex {
+struct nn_mutex {
 #ifndef _WIN32
     pthread_mutex_t mutex;
 #else
@@ -31,7 +31,7 @@ struct aki_mutex {
 #endif
 };
 
-struct aki_cond {
+struct nn_cond {
 #ifndef _WIN32
     pthread_cond_t cond;
 #else
@@ -40,37 +40,37 @@ struct aki_cond {
     bool condition;
 };
 
-typedef f64 aki_os_tstamp;
+typedef f64 nn_os_tstamp;
 
-#define AKI_TS_FROM_USEC(usec) ((usec) * 1e-6)
+#define NNWT_TS_FROM_USEC(usec) ((usec) * 1e-6)
 
 #ifndef _WIN32
-#define AKI_THREADCALL
-typedef void * aki_thread_result;
+#define NNWT_THREADCALL
+typedef void * nn_thread_result;
 #else
-#define AKI_THREADCALL __stdcall
-typedef unsigned long aki_thread_result;
+#define NNWT_THREADCALL __stdcall
+typedef unsigned long nn_thread_result;
 #endif
 
-typedef aki_thread_result (AKI_THREADCALL * aki_thread_func)(void *);
+typedef nn_thread_result (NNWT_THREADCALL * nn_thread_func)(void *);
 
-void aki_thread_sleep(aki_os_tstamp delay);
+void nn_thread_sleep(nn_os_tstamp delay);
 
-void aki_thread_create(struct aki_thread *thread, aki_thread_func func, void *userdata);
-void aki_thread_join(struct aki_thread *thread);
-#ifdef AKIYO_HAS_THREAD_CANCEL
-void aki_thread_cancel(struct aki_thread *thread);
-void aki_thread_setcanceltype(s32 type);
+void nn_thread_create(struct nn_thread *thread, nn_thread_func func, void *userdata);
+void nn_thread_join(struct nn_thread *thread);
+#ifdef NAUNET_HAS_THREAD_CANCEL
+void nn_thread_cancel(struct nn_thread *thread);
+void nn_thread_setcanceltype(s32 type);
 #endif
-//void aki_thread_detach(struct aki_thread *thread);
+//void nn_thread_detach(struct nn_thread *thread);
 
-void aki_mutex_init(struct aki_mutex *mutex);
-void aki_mutex_lock(struct aki_mutex *mutex);
-void aki_mutex_unlock(struct aki_mutex *mutex);
-void aki_mutex_destroy(struct aki_mutex *mutex);
+void nn_mutex_init(struct nn_mutex *mutex);
+void nn_mutex_lock(struct nn_mutex *mutex);
+void nn_mutex_unlock(struct nn_mutex *mutex);
+void nn_mutex_destroy(struct nn_mutex *mutex);
 
-void aki_cond_init(struct aki_cond *cond);
-void aki_cond_wait(struct aki_cond *cond, struct aki_mutex *mutex);
-bool aki_cond_is_waiting(struct aki_cond *cond);
-void aki_cond_signal(struct aki_cond *cond);
-void aki_cond_destroy(struct aki_cond *cond);
+void nn_cond_init(struct nn_cond *cond);
+void nn_cond_wait(struct nn_cond *cond, struct nn_mutex *mutex);
+bool nn_cond_is_waiting(struct nn_cond *cond);
+void nn_cond_signal(struct nn_cond *cond);
+void nn_cond_destroy(struct nn_cond *cond);
diff --git a/src/util/thread/thread_linux.c b/src/util/thread/thread_linux.c
index 26c3e18..bb5bcbc 100644
--- a/src/util/thread/thread_linux.c
+++ b/src/util/thread/thread_linux.c
@@ -4,7 +4,7 @@
 
 #include "thread.h"
 
-void aki_thread_sleep(aki_os_tstamp delay)
+void nn_thread_sleep(nn_os_tstamp delay)
 {
     struct timespec tv;
     tv.tv_sec = (s64)delay;
@@ -12,81 +12,80 @@ void aki_thread_sleep(aki_os_tstamp delay)
     while (nanosleep(&tv, &tv) == -1 && errno == EINTR) {}
 }
 
-void aki_thread_create(struct aki_thread *thread, aki_thread_func func, void *userdata)
+void nn_thread_create(struct nn_thread *thread, nn_thread_func func, void *userdata)
 {
     pthread_create(&thread->thread, NULL, func, userdata);
 }
 
-void aki_thread_join(struct aki_thread *thread)
+void nn_thread_join(struct nn_thread *thread)
 {
     pthread_join(thread->thread, NULL);
 }
 
-#ifdef AKIYO_HAS_THREAD_CANCEL
-void aki_thread_cancel(struct aki_thread *thread)
+#ifdef NAUNET_HAS_THREAD_CANCEL
+void nn_thread_cancel(struct nn_thread *thread)
 {
     pthread_cancel(thread->thread);
 }
 
-void aki_thread_setcanceltype(s32 type)
+void nn_thread_setcanceltype(s32 type)
 {
     pthread_setcanceltype(type, NULL);
 }
 #endif
 
 /*
-void aki_thread_detach(struct aki_thread *thread)
+void nn_thread_detach(struct nn_thread *thread)
 {
     pthread_detach(thread->thread);
 }
 */
 
-void aki_mutex_init(struct aki_mutex *mutex)
+void nn_mutex_init(struct nn_mutex *mutex)
 {
     pthread_mutex_init(&mutex->mutex, NULL);
 }
 
-void aki_mutex_lock(struct aki_mutex *mutex)
+void nn_mutex_lock(struct nn_mutex *mutex)
 {
     pthread_mutex_lock(&mutex->mutex);
 }
 
-void aki_mutex_unlock(struct aki_mutex *mutex)
+void nn_mutex_unlock(struct nn_mutex *mutex)
 {
     pthread_mutex_unlock(&mutex->mutex);
 }
 
-void aki_mutex_destroy(struct aki_mutex *mutex)
+void nn_mutex_destroy(struct nn_mutex *mutex)
 {
     pthread_mutex_destroy(&mutex->mutex);
 }
 
-void aki_cond_init(struct aki_cond *cond)
+void nn_cond_init(struct nn_cond *cond)
 {
     cond->condition = true;
     pthread_cond_init(&cond->cond, NULL);
 }
 
-void aki_cond_wait(struct aki_cond *cond, struct aki_mutex *mutex)
+void nn_cond_wait(struct nn_cond *cond, struct nn_mutex *mutex)
 {
     cond->condition = false;
-    while (!cond->condition) {
+    while (!cond->condition)
         pthread_cond_wait(&cond->cond, &mutex->mutex);
-    }
 }
 
-bool aki_cond_is_waiting(struct aki_cond *cond)
+bool nn_cond_is_waiting(struct nn_cond *cond)
 {
     return !cond->condition;
 }
 
-void aki_cond_signal(struct aki_cond *cond)
+void nn_cond_signal(struct nn_cond *cond)
 {
     cond->condition = true;
     pthread_cond_signal(&cond->cond);
 }
 
-void aki_cond_destroy(struct aki_cond *cond)
+void nn_cond_destroy(struct nn_cond *cond)
 {
     pthread_cond_destroy(&cond->cond);
 }
diff --git a/src/util/thread/thread_windows.c b/src/util/thread/thread_windows.c
index c7fdd62..ded3b6c 100644
--- a/src/util/thread/thread_windows.c
+++ b/src/util/thread/thread_windows.c
@@ -2,86 +2,85 @@
 
 NTSTATUS(__stdcall *NtDelayExecution)(BOOL Alertable, PLARGE_INTEGER DelayInterval);
 
-void aki_thread_sleep(aki_os_tstamp delay)
+void nn_thread_sleep(nn_os_tstamp delay)
 {
     NtDelayExecution(false, &((LARGE_INTEGER){ .QuadPart = -(s64)(delay * 1e7L) }));
 }
 
-void aki_thread_create(struct aki_thread *thread, aki_thread_func func, void *userdata)
+void nn_thread_create(struct nn_thread *thread, nn_thread_func func, void *userdata)
 {
     thread->thread = CreateThread(NULL, 0, func, userdata, 0, NULL);
 }
 
-void aki_thread_join(struct aki_thread *thread)
+void nn_thread_join(struct nn_thread *thread)
 {
     WaitForSingleObject(thread->thread, INFINITE);
     CloseHandle(thread->thread);
 }
 
-#ifdef AKIYO_HAS_THREAD_CANCEL
-void aki_thread_cancel(struct aki_thread *thread)
+#ifdef NAUNET_HAS_THREAD_CANCEL
+void nn_thread_cancel(struct nn_thread *thread)
 {
     (void)thread;
 }
 
-void aki_thread_setcanceltype(s32 type)
+void nn_thread_setcanceltype(s32 type)
 {
     (void)type;
 }
 #endif
 
 /*
-void aki_thread_detach(struct aki_thread *thread)
+void nn_thread_detach(struct nn_thread *thread)
 {
 }
 */
 
-void aki_mutex_init(struct aki_mutex *mutex)
+void nn_mutex_init(struct nn_mutex *mutex)
 {
     InitializeCriticalSection(&mutex->mutex);
 }
 
-void aki_mutex_lock(struct aki_mutex *mutex)
+void nn_mutex_lock(struct nn_mutex *mutex)
 {
     EnterCriticalSection(&mutex->mutex);
 }
 
-void aki_mutex_unlock(struct aki_mutex *mutex)
+void nn_mutex_unlock(struct nn_mutex *mutex)
 {
     LeaveCriticalSection(&mutex->mutex);
 }
 
-void aki_mutex_destroy(struct aki_mutex *mutex)
+void nn_mutex_destroy(struct nn_mutex *mutex)
 {
     DeleteCriticalSection(&mutex->mutex);
 }
 
-void aki_cond_init(struct aki_cond *cond)
+void nn_cond_init(struct nn_cond *cond)
 {
     cond->condition = true;
     InitializeConditionVariable(&cond->cond);
 }
 
-void aki_cond_wait(struct aki_cond *cond, struct aki_mutex *mutex)
+void nn_cond_wait(struct nn_cond *cond, struct nn_mutex *mutex)
 {
     cond->condition = false;
-    while (!cond->condition) {
+    while (!cond->condition)
         SleepConditionVariableCS(&cond->cond, &mutex->mutex, INFINITE);
-    }
 }
 
-bool aki_cond_is_waiting(struct aki_cond *cond)
+bool nn_cond_is_waiting(struct nn_cond *cond)
 {
     return !cond->condition;
 }
 
-void aki_cond_signal(struct aki_cond *cond)
+void nn_cond_signal(struct nn_cond *cond)
 {
     cond->condition = true;
     WakeConditionVariable(&cond->cond);
 }
 
-void aki_cond_destroy(struct aki_cond *cond)
+void nn_cond_destroy(struct nn_cond *cond)
 {
     (void)cond;
 }
diff --git a/src/util/timer/timer.h b/src/util/timer/timer.h
index 2bf6b95..cd2daf7 100644
--- a/src/util/timer/timer.h
+++ b/src/util/timer/timer.h
@@ -2,5 +2,5 @@
 
 #include <al/types.h>
 
-u64 aki_get_timestamp(void);
-f64 aki_get_tick(void);
+u64 nn_get_timestamp(void);
+f64 nn_get_tick(void);
diff --git a/src/util/timer/timer_linux.c b/src/util/timer/timer_linux.c
index d93bfdc..6585f10 100644
--- a/src/util/timer/timer_linux.c
+++ b/src/util/timer/timer_linux.c
@@ -2,14 +2,14 @@
 
 #include "timer.h"
 
-u64 aki_get_timestamp(void)
+u64 nn_get_timestamp(void)
 {
     struct timespec spec;
     clock_gettime(CLOCK_REALTIME, &spec);
     return 1e6 * spec.tv_sec + spec.tv_nsec * 1e-3;
 }
 
-f64 aki_get_tick(void)
+f64 nn_get_tick(void)
 {
     struct timespec spec;
     clock_gettime(CLOCK_MONOTONIC, &spec);
diff --git a/src/util/timer/timer_windows.c b/src/util/timer/timer_windows.c
index edd1297..198cb32 100644
--- a/src/util/timer/timer_windows.c
+++ b/src/util/timer/timer_windows.c
@@ -2,7 +2,7 @@
 
 #include "timer.h"
 
-f64 aki_get_tick(void)
+f64 nn_get_tick(void)
 {
     LARGE_INTEGER result;
     QueryPerformanceCounter(&result);
@@ -12,7 +12,7 @@ f64 aki_get_tick(void)
 // https://stackoverflow.com/a/46024468
 static const s64 UNIX_TIME_START = 0x019DB1DED53E8000; // January 1st, 1970 in "ticks"
 
-u64 aki_get_timestamp(void)
+u64 nn_get_timestamp(void)
 {
    FILETIME ft;
    GetSystemTimePreciseAsFileTime(&ft);