diff --git a/NEWS.md b/NEWS.md
index 1d84c7ef7..03f358ae6 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -10,7 +10,6 @@ rearrangements of Notcurses.
     or fail. The new routines rely on the terminal answering the Send Device
     Attributes escape; if it does not, Notcurses may refuse to start, or even
     hang. Please report a bug if you run into this.
-
     It is still necessary to supply a correct `TERM` environment variable,
     because this is used to index into the `terminfo(5)` database, which
     seeds most common escapes. The extended capabilities of some modern
@@ -25,6 +24,8 @@ rearrangements of Notcurses.
     `ncdirect_canget_cursor()` to check if the cursor can be located.
   * `ncdirect_dim_y()` and `ncdirect_dim_x()` no longer accept a
     `const ncdirect*`, since they update the term parameters. Sorry!
+  * Added `NCDIRECT_OPTION_VERBOSE` and `NCDIRECT_OPTION_VERY_VERBOSE`.
+    They map to `NCLOGLEVEL_WARNING` and `NCLOGLEVEL_TRACE`, respectively.
 
 * 2.3.4 (2021-06-12)
   * Added the flag `NCVISUAL_OPTION_NOINTERPOLATE` to use non-interpolative
diff --git a/doc/man/man3/notcurses_direct.3.md b/doc/man/man3/notcurses_direct.3.md
index 9d0955e6f..e1cb00f79 100644
--- a/doc/man/man3/notcurses_direct.3.md
+++ b/doc/man/man3/notcurses_direct.3.md
@@ -14,6 +14,8 @@ notcurses_direct - minimal notcurses instances for styling text
 #define NCDIRECT_OPTION_INHIBIT_SETLOCALE   0x0001ull
 #define NCDIRECT_OPTION_INHIBIT_CBREAK      0x0002ull
 #define NCDIRECT_OPTION_NO_QUIT_SIGHANDLERS 0x0008ull
+#define NCDIRECT_OPTION_VERBOSE             0x0010ull
+#define NCDIRECT_OPTION_VERY_VERBOSE        0x0020ull
 ```
 
 **struct ncdirect* ncdirect_init(const char* ***termtype***, FILE* ***fp***, uint64_t ***flags***);**
@@ -170,6 +172,12 @@ The following flags are defined:
     **SIGTERM**, and **SIGABRT**, cleaning up the terminal on such exceptions.
     With this flag, the handler will not be installed.
 
+* **NCDIRECT_OPTION_VERBOSE**: Enable diagnostics to **stderr** at the level of
+    **NCLOGLEVEL_WARNING**.
+
+* **NCDIRECT_OPTION_VERY_VERBOSE**: Enable all diagnostics (equivalent to
+    **NCLOGLEVEL_TRACE**). Implies **NCDIRECT_OPTION_VERBOSE**.
+
 An appropriate **terminfo(5)** entry must exist for the terminal. This entry is
 usually selected using the value of the **TERM** environment variable (see
 **getenv(3)**), but a non-**NULL** value for **termtype** will override this. An
@@ -225,6 +233,12 @@ support, and 1 if pixel support is successfully detected.
 
 All other functions return 0 on success, and non-zero on error.
 
+# NOTES
+
+You are recommended to accept **-v** and **-vv** as command-line options,
+mapping them to **NCDIRECT_OPTION_VERBOSE** and
+**NCDIRECT_OPTION_VERY_VERBOSE** respectively.
+
 # SEE ALSO
 
 **getenv(3)**,
diff --git a/doc/man/man3/notcurses_init.3.md b/doc/man/man3/notcurses_init.3.md
index b09de5ef7..7829d2093 100644
--- a/doc/man/man3/notcurses_init.3.md
+++ b/doc/man/man3/notcurses_init.3.md
@@ -212,6 +212,17 @@ A subprocess can be streamed to a plane with an **ncsubproc**, etc.
 
 **notcurses_cursor_disable** returns -1 if the cursor is already invisible.
 
+# NOTES
+
+Several command-line options and keybindings are recommended for Notcurses
+rendered-mode programs:
+
+* **-l[0-8]** ought be mapped to the various **NCLOGLEVEL** values.
+  Alternatively, map **-v** to **NCLOGLEVEL_WARNING**, and map
+  **-vv** to **NCLOGLEVEL_INFO**.
+* **-k** ought be mapped to **NCOPTION_NO_ALTERNATE_SCREEN**.
+* Ctrl+L ought be mapped to **notcurses_refresh(3)**.
+
 # SEE ALSO
 
 **getenv(3)**,
diff --git a/include/notcurses/direct.h b/include/notcurses/direct.h
index df3e27584..f2680e6a9 100644
--- a/include/notcurses/direct.h
+++ b/include/notcurses/direct.h
@@ -29,6 +29,13 @@ extern "C" {
 // registration of these signal handlers. Chosen to match fullscreen mode.
 #define NCDIRECT_OPTION_NO_QUIT_SIGHANDLERS 0x0008ull
 
+// Enable logging (to stderr) at the NCLOGLEVEL_WARNING level.
+#define NCDIRECT_OPTION_VERBOSE             0x0010ull
+
+// Enable logging (to stderr) at the NCLOGLEVEL_TRACE level. This will enable
+// all diagnostics, a superset of NCDIRECT_OPTION_VERBOSE (which this implies).
+#define NCDIRECT_OPTION_VERY_VERBOSE        0x0020ull
+
 // Initialize a direct-mode Notcurses context on the connected terminal at 'fp'.
 // 'fp' must be a tty. You'll usually want stdout. Direct mode supports a
 // limited subset of Notcurses routines which directly affect 'fp', and neither
diff --git a/src/lib/debug.c b/src/lib/debug.c
index ea43df988..a0fcc3564 100644
--- a/src/lib/debug.c
+++ b/src/lib/debug.c
@@ -1,5 +1,7 @@
 #include "internal.h"
 
+int loglevel = NCLOGLEVEL_SILENT;
+
 static inline char
 capyn(const char* cap){
   return cap ? 'y' : 'n';
diff --git a/src/lib/direct.c b/src/lib/direct.c
index 17e4eadab..82c6db760 100644
--- a/src/lib/direct.c
+++ b/src/lib/direct.c
@@ -779,8 +779,8 @@ ncdirect_stop_minimal(void* vnc){
 }
 
 ncdirect* ncdirect_core_init(const char* termtype, FILE* outfp, uint64_t flags){
-  if(flags > (NCDIRECT_OPTION_NO_QUIT_SIGHANDLERS << 1)){ // allow them through with warning
-    logwarn((struct notcurses*)NULL, "Passed unsupported flags 0x%016jx\n", (uintmax_t)flags);
+  if(flags > (NCDIRECT_OPTION_VERY_VERBOSE << 1)){ // allow them through with warning
+    logwarn("Passed unsupported flags 0x%016jx\n", (uintmax_t)flags);
   }
   if(outfp == NULL){
     outfp = stdout;
@@ -793,7 +793,7 @@ ncdirect* ncdirect_core_init(const char* termtype, FILE* outfp, uint64_t flags){
   ret->flags = flags;
   ret->ttyfp = outfp;
   if(!(flags & NCDIRECT_OPTION_INHIBIT_SETLOCALE)){
-    init_lang(NULL);
+    init_lang();
   }
   const char* encoding = nl_langinfo(CODESET);
   bool utf8 = false;
@@ -805,8 +805,17 @@ ncdirect* ncdirect_core_init(const char* termtype, FILE* outfp, uint64_t flags){
     free(ret);
     return NULL;
   }
+  // don't set the loglevel until we've locked in signal handling, lest we
+  // change the loglevel out from under a running instance.
+  if(flags & NCDIRECT_OPTION_VERY_VERBOSE){
+    loglevel = NCLOGLEVEL_TRACE;
+  }else if(flags & NCDIRECT_OPTION_VERBOSE){
+    loglevel = NCLOGLEVEL_WARNING;
+  }else{
+    loglevel = NCLOGLEVEL_SILENT;
+  }
   // we don't need a controlling tty for everything we do; allow a failure here
-  ret->ctermfd = get_tty_fd(NULL, ret->ttyfp);
+  ret->ctermfd = get_tty_fd(ret->ttyfp);
   const char* shortname_term;
   int termerr;
   if(setupterm(termtype, ret->ctermfd, &termerr) != OK){
diff --git a/src/lib/fd.c b/src/lib/fd.c
index 28b0c298f..5344f6ead 100644
--- a/src/lib/fd.c
+++ b/src/lib/fd.c
@@ -109,7 +109,7 @@ ncfdplane_create_internal(ncplane* n, const ncfdplane_options* opts, int fd,
                           ncfdplane_callback cbfxn, ncfdplane_done_cb donecbfxn,
                           bool thread){
   if(opts->flags > 0){
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
   }
   ncfdplane* ret = malloc(sizeof(*ret));
   if(ret == NULL){
@@ -310,7 +310,7 @@ ncsubproc* ncsubproc_createv(ncplane* n, const ncsubproc_options* opts,
     return NULL;
   }
   if(opts->flags > 0){
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
   }
   int fd = -1;
   ncsubproc* ret = malloc(sizeof(*ret));
@@ -345,7 +345,7 @@ ncsubproc* ncsubproc_createvp(ncplane* n, const ncsubproc_options* opts,
     return NULL;
   }
   if(opts->flags > 0){
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
   }
   int fd = -1;
   ncsubproc* ret = malloc(sizeof(*ret));
@@ -380,7 +380,7 @@ ncsubproc* ncsubproc_createvpe(ncplane* n, const ncsubproc_options* opts,
     return NULL;
   }
   if(opts->flags > 0){
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
   }
   int fd = -1;
   ncsubproc* ret = malloc(sizeof(*ret));
@@ -459,16 +459,16 @@ ncplane* ncsubproc_plane(ncsubproc* n){
 
 // if ttyfp is a tty, return a file descriptor extracted from it. otherwise,
 // try to get the controlling terminal. otherwise, return -1.
-int get_tty_fd(notcurses* nc, FILE* ttyfp){
+int get_tty_fd(FILE* ttyfp){
   int fd = -1;
   if(ttyfp){
     if((fd = fileno(ttyfp)) < 0){
-      logwarn(nc, "No file descriptor was available in outfp %p\n", ttyfp);
+      logwarn("No file descriptor was available in outfp %p\n", ttyfp);
     }else{
       if(isatty(fd)){
         fd = dup(fd);
       }else{
-        loginfo(nc, "File descriptor %d was not a TTY\n", fd);
+        loginfo("File descriptor %d was not a TTY\n", fd);
         fd = -1;
       }
     }
@@ -476,15 +476,15 @@ int get_tty_fd(notcurses* nc, FILE* ttyfp){
   if(fd < 0){
     fd = open("/dev/tty", O_RDWR | O_CLOEXEC);
     if(fd < 0){
-      loginfo(nc, "Error opening /dev/tty (%s)\n", strerror(errno));
+      loginfo("Error opening /dev/tty (%s)\n", strerror(errno));
     }else{
       if(!isatty(fd)){
-        loginfo(nc, "File descriptor for /dev/tty (%d) is not actually a TTY\n", fd);
+        loginfo("File descriptor for /dev/tty (%d) is not actually a TTY\n", fd);
         close(fd);
         fd = -1;
       }
     }
   }
-  loginfo(nc, "Returning TTY fd %d\n", fd);
+  loginfo("Returning TTY fd %d\n", fd);
   return fd;
 }
diff --git a/src/lib/fill.c b/src/lib/fill.c
index b6f8e0ac1..2af185e53 100644
--- a/src/lib/fill.c
+++ b/src/lib/fill.c
@@ -146,11 +146,11 @@ calc_highgradient(nccell* c, uint32_t ul, uint32_t ur, uint32_t ll,
 int ncplane_highgradient(ncplane* n, uint32_t ul, uint32_t ur,
                          uint32_t ll, uint32_t lr, int ystop, int xstop){
   if(!notcurses_canutf8(ncplane_notcurses(n))){
-    logerror(ncplane_notcurses(n), "Highdef gradients require UTF8\n");
+    logerror("Highdef gradients require UTF8\n");
     return -1;
   }
   if(check_gradient_channel_args(ul, ur, ll, lr)){
-    logerror(ncplane_notcurses(n), "Invalid highdef gradient channels\n");
+    logerror("Invalid highdef gradient channels\n");
     return -1;
   }
   int yoff, xoff, ymax, xmax;
@@ -208,7 +208,7 @@ int ncplane_gradient(ncplane* n, const char* egc, uint32_t stylemask,
                      uint64_t ul, uint64_t ur, uint64_t bl, uint64_t br,
                      int ystop, int xstop){
   if(check_gradient_args(ul, ur, bl, br)){
-    logerror(ncplane_notcurses(n), "Illegal gradient inputs\n");
+    logerror("Illegal gradient inputs\n");
     return -1;
   }
   if(egc == NULL){
@@ -218,11 +218,11 @@ int ncplane_gradient(ncplane* n, const char* egc, uint32_t stylemask,
   ncplane_cursor_yx(n, &yoff, &xoff);
   // must be at least 1x1, with its upper-left corner at the current cursor
   if(ystop < yoff){
-    logerror(ncplane_notcurses(n), "Ystop %d < yoff %d\n", ystop, yoff);
+    logerror("Ystop %d < yoff %d\n", ystop, yoff);
     return -1;
   }
   if(xstop < xoff){
-    logerror(ncplane_notcurses(n), "Xstop %d < xoff %d\n", xstop, xoff);
+    logerror("Xstop %d < xoff %d\n", xstop, xoff);
     return -1;
   }
   ncplane_dim_yx(n, &ymax, &xmax);
@@ -268,18 +268,18 @@ int ncplane_stain(ncplane* n, int ystop, int xstop,
                   uint64_t tl, uint64_t tr, uint64_t bl, uint64_t br){
   // Can't use default or palette-indexed colors in a gradient
   if(check_gradient_args(tl, tr, bl, br)){
-    logerror(ncplane_notcurses(n), "Illegal staining inputs\n");
+    logerror("Illegal staining inputs\n");
     return -1;
   }
   int yoff, xoff, ymax, xmax;
   ncplane_cursor_yx(n, &yoff, &xoff);
   // must be at least 1x1, with its upper-left corner at the current cursor
   if(ystop < yoff){
-    logerror(ncplane_notcurses(n), "Ystop %d < yoff %d\n", ystop, yoff);
+    logerror("Ystop %d < yoff %d\n", ystop, yoff);
     return -1;
   }
   if(xstop < xoff){
-    logerror(ncplane_notcurses(n), "Xstop %d < xoff %d\n", xstop, xoff);
+    logerror("Xstop %d < xoff %d\n", xstop, xoff);
     return -1;
   }
   ncplane_dim_yx(n, &ymax, &xmax);
@@ -346,7 +346,7 @@ rotate_channels(ncplane* src, const nccell* c, uint32_t* fchan, uint32_t* bchan)
     *bchan = *fchan;
     return 0;
   }
-  logerror(ncplane_notcurses(src), "Invalid EGC for rotation [%s]\n", egc);
+  logerror("Invalid EGC for rotation [%s]\n", egc);
   return -1;
 }
 
diff --git a/src/lib/input.c b/src/lib/input.c
index 83936eba4..534128949 100644
--- a/src/lib/input.c
+++ b/src/lib/input.c
@@ -48,12 +48,12 @@ int notcurses_linesigs_disable(notcurses* n){
   }
   struct termios tios;
   if(tcgetattr(n->ttyfd, &tios)){
-    logerror(n, "Couldn't preserve terminal state for %d (%s)\n", n->ttyfd, strerror(errno));
+    logerror("Couldn't preserve terminal state for %d (%s)\n", n->ttyfd, strerror(errno));
     return -1;
   }
   tios.c_lflag &= ~ISIG;
   if(tcsetattr(n->ttyfd, TCSANOW, &tios)){
-    logerror(n, "Error disabling signals on %d (%s)\n", n->ttyfd, strerror(errno));
+    logerror("Error disabling signals on %d (%s)\n", n->ttyfd, strerror(errno));
     return -1;
   }
   return 0;
@@ -67,12 +67,12 @@ int notcurses_linesigs_enable(notcurses* n){
   }
   struct termios tios;
   if(tcgetattr(n->ttyfd, &tios)){
-    logerror(n, "Couldn't preserve terminal state for %d (%s)\n", n->ttyfd, strerror(errno));
+    logerror("Couldn't preserve terminal state for %d (%s)\n", n->ttyfd, strerror(errno));
     return -1;
   }
   tios.c_lflag |= ~ISIG;
   if(tcsetattr(n->ttyfd, TCSANOW, &tios)){
-    logerror(n, "Error disabling signals on %d (%s)\n", n->ttyfd, strerror(errno));
+    logerror("Error disabling signals on %d (%s)\n", n->ttyfd, strerror(errno));
     return -1;
   }
   return 0;
@@ -1109,7 +1109,7 @@ int ncinputlayer_init(tinfo* tcache, FILE* infp, queried_terminals_e* detected){
   setbuffer(infp, NULL, 0);
   nilayer->inputescapes = NULL;
   nilayer->infd = fileno(infp);
-  nilayer->ttyfd = isatty(nilayer->infd) ? -1 : get_tty_fd(NULL, infp);
+  nilayer->ttyfd = isatty(nilayer->infd) ? -1 : get_tty_fd(infp);
   if(prep_special_keys(nilayer)){
     return -1;
   }
diff --git a/src/lib/internal.h b/src/lib/internal.h
index f0412d244..dc5a84a20 100644
--- a/src/lib/internal.h
+++ b/src/lib/internal.h
@@ -592,7 +592,7 @@ void update_write_stats(const struct timespec* time1, const struct timespec* tim
 
 void sigwinch_handler(int signo);
 
-void init_lang(notcurses* nc); // nc may be NULL, only used for logging
+void init_lang(void);
 
 // load |ti| from the terminfo database, which must already have been
 // initialized. set |utf8| if we've verified UTF8 output encoding.
@@ -1196,37 +1196,37 @@ void nclog(const char* fmt, ...);
 bool is_linux_console(const notcurses* nc, unsigned no_font_changes);
 
 // logging
-#define logerror(nc, fmt, ...) do{ \
-  if(nc){ if((nc)->loglevel >= NCLOGLEVEL_ERROR){ \
-    nclog("%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
-  }else{ fprintf(stderr, "%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
-}while(0);
+extern int loglevel;
 
-#define logwarn(nc, fmt, ...) do{ \
-  if(nc){ if((nc)->loglevel >= NCLOGLEVEL_WARNING){ \
+#define logerror(fmt, ...) do{ \
+  if(loglevel >= NCLOGLEVEL_ERROR){ \
     nclog("%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
-  }else{ fprintf(stderr, "%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
-}while(0);
+  } while(0);
 
-#define loginfo(nc, fmt, ...) do{ \
-  if(nc){ if((nc)->loglevel >= NCLOGLEVEL_INFO){ \
+#define logwarn(fmt, ...) do{ \
+  if(loglevel >= NCLOGLEVEL_WARNING){ \
     nclog("%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
-  } }while(0);
+  } while(0);
 
-#define logverbose(nc, fmt, ...) do{ \
-  if(nc){ if((nc)->loglevel >= NCLOGLEVEL_VERBOSE){ \
+#define loginfo(fmt, ...) do{ \
+  if(loglevel >= NCLOGLEVEL_INFO){ \
     nclog("%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
-  } }while(0);
+  } while(0);
 
-#define logdebug(nc, fmt, ...) do{ \
-  if(nc){ if((nc)->loglevel >= NCLOGLEVEL_DEBUG){ \
+#define logverbose(fmt, ...) do{ \
+  if(loglevel >= NCLOGLEVEL_VERBOSE){ \
     nclog("%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
-  } }while(0);
+  } while(0);
 
-#define logtrace(nc, fmt, ...) do{ \
-  if(nc){ if((nc)->loglevel >= NCLOGLEVEL_TRACE){ \
+#define logdebug(fmt, ...) do{ \
+  if(loglevel >= NCLOGLEVEL_DEBUG){ \
     nclog("%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
-  } }while(0);
+  } while(0);
+
+#define logtrace(fmt, ...) do{ \
+  if(loglevel >= NCLOGLEVEL_TRACE){ \
+    nclog("%s:%d:" fmt, __func__, __LINE__, ##__VA_ARGS__); } \
+  } while(0);
 
 int term_setstyle(FILE* out, unsigned cur, unsigned targ, unsigned stylebit,
                   const char* ton, const char* toff);
@@ -1509,7 +1509,7 @@ int cbreak_mode(int ttyfd, const struct termios* tpreserved);
 
 int set_fd_nonblocking(int fd, unsigned state, unsigned* oldstate);
 
-int get_tty_fd(notcurses* nc, FILE* ttyfp);
+int get_tty_fd(FILE* ttyfp);
 
 // Given the four channels arguments, verify that:
 //
diff --git a/src/lib/layout.c b/src/lib/layout.c
index dccd2e53d..8264f8fcb 100644
--- a/src/lib/layout.c
+++ b/src/lib/layout.c
@@ -65,7 +65,7 @@ puttext_line(ncplane* n, ncalign_e align, const char* text, size_t* bytes){
     wchar_t w;
     const size_t consumed = mbrtowc(&w, text + b, MB_CUR_MAX, &mbstate);
     if(consumed == (size_t)-2 || consumed == (size_t)-1){
-      logerror(ncplane_notcurses(n), "Invalid UTF-8 after %d bytes\n", b);
+      logerror("Invalid UTF-8 after %d bytes\n", b);
       return -1;
     }
 //fprintf(stderr, "converted [%s] -> %lc\n", text + b, w);
diff --git a/src/lib/linux.c b/src/lib/linux.c
index 0446920cd..88a8a991f 100644
--- a/src/lib/linux.c
+++ b/src/lib/linux.c
@@ -314,8 +314,8 @@ shim_lower_eighth(struct consolefontdesc* cfd, unsigned idx){
 
 // add UCS2 codepoint |w| to |map| for font idx |fidx|
 static int
-add_to_map(const notcurses* nc, struct unimapdesc* map, wchar_t w, unsigned fidx){
-  logdebug(nc, "Adding mapping U+%04x -> %03u\n", w, fidx);
+add_to_map(struct unimapdesc* map, wchar_t w, unsigned fidx){
+  logdebug("Adding mapping U+%04x -> %03u\n", w, fidx);
   struct unipair* tmp = realloc(map->entries, sizeof(*map->entries) * (map->entry_ct + 1));
   if(tmp == NULL){
     return -1;
@@ -373,7 +373,7 @@ program_line_drawing_chars(const notcurses* nc, struct unimapdesc* map){
     for(unsigned idx = 0 ; idx < map->entry_ct ; ++idx){
       for(size_t widx = 0 ; widx < wcslen(s->ws) ; ++widx){
         if(map->entries[idx].unicode == s->ws[widx]){
-          logtrace(nc, "Found desired character U+%04x -> %03u\n",
+          logtrace("Found desired character U+%04x -> %03u\n",
                    map->entries[idx].unicode, map->entries[idx].fontpos);
           found[widx] = true;
           if(fontidx == -1){
@@ -385,24 +385,24 @@ program_line_drawing_chars(const notcurses* nc, struct unimapdesc* map){
     if(fontidx > -1){
       for(size_t widx = 0 ; widx < wcslen(s->ws) ; ++widx){
         if(!found[widx]){
-          if(add_to_map(nc, map, s->ws[widx], fontidx)){
+          if(add_to_map(map, s->ws[widx], fontidx)){
             return -1;
           }
           ++toadd;
         }
       }
     }else{
-      logwarn(nc, "Couldn't find any glyphs for set %zu\n", sidx);
+      logwarn("Couldn't find any glyphs for set %zu\n", sidx);
     }
   }
   if(toadd == 0){
     return 0;
   }
   if(ioctl(nc->ttyfd, PIO_UNIMAP, map)){
-    logwarn(nc, "Error setting kernel unicode map (%s)\n", strerror(errno));
+    logwarn("Error setting kernel unicode map (%s)\n", strerror(errno));
     return -1;
   }
-  loginfo(nc, "Successfully added %d kernel unicode mapping%s\n",
+  loginfo("Successfully added %d kernel unicode mapping%s\n",
           toadd, toadd == 1 ? "" : "s");
   return 0;
 }
@@ -441,7 +441,7 @@ program_block_drawing_chars(const notcurses* nc, struct consolefontdesc* cfd,
     if(map->entries[i].unicode >= 0x2580 && map->entries[i].unicode <= 0x259f){
       for(size_t s = 0 ; s < sizeof(shimmers) / sizeof(*shimmers) ; ++s){
         if(map->entries[i].unicode == shimmers[s].w){
-          logdebug(nc, "Found %lc at fontidx %u\n", shimmers[s].w, i);
+          logdebug("Found %lc at fontidx %u\n", shimmers[s].w, i);
           shimmers[s].found = true;
           break;
         }
@@ -458,29 +458,28 @@ program_block_drawing_chars(const notcurses* nc, struct consolefontdesc* cfd,
         }
       }
       if(candidate == 0){
-        logwarn(nc, "Ran out of replaceable glyphs for U+%04lx\n", (long)shimmers[s].w);
+        logwarn("Ran out of replaceable glyphs for U+%04lx\n", (long)shimmers[s].w);
         return -1;
       }
       if(shimmers[s].glyphfxn(cfd, candidate)){
-        logwarn(nc, "Error replacing glyph for U+%04lx at %u\n", (long)shimmers[s].w, candidate);
+        logwarn("Error replacing glyph for U+%04lx at %u\n", (long)shimmers[s].w, candidate);
         return -1;
       }
-      if(add_to_map(nc, map, shimmers[s].w, candidate)){
+      if(add_to_map(map, shimmers[s].w, candidate)){
         return -1;
       }
       ++added;
     }
   }
   if(ioctl(nc->ttyfd, PIO_FONTX, cfd)){
-    logwarn(nc, "Error programming kernel font (%s)\n", strerror(errno));
+    logwarn("Error programming kernel font (%s)\n", strerror(errno));
     return -1;
   }
   if(ioctl(nc->ttyfd, PIO_UNIMAP, map)){
-    logwarn(nc, "Error setting kernel unicode map (%s)\n", strerror(errno));
+    logwarn("Error setting kernel unicode map (%s)\n", strerror(errno));
     return -1;
   }
-  loginfo(nc, "Successfully added %d kernel font glyph%s\n",
-          added, added == 1 ? "" : "s");
+  loginfo("Successfully added %d kernel font glyph%s\n", added, added == 1 ? "" : "s");
   return 0;
 }
 
@@ -488,20 +487,20 @@ static int
 reprogram_linux_font(const notcurses* nc, struct consolefontdesc* cfd,
                      struct unimapdesc* map){
   if(ioctl(nc->ttyfd, GIO_FONTX, cfd)){
-    logwarn(nc, "Error reading Linux kernelfont (%s)\n", strerror(errno));
+    logwarn("Error reading Linux kernelfont (%s)\n", strerror(errno));
     return -1;
   }
-  loginfo(nc, "Kernel font size (glyphcount): %hu\n", cfd->charcount);
-  loginfo(nc, "Kernel font character geometry: 8x%hu\n", cfd->charheight);
+  loginfo("Kernel font size (glyphcount): %hu\n", cfd->charcount);
+  loginfo("Kernel font character geometry: 8x%hu\n", cfd->charheight);
   if(cfd->charcount > 512){
-    logwarn(nc, "Warning: kernel returned excess charcount\n");
+    logwarn("Warning: kernel returned excess charcount\n");
     return -1;
   }
   if(ioctl(nc->ttyfd, GIO_UNIMAP, map)){
-    logwarn(nc, "Error reading Linux unimap (%s)\n", strerror(errno));
+    logwarn("Error reading Linux unimap (%s)\n", strerror(errno));
     return -1;
   }
-  loginfo(nc, "Kernel Unimap size: %hu/%hu\n", map->entry_ct, USHRT_MAX);
+  loginfo("Kernel Unimap size: %hu/%hu\n", map->entry_ct, USHRT_MAX);
   // for certain sets of characters, we're not going to draw them in, but we
   // do want to ensure they map to something plausible...
   if(program_line_drawing_chars(nc, map)){
@@ -520,7 +519,7 @@ reprogram_console_font(const notcurses* nc){
   size_t totsize = 32 * cfd.charcount;
   cfd.chardata = malloc(totsize);
   if(cfd.chardata == NULL){
-    logwarn(nc, "Error acquiring %zub for font descriptors (%s)\n", totsize, strerror(errno));
+    logwarn("Error acquiring %zub for font descriptors (%s)\n", totsize, strerror(errno));
     return -1;
   }
   struct unimapdesc map = {};
@@ -528,7 +527,7 @@ reprogram_console_font(const notcurses* nc){
   totsize = map.entry_ct * sizeof(struct unipair);
   map.entries = malloc(totsize);
   if(map.entries == NULL){
-    logwarn(nc, "Error acquiring %zub for Unicode font map (%s)\n", totsize, strerror(errno));
+    logwarn("Error acquiring %zub for Unicode font map (%s)\n", totsize, strerror(errno));
     free(cfd.chardata);
     return -1;
   }
@@ -545,12 +544,12 @@ bool is_linux_console(const notcurses* nc, unsigned no_font_changes){
   }
   int mode;
   if(ioctl(nc->ttyfd, KDGETMODE, &mode)){
-    logdebug(nc, "Not a Linux console, KDGETMODE failed\n");
+    logdebug("Not a Linux console, KDGETMODE failed\n");
     return false;
   }
-  loginfo(nc, "Verified Linux console, mode %d\n", mode);
+  loginfo("Verified Linux console, mode %d\n", mode);
   if(no_font_changes){
-    logdebug(nc, "Not reprogramming the console font due to option\n");
+    logdebug("Not reprogramming the console font due to option\n");
     return true;
   }
   reprogram_console_font(nc);
diff --git a/src/lib/menu.c b/src/lib/menu.c
index a2a12aba3..80163d375 100644
--- a/src/lib/menu.c
+++ b/src/lib/menu.c
@@ -344,11 +344,11 @@ ncmenu* ncmenu_create(ncplane* n, const ncmenu_options* opts){
     opts = &zeroed;
   }
   if(opts->sectioncount <= 0 || !opts->sections){
-    logerror(ncplane_notcurses(n), "Invalid %d-ary section information\n", opts->sectioncount);
+    logerror("Invalid %d-ary section information\n", opts->sectioncount);
     return NULL;
   }
   if(opts->flags >= (NCMENU_OPTION_HIDING << 1u)){
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
   }
   int totalheight = 1;
   int totalwidth = 2; // start with two-character margin on the left
@@ -396,7 +396,7 @@ ncmenu* ncmenu_create(ncplane* n, const ncmenu_options* opts){
     }
     free(ret);
   }
-  logerror(ncplane_notcurses(n), "Error creating ncmenu\n");
+  logerror("Error creating ncmenu\n");
   return NULL;
 }
 
@@ -415,7 +415,7 @@ int ncmenu_unroll(ncmenu* n, int sectionidx){
     return -1;
   }
   if(sectionidx < 0 || sectionidx >= n->sectioncount){
-    logerror(ncplane_notcurses(n->ncp), "Unrolled invalid sectionidx %d\n", sectionidx);
+    logerror("Unrolled invalid sectionidx %d\n", sectionidx);
     return -1;
   }
   if(n->sections[sectionidx].enabled_item_count <= 0){
diff --git a/src/lib/notcurses.c b/src/lib/notcurses.c
index 2854a2259..08f17b06b 100644
--- a/src/lib/notcurses.c
+++ b/src/lib/notcurses.c
@@ -370,22 +370,22 @@ make_ncpile(notcurses* nc, ncplane* n){
 ncplane* ncplane_new_internal(notcurses* nc, ncplane* n,
                               const ncplane_options* nopts){
   if(nopts->flags >= (NCPLANE_OPTION_MARGINALIZED << 1u)){
-    logwarn(nc, "Provided unsupported flags %016jx\n", (uintmax_t)nopts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)nopts->flags);
   }
   if(nopts->flags & NCPLANE_OPTION_HORALIGNED || nopts->flags & NCPLANE_OPTION_VERALIGNED){
     if(n == NULL){
-      logerror(nc, "Alignment requires a parent plane\n");
+      logerror("Alignment requires a parent plane\n");
       return NULL;
     }
   }
   if(nopts->flags & NCPLANE_OPTION_MARGINALIZED){
     if(nopts->rows != 0 || nopts->cols != 0){
-      logerror(nc, "Geometry specified with margins (r=%d, c=%d)\n",
+      logerror("Geometry specified with margins (r=%d, c=%d)\n",
                nopts->rows, nopts->cols);
       return NULL;
     }
   }else if(nopts->rows <= 0 || nopts->cols <= 0){
-    logerror(nc, "Won't create denormalized plane (r=%d, c=%d)\n",
+    logerror("Won't create denormalized plane (r=%d, c=%d)\n",
              nopts->rows, nopts->cols);
     return NULL;
   }
@@ -415,7 +415,7 @@ ncplane* ncplane_new_internal(notcurses* nc, ncplane* n,
   }
   size_t fbsize = sizeof(*p->fb) * (p->leny * p->lenx);
   if((p->fb = malloc(fbsize)) == NULL){
-    logerror(nc, "Error allocating cellmatrix (r=%d, c=%d)\n",
+    logerror("Error allocating cellmatrix (r=%d, c=%d)\n",
              p->leny, p->lenx);
     free(p);
     return NULL;
@@ -488,7 +488,7 @@ ncplane* ncplane_new_internal(notcurses* nc, ncplane* n,
     pthread_mutex_unlock(&nc->statlock);
     pthread_mutex_unlock(&nc->pilelock);
   }
-  loginfo(nc, "Created new %dx%d plane \"%s\" @ %dx%d\n",
+  loginfo("Created new %dx%d plane \"%s\" @ %dx%d\n",
           p->leny, p->lenx, p->name ? p->name : "", p->absy, p->absx);
   return p;
 }
@@ -547,29 +547,29 @@ void ncplane_home(ncplane* n){
 
 inline int ncplane_cursor_move_yx(ncplane* n, int y, int x){
   if(x >= n->lenx){
-    logerror(ncplane_notcurses(n), "Target x %d >= length %d\n", x, n->lenx);
+    logerror("Target x %d >= length %d\n", x, n->lenx);
     return -1;
   }else if(x < 0){
     if(x < -1){
-      logerror(ncplane_notcurses(n), "Negative target x %d\n", x);
+      logerror("Negative target x %d\n", x);
       return -1;
     }
   }else{
     n->x = x;
   }
   if(y >= n->leny){
-    logerror(ncplane_notcurses(n), "Target y %d >= height %d\n", y, n->leny);
+    logerror("Target y %d >= height %d\n", y, n->leny);
     return -1;
   }else if(y < 0){
     if(y < -1){
-      logerror(ncplane_notcurses(n), "Negative target y %d\n", y);
+      logerror("Negative target y %d\n", y);
       return -1;
     }
   }else{
     n->y = y;
   }
   if(cursor_invalid_p(n)){
-    logerror(ncplane_notcurses(n), "Invalid cursor following move (%d/%d)\n", n->y, n->x);
+    logerror("Invalid cursor following move (%d/%d)\n", n->y, n->x);
     return -1;
   }
   return 0;
@@ -630,41 +630,41 @@ int resize_callbacks_children(ncplane* n){
 int ncplane_resize_internal(ncplane* n, int keepy, int keepx, int keepleny,
                             int keeplenx, int yoff, int xoff, int ylen, int xlen){
   if(keepleny < 0 || keeplenx < 0){ // can't retain negative size
-    logerror(ncplane_notcurses_const(n), "Can't retain negative size %dx%d\n", keepleny, keeplenx);
+    logerror("Can't retain negative size %dx%d\n", keepleny, keeplenx);
     return -1;
   }
   if(keepy < 0 || keepx < 0){ // can't start at negative origin
-    logerror(ncplane_notcurses_const(n), "Can't retain negative offset %dx%d\n", keepy, keepx);
+    logerror("Can't retain negative offset %dx%d\n", keepy, keepx);
     return -1;
   }
   if((!keepleny && keeplenx) || (keepleny && !keeplenx)){ // both must be 0
-    logerror(ncplane_notcurses_const(n), "Can't retain null dimension %dx%d\n", keepleny, keeplenx);
+    logerror("Can't retain null dimension %dx%d\n", keepleny, keeplenx);
     return -1;
   }
   // can't be smaller than keep length
   if(ylen < keepleny){
-    logerror(ncplane_notcurses_const(n), "Can't map in y dimension: %d < %d\n", ylen, keepleny);
+    logerror("Can't map in y dimension: %d < %d\n", ylen, keepleny);
     return -1;
   }
   if(xlen < keeplenx){
-    logerror(ncplane_notcurses_const(n), "Can't map in x dimension: %d < %d\n", xlen, keeplenx);
+    logerror("Can't map in x dimension: %d < %d\n", xlen, keeplenx);
     return -1;
   }
   if(ylen <= 0 || xlen <= 0){ // can't resize to trivial or negative size
-    logerror(ncplane_notcurses_const(n), "Can't achieve meaningless size %dx%d\n", ylen, xlen);
+    logerror("Can't achieve meaningless size %dx%d\n", ylen, xlen);
     return -1;
   }
   int rows, cols;
   ncplane_dim_yx(n, &rows, &cols);
   if(keepleny + keepy > rows){
-    logerror(ncplane_notcurses_const(n), "Can't keep %d@%d rows from %d\n", keepleny, keepy, rows);
+    logerror("Can't keep %d@%d rows from %d\n", keepleny, keepy, rows);
     return -1;
   }
   if(keeplenx + keepx > cols){
-    logerror(ncplane_notcurses_const(n), "Can't keep %d@%d cols from %d\n", keeplenx, keepx, cols);
+    logerror("Can't keep %d@%d cols from %d\n", keeplenx, keepx, cols);
     return -1;
   }
-  loginfo(ncplane_notcurses_const(n), "%dx%d @ %d/%d → %d/%d @ %d/%d (keeping %dx%d from %d/%d)\n", rows, cols, n->absy, n->absx, ylen, xlen, n->absy + keepy + yoff, n->absx + keepx + xoff, keepleny, keeplenx, keepy, keepx);
+  loginfo("%dx%d @ %d/%d → %d/%d @ %d/%d (keeping %dx%d from %d/%d)\n", rows, cols, n->absy, n->absx, ylen, xlen, n->absy + keepy + yoff, n->absx + keepx + xoff, keepleny, keeplenx, keepy, keepx);
   if(n->absy == n->absy + keepy && n->absx == n->absx + keepx &&
       rows == ylen && cols == xlen){
     return 0;
@@ -685,7 +685,7 @@ int ncplane_resize_internal(ncplane* n, int keepy, int keepx, int keepleny,
     return -1;
   }
   if(n->tam){
-    loginfo(ncplane_notcurses_const(n), "TAM realloc to %d entries\n", newarea);
+    loginfo("TAM realloc to %d entries\n", newarea);
     tament* tmptam = realloc(n->tam, sizeof(*tmptam) * newarea);
     if(tmptam == NULL){
       free(fb);
@@ -780,11 +780,11 @@ int ncplane_destroy(ncplane* ncp){
     return 0;
   }
   if(ncplane_notcurses(ncp)->stdplane == ncp){
-    logerror(ncplane_notcurses(ncp), "Won't destroy standard plane\n");
+    logerror("Won't destroy standard plane\n");
     return -1;
   }
 //notcurses_debug(ncplane_notcurses(ncp), stderr);
-  loginfo(ncplane_notcurses_const(ncp), "Destroying %dx%d plane \"%s\" @ %dx%d\n",
+  loginfo("Destroying %dx%d plane \"%s\" @ %dx%d\n",
           ncp->leny, ncp->lenx, ncp->name ? ncp->name : NULL, ncp->absy, ncp->absx);
   int ret = 0;
   // dissolve our binding from behind (->bprev is either NULL, or its
@@ -826,7 +826,7 @@ int ncplane_genocide(ncplane *ncp){
     return 0;
   }
   if(ncplane_notcurses(ncp)->stdplane == ncp){
-    logerror(ncplane_notcurses(ncp), "Won't destroy standard plane\n");
+    logerror("Won't destroy standard plane\n");
     return -1;
   }
   int ret = 0;
@@ -932,7 +932,7 @@ init_banner(const notcurses* nc){
 // of "C" or "POSIX"). recommended practice is for the client code to have
 // called setlocale() themselves, and set the NCOPTION_INHIBIT_SETLOCALE flag.
 // if that flag is set, we take the locale and encoding as we get them.
-void init_lang(struct notcurses* nc){
+void init_lang(void){
   const char* encoding = nl_langinfo(CODESET);
   if(encoding && !strcmp(encoding, "UTF-8")){
     return; // already utf-8, great!
@@ -940,19 +940,19 @@ void init_lang(struct notcurses* nc){
   const char* lang = getenv("LANG");
   // if LANG was explicitly set to C/POSIX, life sucks, roll with it
   if(lang && (!strcmp(lang, "C") || !strcmp(lang, "POSIX"))){
-    loginfo(nc, "LANG was explicitly set to %s, not changing locale\n", lang);
+    loginfo("LANG was explicitly set to %s, not changing locale\n", lang);
     return;
   }
   setlocale(LC_ALL, "");
   encoding = nl_langinfo(CODESET);
   if(encoding && !strcmp(encoding, "UTF-8")){
-    loginfo(nc, "Set locale from LANG; client should call setlocale(2)!\n");
+    loginfo("Set locale from LANG; client should call setlocale(2)!\n");
     return;
   }
   setlocale(LC_CTYPE, "C.UTF-8");
   encoding = nl_langinfo(CODESET);
   if(encoding && !strcmp(encoding, "UTF-8")){
-    loginfo(nc, "Forced UTF-8 encoding; client should call setlocale(2)!\n");
+    loginfo("Forced UTF-8 encoding; client should call setlocale(2)!\n");
     return;
   }
 }
@@ -1010,7 +1010,7 @@ notcurses* notcurses_core_init(const notcurses_options* opts, FILE* outfp){
   ret->rstate.mstreamfp = NULL;
   ret->loglevel = opts->loglevel;
   if(!(opts->flags & NCOPTION_INHIBIT_SETLOCALE)){
-    init_lang(ret);
+    init_lang();
   }
   const char* encoding = nl_langinfo(CODESET);
   bool utf8;
@@ -1049,7 +1049,7 @@ notcurses* notcurses_core_init(const notcurses_options* opts, FILE* outfp){
     free(ret);
     return NULL;
   }
-  ret->ttyfd = get_tty_fd(ret, ret->ttyfp);
+  ret->ttyfd = get_tty_fd(ret->ttyfp);
   is_linux_console(ret, !!(opts->flags & NCOPTION_NO_FONT_CHANGES));
   if(ret->ttyfd < 0){
     fprintf(stderr, "Defaulting to %dx%d (output is not to a terminal)\n", DEFAULT_ROWS, DEFAULT_COLS);
@@ -1072,6 +1072,9 @@ notcurses* notcurses_core_init(const notcurses_options* opts, FILE* outfp){
     free(ret);
     return NULL;
   }
+  // don't set loglevel until we've acquired the signal handler, lest we
+  // change the loglevel out from under a running instance
+  loglevel = opts->loglevel;
   int termerr;
   if(setupterm(opts->termtype, ret->ttyfd, &termerr) != OK){
     fprintf(stderr, "Terminfo error %d (see terminfo(3ncurses))\n", termerr);
@@ -1506,9 +1509,8 @@ int cell_load(ncplane* n, nccell* c, const char* gcluster){
 static inline int
 ncplane_put(ncplane* n, int y, int x, const char* egc, int cols,
             uint16_t stylemask, uint64_t channels, int bytes){
-  const notcurses* nc = ncplane_notcurses_const(n);
   if(n->sprite){
-    logerror(nc, "Can't write glyphs (%s) to sprixelated plane\n", egc);
+    logerror("Can't write glyphs (%s) to sprixelated plane\n", egc);
     return -1;
   }
   // FIXME reject any control or space characters here--should be iswgraph()
@@ -1517,13 +1519,13 @@ ncplane_put(ncplane* n, int y, int x, const char* egc, int cols,
   // specified, we must always try to print at exactly that location.
   if(x != -1){
     if(x + cols > n->lenx){
-      logerror(nc, "Target x %d + %d cols >= length %d\n", x, cols, n->lenx);
+      logerror("Target x %d + %d cols >= length %d\n", x, cols, n->lenx);
       ncplane_cursor_move_yx(n, y, x); // update cursor, though
       return -1;
     }
   }else if(y == -1 && n->x + cols > n->lenx){
     if(!n->scrolling){
-      logerror(nc, "No room to output [%.*s] %d/%d\n", bytes, egc, n->y, n->x);
+      logerror("No room to output [%.*s] %d/%d\n", bytes, egc, n->y, n->x);
       return -1;
     }
     scroll_down(n);
@@ -1864,17 +1866,17 @@ int ncplane_box(ncplane* n, const nccell* ul, const nccell* ur,
   ncplane_cursor_yx(n, &yoff, &xoff);
   // must be at least 2x2, with its upper-left corner at the current cursor
   if(ystop < yoff + 1){
-    logerror(ncplane_notcurses(n), "ystop (%d) insufficient for yoff (%d)\n", ystop, yoff);
+    logerror("ystop (%d) insufficient for yoff (%d)\n", ystop, yoff);
     return -1;
   }
   if(xstop < xoff + 1){
-    logerror(ncplane_notcurses(n), "xstop (%d) insufficient for xoff (%d)\n", xstop, xoff);
+    logerror("xstop (%d) insufficient for xoff (%d)\n", xstop, xoff);
     return -1;
   }
   ncplane_dim_yx(n, &ymax, &xmax);
   // must be within the ncplane
   if(xstop >= xmax || ystop >= ymax){
-    logerror(ncplane_notcurses(n), "Boundary (%dx%d) beyond plane (%dx%d)\n", ystop, xstop, ymax, xmax);
+    logerror("Boundary (%dx%d) beyond plane (%dx%d)\n", ystop, xstop, ymax, xmax);
     return -1;
   }
   unsigned edges;
@@ -2061,24 +2063,23 @@ void ncplane_erase(ncplane* n){
 }
 
 int ncplane_erase_region(ncplane* n, int ystart, int xstart, int ylen, int xlen){
-  const notcurses* nc = ncplane_notcurses_const(n);
   if(ylen < 0 || xlen < 0){
-    logerror(nc, "Won't erase section of negative length (%d, %d)\n", ylen, xlen);
+    logerror("Won't erase section of negative length (%d, %d)\n", ylen, xlen);
     return -1;
   }
   if(ystart < 0 || xstart < 0){
-    logerror(nc, "Illegal start of erase (%d, %d)\n", ystart, xstart);
+    logerror("Illegal start of erase (%d, %d)\n", ystart, xstart);
     return -1;
   }
   if(ystart >= ncplane_dim_y(n) || ystart + ylen > ncplane_dim_y(n)){
-    logerror(nc, "Illegal y spec for erase (%d, %d)\n", ystart, ylen);
+    logerror("Illegal y spec for erase (%d, %d)\n", ystart, ylen);
     return -1;
   }
   if(ylen == 0){
     ylen = ncplane_dim_y(n) - ystart;
   }
   if(xstart >= ncplane_dim_x(n) || xstart + xlen > ncplane_dim_x(n)){
-    logerror(nc, "Illegal x spec for erase (%d, %d)\n", xstart, xlen);
+    logerror("Illegal x spec for erase (%d, %d)\n", xstart, xlen);
     return -1;
   }
   if(xlen == 0){
@@ -2322,14 +2323,13 @@ int ncplane_resize_maximize(ncplane* n){
 }
 
 int ncplane_resize_realign(ncplane* n){
-  const notcurses* nc = ncplane_notcurses_const(n);
   const ncplane* parent = ncplane_parent_const(n);
   if(parent == n){
-    logerror(nc, "Can't realign a root plane\n");
+    logerror("Can't realign a root plane\n");
     return 0;
   }
   if(n->halign == NCALIGN_UNALIGNED && n->valign == NCALIGN_UNALIGNED){
-    logerror(nc, "Passed a non-aligned plane\n");
+    logerror("Passed a non-aligned plane\n");
     return -1;
   }
   int xpos = ncplane_x(n);
@@ -2352,11 +2352,11 @@ int ncplane_resize_realign(ncplane* n){
 ncplane* ncplane_reparent(ncplane* n, ncplane* newparent){
   const notcurses* nc = ncplane_notcurses_const(n);
   if(n == nc->stdplane){
-    logerror(nc, "Won't reparent standard plane\n");
+    logerror("Won't reparent standard plane\n");
     return NULL; // can't reparent standard plane
   }
   if(n->boundto == newparent){
-    loginfo(nc, "Won't reparent plane to itself\n");
+    loginfo("Won't reparent plane to itself\n");
     return n;
   }
 //notcurses_debug(ncplane_notcurses(n), stderr);
@@ -2651,11 +2651,11 @@ ncplane_as_rgba_internal(const ncplane* nc, ncblitter_e blit,
                          int* pxdimy, int* pxdimx){
   const notcurses* ncur = ncplane_notcurses_const(nc);
   if(begy < 0 || begx < 0){
-    logerror(ncur, "Nil offset (%d,%d)\n", begy, begx);
+    logerror("Nil offset (%d,%d)\n", begy, begx);
     return NULL;
   }
   if(begx >= nc->lenx || begy >= nc->leny){
-    logerror(ncur, "Invalid offset (%d,%d)\n", begy, begx);
+    logerror("Invalid offset (%d,%d)\n", begy, begx);
     return NULL;
   }
   if(lenx == -1){ // -1 means "to the end"; use all space available
@@ -2665,26 +2665,26 @@ ncplane_as_rgba_internal(const ncplane* nc, ncblitter_e blit,
     leny = nc->leny - begy;
   }
   if(lenx <= 0 || leny <= 0){ // no need to draw zero-size object, exit
-    logerror(ncur, "Nil geometry (%dx%d)\n", leny, lenx);
+    logerror("Nil geometry (%dx%d)\n", leny, lenx);
     return NULL;
   }
 //fprintf(stderr, "sum: %d/%d avail: %d/%d\n", begy + leny, begx + lenx, nc->leny, nc->lenx);
   if(begx + lenx > nc->lenx || begy + leny > nc->leny){
-    logerror(ncur, "Invalid specs %d + %d > %d or %d + %d > %d\n",
+    logerror("Invalid specs %d + %d > %d or %d + %d > %d\n",
              begx, lenx, nc->lenx, begy, leny, nc->leny);
     return NULL;
   }
   if(blit == NCBLIT_PIXEL){ // FIXME extend this to support sprixels
-    logerror(ncur, "Pixel blitter %d not yet supported\n", blit);
+    logerror("Pixel blitter %d not yet supported\n", blit);
     return NULL;
   }
   if(blit == NCBLIT_DEFAULT){
-    logerror(ncur, "Must specify exact blitter, not NCBLIT_DEFAULT\n");
+    logerror("Must specify exact blitter, not NCBLIT_DEFAULT\n");
     return NULL;
   }
   const struct blitset* bset = lookup_blitset(&ncur->tcache, blit, false);
   if(bset == NULL){
-    logerror(ncur, "Blitter %d invalid in current environment\n", blit);
+    logerror("Blitter %d invalid in current environment\n", blit);
     return NULL;
   }
 //fprintf(stderr, "ALLOCATING %u %d %d %p\n", 4u * lenx * leny * 2, leny, lenx, bset);
@@ -2766,11 +2766,11 @@ uint32_t* ncplane_as_rgba(const ncplane* nc, ncblitter_e blit,
 // return a heap-allocated copy of the contents
 char* ncplane_contents(ncplane* nc, int begy, int begx, int leny, int lenx){
   if(begy < 0 || begx < 0){
-    logerror(ncplane_notcurses_const(nc), "Beginning coordinates (%d/%d) below 0\n", begy, begx);
+    logerror("Beginning coordinates (%d/%d) below 0\n", begy, begx);
     return NULL;
   }
   if(begx >= nc->lenx || begy >= nc->leny){
-    logerror(ncplane_notcurses_const(nc), "Beginning coordinates (%d/%d) exceeded lengths (%d/%d)\n",
+    logerror("Beginning coordinates (%d/%d) exceeded lengths (%d/%d)\n",
              begy, begx, nc->leny, nc->lenx);
     return NULL;
   }
@@ -2781,11 +2781,11 @@ char* ncplane_contents(ncplane* nc, int begy, int begx, int leny, int lenx){
     leny = nc->leny - begy;
   }
   if(lenx < 0 || leny < 0){ // no need to draw zero-size object, exit
-    logerror(ncplane_notcurses_const(nc), "Lengths (%d/%d) below 0\n", leny, lenx);
+    logerror("Lengths (%d/%d) below 0\n", leny, lenx);
     return NULL;
   }
   if(begx + lenx > nc->lenx || begy + leny > nc->leny){
-    logerror(ncplane_notcurses_const(nc), "Ending coordinates (%d/%d) exceeded lengths (%d/%d)\n",
+    logerror("Ending coordinates (%d/%d) exceeded lengths (%d/%d)\n",
              begy + leny, begx + lenx, nc->leny, nc->lenx);
     return NULL;
   }
diff --git a/src/lib/plot.c b/src/lib/plot.c
index 7a4f9dfd5..edc6ccd5c 100644
--- a/src/lib/plot.c
+++ b/src/lib/plot.c
@@ -219,16 +219,15 @@ create_##T(nc##X##plot* ncpp, ncplane* n, const ncplot_options* opts, const T mi
     opts = &zeroed; \
   } \
   if(opts->flags >= (NCPLOT_OPTION_PRINTSAMPLE << 1u)){ \
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags); \
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags); \
   } \
-  const notcurses* nc = ncplane_notcurses_const(n); \
   /* if miny == maxy (enabling domain detection), they both must be equal to 0 */ \
   if(miny == maxy && miny){ \
     ncplane_destroy(n); \
     return false; \
   } \
   if(opts->rangex < 0){ \
-    logerror(nc, "Supplied negative independent range %d\n", opts->rangex); \
+    logerror("Supplied negative independent range %d\n", opts->rangex); \
     ncplane_destroy(n); \
     return false; \
   } \
@@ -238,7 +237,7 @@ create_##T(nc##X##plot* ncpp, ncplane* n, const ncplot_options* opts, const T mi
   } \
   /* DETECTMAXONLY can't be used without domain detection */ \
   if(opts->flags & NCPLOT_OPTION_DETECTMAXONLY && (miny != maxy)){ \
-    logerror(nc, "Supplied DETECTMAXONLY without domain detection"); \
+    logerror("Supplied DETECTMAXONLY without domain detection"); \
     ncplane_destroy(n); \
     return false; \
   } \
diff --git a/src/lib/progbar.c b/src/lib/progbar.c
index 034a697a4..6c81b004f 100644
--- a/src/lib/progbar.c
+++ b/src/lib/progbar.c
@@ -8,7 +8,7 @@ ncprogbar* ncprogbar_create(ncplane* n, const ncprogbar_options* opts){
     opts = &default_opts;
   }
   if(opts->flags > (NCPROGBAR_OPTION_RETROGRADE << 1u)){
-    logwarn(ncplane_notcurses(n), "Invalid flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Invalid flags %016jx\n", (uintmax_t)opts->flags);
   }
   ncprogbar* ret = malloc(sizeof(*ret));
   if(ret){
@@ -169,7 +169,7 @@ progbar_redraw(ncprogbar* n){
 int ncprogbar_set_progress(ncprogbar* n, double p){
 //fprintf(stderr, "PROGRESS: %g\n", p);
   if(p < 0 || p > 1){
-    logerror(ncplane_notcurses(ncprogbar_plane(n)), "Invalid progress %g\n", p);
+    logerror("Invalid progress %g\n", p);
     return -1;
   }
   n->progress = p;
diff --git a/src/lib/reader.c b/src/lib/reader.c
index df833042f..b99341cf4 100644
--- a/src/lib/reader.c
+++ b/src/lib/reader.c
@@ -6,7 +6,7 @@ ncreader* ncreader_create(ncplane* n, const ncreader_options* opts){
     opts = &zeroed;
   }
   if(opts->flags > NCREADER_OPTION_CURSOR){
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
   }
   ncreader* nr = malloc(sizeof(*nr));
   if(nr == NULL){
@@ -187,7 +187,7 @@ int ncreader_move_down(ncreader* n){
 int ncreader_write_egc(ncreader* n, const char* egc){
   const int cols = ncstrwidth(egc);
   if(cols < 0){
-    logerror(ncplane_notcurses(n->ncp), "Fed illegal UTF-8 [%s]\n", egc);
+    logerror("Fed illegal UTF-8 [%s]\n", egc);
     return -1;
   }
   if(n->textarea->x >= n->textarea->lenx - cols){
diff --git a/src/lib/reel.c b/src/lib/reel.c
index f52d1bd01..638f4d7dd 100644
--- a/src/lib/reel.c
+++ b/src/lib/reel.c
@@ -298,7 +298,7 @@ ncreel_draw_tablet(const ncreel* nr, nctablet* t, int frontiertop,
     int ll = t->cbfxn(t, direction == DIRECTION_DOWN);
 //fprintf(stderr, "RETURNRETURNRETURN %p %d (%d, %d, %d) DIR %d\n", t, ll, cby, cbleny, leny, direction);
     if(ll > cbleny){
-      logwarn(ncplane_notcurses(nr->p), "Tablet callback returned %d lines, %d allowed\n", ll, cbleny);
+      logwarn("Tablet callback returned %d lines, %d allowed\n", ll, cbleny);
       ll = cbleny;
     }
     if(ll != cbleny){
@@ -669,7 +669,7 @@ int ncreel_redraw(ncreel* nr){
   if(focused){
 //fprintf(stderr, "drawing focused tablet %p dir: %d fulcrum: %d!\n", focused, nr->direction, fulcrum);
     if(ncreel_draw_tablet(nr, focused, fulcrum, fulcrum, DIRECTION_DOWN)){
-      logerror(ncplane_notcurses(nr->p), "Error drawing tablet\n");
+      logerror("Error drawing tablet\n");
       return -1;
     }
 //fprintf(stderr, "drew focused tablet %p -> %p lastdir: %d!\n", focused, focused->p, nr->direction);
@@ -681,25 +681,25 @@ int ncreel_redraw(ncreel* nr){
     if(nr->direction == LASTDIRECTION_DOWN){
       otherend = draw_previous_tablets(nr, otherend, &frontiertop, frontierbottom);
       if(otherend == NULL){
-        logerror(ncplane_notcurses(nr->p), "Error drawing higher tablets\n");
+        logerror("Error drawing higher tablets\n");
         return -1;
       }
       otherend = draw_following_tablets(nr, otherend, frontiertop, &frontierbottom);
     }else{ // DIRECTION_UP
       otherend = draw_previous_tablets(nr, otherend, &frontiertop, frontierbottom);
       if(otherend == NULL){
-        logerror(ncplane_notcurses(nr->p), "Error drawing higher tablets\n");
+        logerror("Error drawing higher tablets\n");
         return -1;
       }
       otherend = draw_following_tablets(nr, otherend, frontiertop, &frontierbottom);
     }
     if(otherend == NULL){
-      logerror(ncplane_notcurses(nr->p), "Error drawing following tablets\n");
+      logerror("Error drawing following tablets\n");
       return -1;
     }
 //notcurses_debug(ncplane_notcurses(nr->p), stderr);
     if(tighten_reel(nr)){
-      logerror(ncplane_notcurses(nr->p), "Error tightening reel\n");
+      logerror("Error tightening reel\n");
       return -1;
     }
 //notcurses_debug(ncplane_notcurses(nr->p), stderr);
@@ -707,7 +707,7 @@ int ncreel_redraw(ncreel* nr){
   nr->vft = nr->tablets; // update the visually-focused tablet pointer
 //fprintf(stderr, "DONE ARRANGING\n");
   if(draw_ncreel_borders(nr)){
-    logerror(ncplane_notcurses(nr->p), "Error drawing reel borders\n");
+    logerror("Error drawing reel borders\n");
     return -1; // enforces specified dimensional minima
   }
   return 0;
@@ -718,13 +718,12 @@ validate_ncreel_opts(ncplane* n, const ncreel_options* ropts){
   if(n == NULL){
     return false;
   }
-  const notcurses* nc = ncplane_notcurses_const(n);
   if(ropts->flags >= (NCREEL_OPTION_CIRCULAR << 1u)){
-    logwarn(nc, "Provided unsupported flags 0x%016jx\n", (uintmax_t)ropts->flags);
+    logwarn("Provided unsupported flags 0x%016jx\n", (uintmax_t)ropts->flags);
   }
   if(ropts->flags & NCREEL_OPTION_CIRCULAR){
     if(!(ropts->flags & NCREEL_OPTION_INFINITESCROLL)){
-      logerror(nc, "Can't set circular without infinitescroll\n");
+      logerror("Can't set circular without infinitescroll\n");
       return false; // can't set circular without infinitescroll
     }
   }
@@ -734,11 +733,11 @@ validate_ncreel_opts(ncplane* n, const ncreel_options* ropts){
                             NCBOXMASK_TOP |
                             NCBOXMASK_BOTTOM;
   if(ropts->bordermask > fullmask){
-    logerror(nc, "Bad bordermask: 0x%016x\n", ropts->bordermask);
+    logerror("Bad bordermask: 0x%016x\n", ropts->bordermask);
     return false;
   }
   if(ropts->tabletmask > fullmask){
-    logerror(nc, "Bad tabletmask: 0x%016x\n", ropts->bordermask);
+    logerror("Bad tabletmask: 0x%016x\n", ropts->bordermask);
     return false;
   }
   return true;
@@ -787,7 +786,7 @@ nctablet* ncreel_add(ncreel* nr, nctablet* after, nctablet *before,
   nctablet* t;
   if(after && before){
     if(after->next != before || before->prev != after){
-      logerror(ncplane_notcurses(nr->p), "bad before (%p) / after (%p) spec\n", before, after);
+      logerror("bad before (%p) / after (%p) spec\n", before, after);
       return NULL;
     }
   }else if(!after && !before){
diff --git a/src/lib/render.c b/src/lib/render.c
index 041646328..6433a0bcd 100644
--- a/src/lib/render.c
+++ b/src/lib/render.c
@@ -85,7 +85,7 @@ void cell_release(ncplane* n, nccell* c){
 // Duplicate one cell onto another when they share a plane. Convenience wrapper.
 int nccell_duplicate(ncplane* n, nccell* targ, const nccell* c){
   if(cell_duplicate_far(&n->pool, targ, n, c) < 0){
-    logerror(ncplane_notcurses(n), "Failed duplicating cell\n");
+    logerror("Failed duplicating cell\n");
     return -1;
   }
   return 0;
@@ -468,27 +468,27 @@ int ncplane_mergedown(ncplane* restrict src, ncplane* restrict dst,
                       int dsty, int dstx){
 //fprintf(stderr, "Merging down %d/%d @ %d/%d to %d/%d\n", leny, lenx, begsrcy, begsrcx, dsty, dstx);
   if(dsty >= dst->leny || dstx >= dst->lenx){
-    logerror(ncplane_notcurses_const(dst), "Dest origin %d/%d ≥ dest dimensions %d/%d\n",
+    logerror("Dest origin %d/%d ≥ dest dimensions %d/%d\n",
              dsty, dstx, dst->leny, dst->lenx);
     return -1;
   }
   if(dst->leny - leny < dsty || dst->lenx - lenx < dstx){
-    logerror(ncplane_notcurses_const(dst), "Dest len %d/%d ≥ dest dimensions %d/%d\n",
+    logerror("Dest len %d/%d ≥ dest dimensions %d/%d\n",
              leny, lenx, dst->leny, dst->lenx);
     return -1;
   }
   if(begsrcy >= src->leny || begsrcx >= src->lenx){
-    logerror(ncplane_notcurses_const(dst), "Source origin %d/%d ≥ source dimensions %d/%d\n",
+    logerror("Source origin %d/%d ≥ source dimensions %d/%d\n",
              begsrcy, begsrcx, src->leny, src->lenx);
     return -1;
   }
   if(src->leny - leny < begsrcy || src->lenx - lenx < begsrcx){
-    logerror(ncplane_notcurses_const(dst), "Source len %d/%d ≥ source dimensions %d/%d\n",
+    logerror("Source len %d/%d ≥ source dimensions %d/%d\n",
              leny, lenx, src->leny, src->lenx);
     return -1;
   }
   if(src->sprite || dst->sprite){
-    logerror(ncplane_notcurses_const(dst), "Can't merge sprixel planes\n");
+    logerror("Can't merge sprixel planes\n");
     return -1;
   }
   const int totalcells = dst->leny * dst->lenx;
@@ -496,7 +496,7 @@ int ncplane_mergedown(ncplane* restrict src, ncplane* restrict dst,
   const size_t crenderlen = sizeof(struct crender) * totalcells;
   struct crender* rvec = malloc(crenderlen);
   if(!rendfb || !rvec){
-    logerror(ncplane_notcurses_const(dst), "Error allocating render state for %dx%d\n", leny, lenx);
+    logerror("Error allocating render state for %dx%d\n", leny, lenx);
     free(rendfb);
     free(rvec);
     return -1;
@@ -1460,11 +1460,11 @@ int notcurses_cursor_yx(notcurses* nc, int* y, int* x){
 
 int notcurses_cursor_enable(notcurses* nc, int y, int x){
   if(y < 0 || x < 0){
-    logerror(nc, "Illegal cursor placement: %d, %d\n", y, x);
+    logerror("Illegal cursor placement: %d, %d\n", y, x);
     return -1;
   }
   if(y >= nc->margin_t || x >= nc->margin_l){
-    logerror(nc, "Illegal cursor placement: %d, %d\n", y, x);
+    logerror("Illegal cursor placement: %d, %d\n", y, x);
     return -1;
   }
   // if we're already at the demanded location, we must already be visible, and
@@ -1496,7 +1496,7 @@ int notcurses_cursor_enable(notcurses* nc, int y, int x){
 
 int notcurses_cursor_disable(notcurses* nc){
   if(nc->cursorx < 0 || nc->cursory < 0){
-    logerror(nc, "Cursor is not enabled\n");
+    logerror("Cursor is not enabled\n");
     return -1;
   }
   if(nc->ttyfd >= 0){
diff --git a/src/lib/selector.c b/src/lib/selector.c
index 079d1093d..f11814de0 100644
--- a/src/lib/selector.c
+++ b/src/lib/selector.c
@@ -238,7 +238,7 @@ ncselector* ncselector_create(ncplane* n, const ncselector_options* opts){
   }
   unsigned itemcount = 0;
   if(opts->flags > 0){
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
   }
   if(opts->items){
     for(const struct ncselector_item* i = opts->items ; i->option ; ++i){
@@ -834,7 +834,7 @@ ncmultiselector* ncmultiselector_create(ncplane* n, const ncmultiselector_option
     opts = &zeroed;
   }
   if(opts->flags > 0){
-    logwarn(ncplane_notcurses(n), "Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
+    logwarn("Provided unsupported flags %016jx\n", (uintmax_t)opts->flags);
   }
   unsigned itemcount = 0;
   if(opts->items){
diff --git a/src/lib/signal.c b/src/lib/signal.c
index 1c1d583f6..42a82075c 100644
--- a/src/lib/signal.c
+++ b/src/lib/signal.c
@@ -113,7 +113,7 @@ int setup_signals(void* vnc, bool no_quit_sigs, bool no_winch_sig,
   // don't register ourselves if we don't intend to set up signal handlers
   // we expect NULL (nothing registered), and want to register nc
   if(!atomic_compare_exchange_strong(&signal_nc, &expected, nc)){
-    loginfo(nc, "%p is already registered for signals (provided %p)\n", expected, nc);
+    loginfo("%p is already registered for signals (provided %p)\n", expected, nc);
     return -1;
   }
   if(!no_winch_sig){
diff --git a/src/lib/tabbed.c b/src/lib/tabbed.c
index a475a54d6..369539bb5 100644
--- a/src/lib/tabbed.c
+++ b/src/lib/tabbed.c
@@ -71,13 +71,12 @@ void nctabbed_ensure_selected_header_visible(nctabbed* nt){
 }
 
 static bool
-nctabbed_validate_opts(ncplane* n, const nctabbed_options* opts){
-  notcurses* nc = ncplane_notcurses(n);
+nctabbed_validate_opts(const nctabbed_options* opts){
   if(opts->flags > NCTABBED_OPTION_BOTTOM){
-    logwarn(nc, "Provided unsupported flags 0x%016jx\n", (uint64_t)opts->flags);
+    logwarn("Provided unsupported flags 0x%016jx\n", (uint64_t)opts->flags);
   }
   if(opts->sepchan && !opts->separator){
-    logwarn(nc, "Provided non-zero separator channel when separator is NULL")
+    logwarn("Provided non-zero separator channel when separator is NULL")
   }
   return true;
 }
@@ -131,15 +130,14 @@ nctabbed* nctabbed_create(ncplane* n, const nctabbed_options* topts){
   ncplane_options nopts = {};
   int nrows, ncols;
   nctabbed* nt;
-  notcurses* nc = ncplane_notcurses(n);
   if(!topts){
     topts = &zeroed;
   }
-  if(!nctabbed_validate_opts(n, topts)){
+  if(!nctabbed_validate_opts(topts)){
     return NULL;
   }
   if((nt = malloc(sizeof(*nt))) == NULL){
-    logerror(nc, "Couldn't allocate nctabbed");
+    logerror("Couldn't allocate nctabbed");
     return NULL;
   }
   nt->ncp = n;
@@ -148,12 +146,12 @@ nctabbed* nctabbed_create(ncplane* n, const nctabbed_options* topts){
   memcpy(&nt->opts, topts, sizeof(*topts));
   if(nt->opts.separator){
     if((nt->opts.separator = strdup(nt->opts.separator)) == NULL){
-      logerror(nc, "Couldn't allocate nctabbed separator");
+      logerror("Couldn't allocate nctabbed separator");
       free(nt);
       return NULL;
     }
     if((nt->sepcols = ncstrwidth(nt->opts.separator)) < 0){
-      logerror(nc, "Separator string contains illegal characters");
+      logerror("Separator string contains illegal characters");
       free(nt->opts.separator);
       free(nt);
       return NULL;
@@ -167,7 +165,7 @@ nctabbed* nctabbed_create(ncplane* n, const nctabbed_options* topts){
     nopts.cols = ncols;
     nopts.rows = nrows - 1;
     if((nt->p = ncplane_create(n, &nopts)) == NULL){
-      logerror(nc, "Couldn't create the tab content plane");
+      logerror("Couldn't create the tab content plane");
       ncplane_genocide(n);
       free(nt);
       return NULL;
@@ -175,7 +173,7 @@ nctabbed* nctabbed_create(ncplane* n, const nctabbed_options* topts){
     nopts.y = nrows - 2;
     nopts.rows = 1;
     if((nt->hp = ncplane_create(n, &nopts)) == NULL){
-      logerror(nc, "Couldn't create the tab headers plane");
+      logerror("Couldn't create the tab headers plane");
       ncplane_genocide(n);
       free(nt);
       return NULL;
@@ -185,7 +183,7 @@ nctabbed* nctabbed_create(ncplane* n, const nctabbed_options* topts){
     nopts.cols = ncols;
     nopts.rows = 1;
     if((nt->hp = ncplane_create(n, &nopts)) == NULL){
-      logerror(nc, "Couldn't create the tab headers plane");
+      logerror("Couldn't create the tab headers plane");
       ncplane_genocide(n);
       free(nt);
       return NULL;
@@ -193,7 +191,7 @@ nctabbed* nctabbed_create(ncplane* n, const nctabbed_options* topts){
     nopts.y = 1;
     nopts.rows = nrows - 1;
     if((nt->p = ncplane_create(n, &nopts)) == NULL){
-      logerror(nc, "Couldn't create the tab content plane");
+      logerror("Couldn't create the tab content plane");
       ncplane_genocide(n);
       free(nt);
       return NULL;
@@ -206,10 +204,9 @@ nctabbed* nctabbed_create(ncplane* n, const nctabbed_options* topts){
 nctab* nctabbed_add(nctabbed* nt, nctab* after, nctab* before, tabcb cb,
                     const char* name, void* opaque){
   nctab* t;
-  notcurses* nc = ncplane_notcurses(nt->ncp);
   if(after && before){
     if(after->next != before || before->prev != after){
-      logerror(ncplane_notcurses(nt->ncp), "bad before (%p) / after (%p) spec\n", before, after);
+      logerror("bad before (%p) / after (%p) spec\n", before, after);
       return NULL;
     }
   }else if(!after && !before){
@@ -217,16 +214,16 @@ nctab* nctabbed_add(nctabbed* nt, nctab* after, nctab* before, tabcb cb,
     after = nt->selected;
   }
   if((t = malloc(sizeof(*t))) == NULL){
-    logerror(nc, "Couldn't allocate nctab")
+    logerror("Couldn't allocate nctab")
     return NULL;
   }
   if((t->name = strdup(name)) == NULL){
-    logerror(nc, "Couldn't allocate the tab name");
+    logerror("Couldn't allocate the tab name");
     free(t);
     return NULL;
   }
   if((t->namecols = ncstrwidth(name)) < 0){
-    logerror(nc, "Tab name contains illegal characters")
+    logerror("Tab name contains illegal characters")
     free(t->name);
     free(t);
     return NULL;
@@ -255,7 +252,7 @@ nctab* nctabbed_add(nctabbed* nt, nctab* after, nctab* before, tabcb cb,
 
 int nctabbed_del(nctabbed* nt, nctab* t){
   if(!t){
-    logerror(ncplane_notcurses(nt->ncp), "Provided NULL nctab");
+    logerror("Provided NULL nctab");
     return -1;
   }
   if(nt->tabcount == 1){
@@ -275,19 +272,19 @@ int nctabbed_del(nctabbed* nt, nctab* t){
   return 0;
 }
 
-int nctab_move(nctabbed* nt, nctab* t, nctab* after, nctab* before){
+int nctab_move(nctabbed* nt __attribute__ ((unused)), nctab* t, nctab* after, nctab* before){
   if(after && before){
     if(after->prev != before || before->next != after){
-      logerror(ncplane_notcurses(nt->ncp), "bad before (%p) / after (%p) spec\n", before, after);
+      logerror("bad before (%p) / after (%p) spec\n", before, after);
       return -1;
     }
   }else if(!after && !before){
-    logerror(ncplane_notcurses(nt->ncp), "bad before (%p) / after (%p) spec\n", before, after);
+    logerror("bad before (%p) / after (%p) spec\n", before, after);
     return -1;
   }
   // bad things would happen
   if(t == after || t == before){
-    logerror(ncplane_notcurses(nt->ncp), "Cannot move a tab before or after itself.");
+    logerror("Cannot move a tab before or after itself.");
     return -1;
   }
   t->prev->next = t->next;
@@ -427,13 +424,12 @@ tabcb nctab_set_cb(nctab* t, tabcb newcb){
 int nctab_set_name(nctab* t, const char* newname){
   int newnamecols;
   char* prevname = t->name;
-  notcurses* nc = ncplane_notcurses(t->nt->ncp);
   if((newnamecols = ncstrwidth(newname)) < 0){
-    logerror(nc, "New tab name contains illegal characters");
+    logerror("New tab name contains illegal characters");
     return -1;
   }
   if((t->name = strdup(newname)) == NULL){
-    logerror(nc, "Couldn't allocate new tab name");
+    logerror("Couldn't allocate new tab name");
     t->name = prevname;
     return -1;
   }
@@ -451,13 +447,12 @@ void* nctab_set_userptr(nctab* t, void* newopaque){
 int nctabbed_set_separator(nctabbed* nt, const char* separator){
   int newsepcols;
   char* prevsep = nt->opts.separator;
-  notcurses* nc = ncplane_notcurses(nt->ncp);
   if((newsepcols = ncstrwidth(separator)) < 0){
-    logerror(nc, "New tab separator contains illegal characters");
+    logerror("New tab separator contains illegal characters");
     return -1;
   }
   if((nt->opts.separator = strdup(separator)) == NULL){
-    logerror(nc, "Couldn't allocate new tab separator");
+    logerror("Couldn't allocate new tab separator");
     nt->opts.separator = prevsep;
     return -1;
   }
diff --git a/src/lib/tree.c b/src/lib/tree.c
index 4f48282f3..7e9fc9701 100644
--- a/src/lib/tree.c
+++ b/src/lib/tree.c
@@ -123,25 +123,24 @@ nctree_inner_create(ncplane* n, const struct nctree_options* opts){
 }
 
 nctree* nctree_create(ncplane* n, const struct nctree_options* opts){
-  notcurses* nc = ncplane_notcurses(n);
   if(opts->flags){
-    logwarn(nc, "Passed invalid flags 0x%016jx\n", (uint64_t)opts->flags);
+    logwarn("Passed invalid flags 0x%016jx\n", (uint64_t)opts->flags);
   }
   if(opts->count == 0 || opts->items == NULL){
-    logerror(nc, "Can't create empty tree\n");
+    logerror("Can't create empty tree\n");
     goto error;
   }
   if(opts->nctreecb == NULL){
-    logerror(nc, "Can't use NULL callback\n");
+    logerror("Can't use NULL callback\n");
     goto error;
   }
   if(opts->indentcols < 0){
-    logerror(nc, "Can't indent negative columns\n");
+    logerror("Can't indent negative columns\n");
     goto error;
   }
   nctree* ret = nctree_inner_create(n, opts);
   if(ret == NULL){
-    logerror(nc, "Couldn't prepare nctree\n");
+    logerror("Couldn't prepare nctree\n");
     goto error;
   }
   return ret;
diff --git a/src/lib/visual.c b/src/lib/visual.c
index 3c4e1c81d..5be135314 100644
--- a/src/lib/visual.c
+++ b/src/lib/visual.c
@@ -17,9 +17,9 @@
 ncvisual_implementation visual_implementation = { };
 
 // to be called at startup -- performs any necessary engine initialization.
-int ncvisual_init(int loglevel){
+int ncvisual_init(int logl){
   if(visual_implementation.visual_init){
-    return visual_implementation.visual_init(loglevel);
+    return visual_implementation.visual_init(logl);
   }
   return 0;
 }
@@ -139,10 +139,10 @@ int ncvisual_blitset_geom(const notcurses* nc, const tinfo* tcache,
     lenx = &fakelenx;
   }
   if(vopts && vopts->flags >= (NCVISUAL_OPTION_NOINTERPOLATE << 1u)){
-    logwarn(nc, "Warning: unknown ncvisual options %016jx\n", (uintmax_t)vopts->flags);
+    logwarn("Warning: unknown ncvisual options %016jx\n", (uintmax_t)vopts->flags);
   }
   if(vopts && (vopts->flags & NCVISUAL_OPTION_CHILDPLANE) && !vopts->n){
-    logerror(nc, "Requested child plane with NULL n\n");
+    logerror("Requested child plane with NULL n\n");
     return -1;
   }
   int begy, begx;
@@ -151,18 +151,18 @@ int ncvisual_blitset_geom(const notcurses* nc, const tinfo* tcache,
   *leny = vopts ? vopts->leny : 0;
 //fprintf(stderr, "blit %dx%d+%dx%d %p\n", begy, begx, *leny, *lenx, ncv->data);
   if(begy < 0 || begx < 0 || *lenx <= -1 || *leny <= -1){
-    logerror(nc, "Invalid geometry for visual %d %d %d %d\n", begy, begx, *leny, *lenx);
+    logerror("Invalid geometry for visual %d %d %d %d\n", begy, begx, *leny, *lenx);
     return -1;
   }
   if(n){
 //fprintf(stderr, "OUR DATA: %p rows/cols: %d/%d\n", n->data, n->pixy, n->pixx);
     if(n->data == NULL){
-      logerror(nc, "No data in visual\n");
+      logerror("No data in visual\n");
       return -1;
     }
 //fprintf(stderr, "blit %d/%d to %dx%d+%dx%d scaling: %d\n", n->pixy, n->pixx, begy, begx, *leny, *lenx, vopts ? vopts->scaling : 0);
     if(begx >= n->pixx || begy >= n->pixy){
-      logerror(nc, "Visual too large %d > %d or %d > %d\n", begy, n->pixy, begx, n->pixx);
+      logerror("Visual too large %d > %d or %d > %d\n", begy, n->pixy, begx, n->pixx);
       return -1;
     }
     if(*lenx == 0){ // 0 means "to the end"; use all available source material
@@ -173,17 +173,17 @@ int ncvisual_blitset_geom(const notcurses* nc, const tinfo* tcache,
     }
 //fprintf(stderr, "blit %d/%d to %dx%d+%dx%d scaling: %d flags: 0x%016lx\n", n->pixy, n->pixx, begy, begx, *leny, *lenx, vopts ? vopts->scaling : 0, vopts ? vopts->flags : 0);
     if(*lenx <= 0 || *leny <= 0){ // no need to draw zero-size object, exit
-      logerror(nc, "Zero-size object %d %d\n", *leny, *lenx);
+      logerror("Zero-size object %d %d\n", *leny, *lenx);
       return -1;
     }
     if(begx + *lenx > n->pixx || begy + *leny > n->pixy){
-      logerror(nc, "Geometry too large %d > %d or %d > %d\n", begy + *leny, n->pixy, begx + *lenx, n->pixx);
+      logerror("Geometry too large %d > %d or %d > %d\n", begy + *leny, n->pixy, begx + *lenx, n->pixx);
       return -1;
     }
   }
   const struct blitset* bset = rgba_blitter(tcache, vopts);
   if(!bset){
-    logerror(nc, "Couldn't get a blitter for %d\n", vopts ? vopts->blitter : NCBLIT_DEFAULT);
+    logerror("Couldn't get a blitter for %d\n", vopts ? vopts->blitter : NCBLIT_DEFAULT);
     return -1;
   }
   if(blitter){
@@ -192,27 +192,27 @@ int ncvisual_blitset_geom(const notcurses* nc, const tinfo* tcache,
   if(bset->geom == NCBLIT_PIXEL && vopts){
     if(vopts->n){
       if(vopts->n == notcurses_stdplane_const(nc)){
-        logerror(nc, "Won't blit bitmaps to the standard plane\n");
+        logerror("Won't blit bitmaps to the standard plane\n");
         return -1;
       }
       if(vopts->y && !(vopts->flags & NCVISUAL_OPTION_VERALIGNED)){
-        logerror(nc, "Non-origin y placement %d for sprixel\n", vopts->y);
+        logerror("Non-origin y placement %d for sprixel\n", vopts->y);
         return -1;
       }
       if(vopts->x && !(vopts->flags & NCVISUAL_OPTION_HORALIGNED)){
-        logerror(nc, "Non-origin x placement %d for sprixel\n", vopts->x);
+        logerror("Non-origin x placement %d for sprixel\n", vopts->x);
         return -1;
       }
       // FIXME clamp to sprixel limits
       if(vopts->scaling == NCSCALE_NONE || vopts->scaling == NCSCALE_NONE_HIRES){
         int rows = (*leny + nc->tcache.cellpixy - 1) / nc->tcache.cellpixy;
         if(rows > ncplane_dim_y(vopts->n)){
-          logerror(nc, "Sprixel too tall %d for plane %d\n", *leny, ncplane_dim_y(vopts->n) * nc->tcache.cellpixy);
+          logerror("Sprixel too tall %d for plane %d\n", *leny, ncplane_dim_y(vopts->n) * nc->tcache.cellpixy);
           return -1;
         }
         int cols = (*lenx + nc->tcache.cellpixx - 1) / nc->tcache.cellpixx;
         if(cols > ncplane_dim_x(vopts->n)){
-          logerror(nc, "Sprixel too wide %d for plane %d\n", *lenx, ncplane_dim_x(vopts->n) * nc->tcache.cellpixx);
+          logerror("Sprixel too wide %d for plane %d\n", *lenx, ncplane_dim_x(vopts->n) * nc->tcache.cellpixx);
           return -1;
         }
       }
@@ -234,13 +234,13 @@ int ncvisual_blitset_geom(const notcurses* nc, const tinfo* tcache,
   }
   if(vopts && vopts->flags & NCVISUAL_OPTION_HORALIGNED){
     if(vopts->x < NCALIGN_UNALIGNED || vopts->x > NCALIGN_RIGHT){
-      logerror(nc, "Bad x %d for horizontal alignment\n", vopts->x);
+      logerror("Bad x %d for horizontal alignment\n", vopts->x);
       return -1;
     }
   }
   if(vopts && vopts->flags & NCVISUAL_OPTION_VERALIGNED){
     if(vopts->y < NCALIGN_UNALIGNED || vopts->y > NCALIGN_RIGHT){
-      logerror(nc, "Bad y %d for vertical alignment\n", vopts->y);
+      logerror("Bad y %d for vertical alignment\n", vopts->y);
       return -1;
     }
   }
@@ -838,7 +838,7 @@ ncplane* ncvisual_render_pixels(notcurses* nc, ncvisual* ncv, const struct blits
                                 uint64_t flags, uint32_t transcolor){
   ncplane* stdn = notcurses_stdplane(nc);
   if(n == stdn){
-    logerror(nc, "Won't blit bitmaps to the standard plane\n");
+    logerror("Won't blit bitmaps to the standard plane\n");
     return NULL;
   }
   int disppixy = 0, disppixx = 0, outy = 0;
diff --git a/src/media/ffmpeg.c b/src/media/ffmpeg.c
index eae7a1eb2..8536dcb5d 100644
--- a/src/media/ffmpeg.c
+++ b/src/media/ffmpeg.c
@@ -588,8 +588,8 @@ int ffmpeg_log_level(int level){
   return AV_LOG_TRACE;
 }
 
-int ffmpeg_init(int loglevel){
-  av_log_set_level(ffmpeg_log_level(loglevel));
+int ffmpeg_init(int logl){
+  av_log_set_level(ffmpeg_log_level(logl));
   // FIXME could also use av_log_set_callback() and capture the message...
   return 0;
 }
diff --git a/src/media/oiio-indep.c b/src/media/oiio-indep.c
index 063209a90..b7d757af8 100644
--- a/src/media/oiio-indep.c
+++ b/src/media/oiio-indep.c
@@ -70,7 +70,7 @@ char* oiio_subtitle(const ncvisual* ncv) { // no support in OIIO
   return NULL;
 }
 
-int oiio_init(int loglevel __attribute__ ((unused))) {
+int oiio_init(int logl __attribute__ ((unused))) {
   // FIXME set OIIO global attribute "debug" based on loglevel
   // FIXME check OIIO_VERSION_STRING components against linked openimageio_version()
   return 0; // allow success here
diff --git a/src/tests/main.cpp b/src/tests/main.cpp
index 59ad1f40e..9659a4db1 100644
--- a/src/tests/main.cpp
+++ b/src/tests/main.cpp
@@ -13,13 +13,13 @@
 #include <langinfo.h>
 
 const char* datadir = NOTCURSES_SHARE;
-ncloglevel_e loglevel = NCLOGLEVEL_SILENT;
+ncloglevel_e cliloglevel = NCLOGLEVEL_SILENT;
 
 auto testing_notcurses() -> struct notcurses* {
   notcurses_options nopts{};
   // get loglevel from command line. enabling it by default leads to
   // more confusion than useful information, so leave it off by default.
-  nopts.loglevel = loglevel;
+  nopts.loglevel = cliloglevel;
   nopts.flags = NCOPTION_SUPPRESS_BANNERS | NCOPTION_NO_ALTERNATE_SCREEN;
   auto nc = notcurses_init(&nopts, nullptr);
   return nc;
@@ -53,7 +53,7 @@ handle_opts(const char** argv){
     }else if(strcmp(*argv, "-p") == 0){
       inarg = true;
     }else if(strncmp(*argv, "-l", 2) == 0){ // just require -l
-      loglevel = NCLOGLEVEL_TRACE;
+      cliloglevel = NCLOGLEVEL_TRACE;
     }
     ++argv;
   }