diff --git a/CMakeLists.txt b/CMakeLists.txt
index 17a9efa99be44b96fcf58414dfe03467ccb398e9..5b014d8ea5313a973295f4ca6c1f30cff4ca1805 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -85,6 +85,7 @@ set(Clang_CXX_FLAGS
 )
 set(GNU_C_FLAGS
     -fdiagnostics-color=always
+    -Wno-stringop-truncation # WTF gcc with strncat
 )
 
 ###               ###
diff --git a/inc/lektor/common.h b/inc/lektor/common.h
index 5517fbaa3e5e48b035825bdbeaab2083c274ece2..5fa57233ad054de85ab00e64f41194877b89b401 100644
--- a/inc/lektor/common.h
+++ b/inc/lektor/common.h
@@ -113,10 +113,11 @@ extern void (*___lkt_assert)(const char *file, int line, const char *func, const
 #ifdef assert
 #undef assert
 #endif
+#define lkt_assert(ex) (void)((ex) || (___lkt_assert(__FILE__, __LINE__, __func__, #ex), 0))
 #ifdef NDEBUG
 #define assert(ex)
 #else
-#define assert(ex) (void)((ex) || (___lkt_assert(__FILE__, __LINE__, __func__, #ex), 0))
+#define assert(ex) lkt_assert(ex)
 #endif
 
 /* Custom defined abort. */
@@ -180,10 +181,10 @@ void ___lkt_log(LOG_LEVEL, const char *sec, const char *func, const char *file,
 void ___lkt_print(const char *section, const char *format, ...);
 #define LKT_OUTPUT(section, ...) ___lkt_print(section, __VA_ARGS__)
 
-#define LKT_ENV_RESTART    "__LKT_RESTART"
-#define LKT_ENV_CURRENT    "__LKT_CURRENT"
-#define LKT_ENV_SET_ASSERT "__LKT_SET_ASSERT"
-#define LKT_ENV_KLKT_PID   "__LKT_KLKT_PID"
+#define LKT_ENV_RESTART      "__LKT_RESTART"
+#define LKT_ENV_CURRENT      "__LKT_CURRENT"
+#define LKT_ENV_UNSET_ASSERT "__LKT_UNSET_ASSERT"
+#define LKT_ENV_KLKT_PID     "__LKT_KLKT_PID"
 
 #define LKT_TABLE_FIELDS_MAX       20
 #define LKT_LINE_MAX               1024
diff --git a/inc/lektor/internal/dbmacro.h b/inc/lektor/internal/dbmacro.h
index d24cdda09bd3c2c46397ec8fbb883b1509db98d4..9880b8702129d936aa0e9041eb1e218a823ec27b 100644
--- a/inc/lektor/internal/dbmacro.h
+++ b/inc/lektor/internal/dbmacro.h
@@ -1,11 +1,7 @@
 #if !defined(__LKT_DATABASE_MACRO_H__)
 #define __LKT_DATABASE_MACRO_H__
 
-#if !defined(NDEBUG) /* DEBUG */
 #define ___LOCAL_DEBUG(...) LOG_DEBUG("DB", __VA_ARGS__)
-#else /* NOT DEBUG */
-#define ___LOCAL_DEBUG(...)
-#endif
 
 bool database_unprotected_detach(lkt_db *, const char *);
 bool database_unprotected_attach(lkt_db *, const char *, const char *);
diff --git a/inc/lektor/internal/worker.h b/inc/lektor/internal/worker.h
index 04e4cdd795774e1a59a71884840524c3070435c6..66e7e1e8d44ececd6147595f45790e76301c9938 100644
--- a/inc/lektor/internal/worker.h
+++ b/inc/lektor/internal/worker.h
@@ -56,30 +56,30 @@ worker_pool_thread(void *___pool)
     worker_pool_function func;
     FOR_EVER
     {
-        assert(!pthread_mutex_lock((pthread_mutex_t *)&pool->lock));
+        lkt_assert(!pthread_mutex_lock((pthread_mutex_t *)&pool->lock));
         if (pool->len) {
             --(pool->len);
             ++(pool->thread_working);
             func = pool->functions[pool->len];
             arg  = pool->args[pool->len];
         } else if (pool->exit) {
-            assert(!pthread_mutex_unlock((pthread_mutex_t *)&pool->lock));
+            lkt_assert(!pthread_mutex_unlock((pthread_mutex_t *)&pool->lock));
             LOG_INFO("WORKER", "Exiting");
             break;
         } else {
-            assert(!pthread_mutex_unlock((pthread_mutex_t *)&pool->lock));
+            lkt_assert(!pthread_mutex_unlock((pthread_mutex_t *)&pool->lock));
             sleep(1);
             continue;
         }
 
-        assert(!pthread_mutex_unlock((pthread_mutex_t *)&pool->lock));
+        lkt_assert(!pthread_mutex_unlock((pthread_mutex_t *)&pool->lock));
         LOG_INFO("WORKER", "Picked up a function");
         func(___pool, (void *)arg);
         LOG_INFO("WORKER", "Finished work for a function");
 
-        assert(!pthread_mutex_lock((pthread_mutex_t *)&pool->lock));
+        lkt_assert(!pthread_mutex_lock((pthread_mutex_t *)&pool->lock));
         --(pool->thread_working);
-        assert(!pthread_mutex_unlock((pthread_mutex_t *)&pool->lock));
+        lkt_assert(!pthread_mutex_unlock((pthread_mutex_t *)&pool->lock));
     }
     pthread_exit(NULL);
 }
@@ -122,7 +122,7 @@ worker_pool_new(struct worker_pool *ret, size_t init_size, size_t thread_count)
 {
     if (!thread_count) {
         int nprocs = get_nprocs_conf();
-        assert(nprocs > 0);
+        lkt_assert(nprocs > 0);
         thread_count = (size_t)nprocs;
     }
     struct worker_pool __ret = {
@@ -136,13 +136,13 @@ worker_pool_new(struct worker_pool *ret, size_t init_size, size_t thread_count)
     };
     *ret = __ret;
     pthread_mutexattr_t attr;
-    assert(!pthread_mutexattr_init(&attr));
-    assert(!pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE));
-    assert(!pthread_mutex_init(&ret->lock, &attr));
-    assert(!pthread_mutexattr_destroy(&attr));
+    lkt_assert(!pthread_mutexattr_init(&attr));
+    lkt_assert(!pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE));
+    lkt_assert(!pthread_mutex_init(&ret->lock, &attr));
+    lkt_assert(!pthread_mutexattr_destroy(&attr));
     size_t i;
     for (i = 0; i < ret->thread_size; ++i)
-        assert(!pthread_create(&ret->threads[i], NULL, worker_pool_thread, ret));
+        lkt_assert(!pthread_create(&ret->threads[i], NULL, worker_pool_thread, ret));
     return 0;
 }
 
diff --git a/src/base/cmd.c b/src/base/cmd.c
index 711ddedbcd604249a785422866376764348ddc7d..1aa7079eb1bd058060a1ff7278b0f6f56cf0305b 100644
--- a/src/base/cmd.c
+++ b/src/base/cmd.c
@@ -10,7 +10,7 @@ cmd_set_executable_name(const char *str)
     if (executable_name != NULL)
         free((void *)executable_name);
     executable_name = strdup(str);
-    assert(executable_name);
+    lkt_assert(executable_name);
 }
 
 const char *
@@ -98,7 +98,7 @@ cmd_apply_env(struct cmd_env *env, void *user)
 void
 cmd_parse_env(struct cmd_env *env, int *argc, const char ***argv)
 {
-    assert((*argc) >= 0);
+    lkt_assert((*argc) >= 0);
 
     size_t max_options = ___get_max_options(env);
     size_t len         = 0;
diff --git a/src/base/common.c b/src/base/common.c
index b5cae9f78bdd86917f9ef0e8d7e30187de36c767..3a89b3fc65e6af7262eeb91436dd09ad955d3ca6 100644
--- a/src/base/common.c
+++ b/src/base/common.c
@@ -27,16 +27,15 @@ ___yes_assert(const char *file, int line, const char *func, const char *msg)
     ___lkt_abort();
 }
 
-void (*___lkt_assert)(const char *file, int line, const char *func, const char *msg) = ___no_assert;
+void (*___lkt_assert)(const char *file, int line, const char *func,
+                      const char *msg) = ___yes_assert;
 
 CONSTRUCTOR_FUNCTION
 __set_assert(void)
 {
-#ifndef NDEBUG
-    const char *yes_assert = getenv(LKT_ENV_SET_ASSERT);
-    if (NULL != yes_assert && strlen(yes_assert) > 0)
-        ___lkt_assert = ___yes_assert;
-#endif
+    const char *no_assert = getenv(LKT_ENV_UNSET_ASSERT);
+    if (NULL != no_assert && strlen(no_assert) > 0)
+        ___lkt_assert = ___no_assert;
 }
 
 /* Log functions */
@@ -47,7 +46,7 @@ extern struct lkt_logfile *___log_logfile;                /* Use the logfile glo
 void
 lkt_set_log_level(LOG_LEVEL lvl)
 {
-    assert(lvl != ___LAST_UNUSED_LOG_LEVEL);
+    lkt_assert(lvl != ___LAST_UNUSED_LOG_LEVEL);
     if (lvl <= LOG_LEVEL_ERROR)
         ___log_level = LOG_LEVEL_ERROR;
     else if (lvl >= LOG_LEVEL_DEBUG)
@@ -69,7 +68,7 @@ void
 ___lkt_log(LOG_LEVEL level, const char *section, const char *func, const char *file,
            uint64_t line_number, const char *format, ...)
 {
-    assert(level != ___LAST_UNUSED_LOG_LEVEL);
+    lkt_assert(level != ___LAST_UNUSED_LOG_LEVEL);
 
     char line[LKT_MESSAGE_MAX];
     va_list ap;
diff --git a/src/base/launch.c b/src/base/launch.c
index 1013fb1b93fb81d029db0a95e13e3c8cf616bf90..6ad997cb328901d58eb89fbdac763d5a38d3c3de 100644
--- a/src/base/launch.c
+++ b/src/base/launch.c
@@ -259,8 +259,8 @@ launch_caching(va_list *args)
     if (database_get_version(db) >= LKT_DATABASE_VERSION_MK_7_1) {
         ret_code = 0;
         LOG_INFO("CACHING", "Caching on correct db version mk-7.1");
-        assert(!pthread_create(&___thread_wlaker, NULL, ___caching_walker, (void *)db));
-        assert(!pthread_detach(___thread_wlaker));
+        lkt_assert(!pthread_create(&___thread_wlaker, NULL, ___caching_walker, (void *)db));
+        lkt_assert(!pthread_detach(___thread_wlaker));
     }
 
     else {
diff --git a/src/base/os.c b/src/base/os.c
index 9c91f2e429d26f03df225699b3d6a1e1f215cbf1..1d3b59a4f0c43fe5a76a087a344184a6f1b59148 100644
--- a/src/base/os.c
+++ b/src/base/os.c
@@ -31,9 +31,9 @@ lkt_thread_set_name(const char *name)
     prctl(PR_SET_NAME, name);
 #elif defined(__FreeBSD__)
     long id;
-    assert(0 == thr_self(&id));
+    lkt_assert(0 == thr_self(&id));
     LOG_INFO("OS", "Set name to '%s' for thread %ld", name, id);
-    assert(0 == thr_set_name(id, name));
+    lkt_assert(0 == thr_set_name(id, name));
 #else
 #pragma message(TODO "Add support for thread set name for the current OS")
     LOG_ERROR("OS", "Unsuported operation 'thread_set_name' for OS");
diff --git a/src/base/stack.c b/src/base/stack.c
index f2e7fc0b335d5c3e45d54610c8f3a969039e833f..91fc2a64f8ca24c45e73f0384b1847e30511bb84 100644
--- a/src/base/stack.c
+++ b/src/base/stack.c
@@ -4,7 +4,7 @@
 void
 stack_new(struct stack *ret)
 {
-    assert(ret);
+    lkt_assert(ret);
 
     struct stack _ret = {
         .contents = LKT_ALLOC_ARRAY(volatile void *, LKT_DEFAULT_LIST_SIZE),
@@ -39,7 +39,7 @@ stack_empty(struct stack *lst)
 void
 stack_push(struct stack *lst, void *item)
 {
-    assert(lst);
+    lkt_assert(lst);
 
     if (lst->size == lst->len) {
         volatile void **new = realloc(lst->contents, lst->size * 2 * sizeof(void *));
diff --git a/src/base/uri.c b/src/base/uri.c
index 06abae4de94eaee5d8182e8dad1362e7e5007874..fbe544a6132530dff31a709218353b6c1eb43149 100644
--- a/src/base/uri.c
+++ b/src/base/uri.c
@@ -142,7 +142,7 @@ __prefix(char *str, struct lkt_uri *ret)
         return NULL;
 
     /* No place for the '://' separator */
-    assert((val - str) >= 0);
+    lkt_assert((val - str) >= 0);
     if (len - (size_t)(val - str) < 3)
         return NULL;
 
diff --git a/src/main/lkt.c b/src/main/lkt.c
index e738d8e3518e26b74c0f9dc911b272eb46ce7c79..020bf39ebe16e0f06c24dc0b07518472538a4897 100644
--- a/src/main/lkt.c
+++ b/src/main/lkt.c
@@ -573,8 +573,8 @@ read_kara_and_exit(FILE *sock)
 {
     char *mem = NULL;
     char buff[LKT_MESSAGE_MAX];
-    assert(mem = calloc(6 * LKT_MESSAGE_MAX, sizeof(char)));
-    assert(memset(mem, 0, 6 * LKT_MESSAGE_MAX * sizeof(char)));
+    lkt_assert(mem = calloc(6 * LKT_MESSAGE_MAX, sizeof(char)));
+    lkt_assert(memset(mem, 0, 6 * LKT_MESSAGE_MAX * sizeof(char)));
 
     char *const title    = &mem[0];
     char *const author   = &mem[LKT_MESSAGE_MAX];
@@ -583,9 +583,10 @@ read_kara_and_exit(FILE *sock)
     char *const category = &mem[4 * LKT_MESSAGE_MAX];
     char *const language = &mem[5 * LKT_MESSAGE_MAX];
 
-#define ___assign_mdt(what)           \
-    if (STR_NMATCH(#what, buff, len)) \
-        assert(memcpy(what, value, value_size));
+#define ___assign_mdt(what)              \
+    if (STR_NMATCH(#what, buff, len)) {  \
+        memcpy(what, value, value_size); \
+    }
 
     FOR_EVER
     {