diff --git a/NEWS.md b/NEWS.md
index 590fb3dd8..814373d59 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -12,6 +12,9 @@ rearrangements of Notcurses.
     size of the plane and cells in pixels, as well as the maximum bitmap
     size that can be displayed.
   * added new function `ncdirect_stream()`, which does what you'd think.
+  * `cell_release()` and `cell_duplicate()` have been migrated to
+    `nccell_release()` and `nccell_duplicate()`, respectively. The former
+    forms have been deprecated, and will be removed in API3.
 
 * 2.2.5 (2021-04-04)
   * Bugfix release, no user-visible changes.
diff --git a/include/ncpp/Plane.hh b/include/ncpp/Plane.hh
index f82204cbd..a00a0cedf 100644
--- a/include/ncpp/Plane.hh
+++ b/include/ncpp/Plane.hh
@@ -1088,17 +1088,17 @@ namespace ncpp
 
 		void release (Cell &cell) const noexcept
 		{
-			cell_release (plane, cell);
+			nccell_release (plane, cell);
 		}
 
 		int duplicate (Cell &target, Cell &source) const NOEXCEPT_MAYBE
 		{
-			return error_guard<int> (cell_duplicate (plane, target, source), -1);
+			return error_guard<int> (nccell_duplicate (plane, target, source), -1);
 		}
 
 		int duplicate (Cell &target, Cell const& source) const NOEXCEPT_MAYBE
 		{
-			return error_guard<int> (cell_duplicate (plane, target, source), -1);
+			return error_guard<int> (nccell_duplicate (plane, target, source), -1);
 		}
 
 		int duplicate (Cell &target, Cell *source) const
diff --git a/include/notcurses/notcurses.h b/include/notcurses/notcurses.h
index 7fa259d68..ec65b5882 100644
--- a/include/notcurses/notcurses.h
+++ b/include/notcurses/notcurses.h
@@ -662,10 +662,20 @@ cell_prime(struct ncplane* n, nccell* c, const char* gcluster,
 
 // Duplicate 'c' into 'targ'; both must be/will be bound to 'n'. Returns -1 on
 // failure, and 0 on success.
-API int cell_duplicate(struct ncplane* n, nccell* targ, const nccell* c);
+API int nccell_duplicate(struct ncplane* n, nccell* targ, const nccell* c);
+
+__attribute__ ((deprecated)) static inline int
+cell_duplicate(struct ncplane* n, nccell* targ, const nccell* c){
+  return nccell_duplicate(n, targ, c);
+}
 
 // Release resources held by the nccell 'c'.
-API void cell_release(struct ncplane* n, nccell* c);
+API void nccell_release(struct ncplane* n, nccell* c);
+
+__attribute__ ((deprecated)) static inline void
+cell_release(struct ncplane* n, nccell* c){
+  nccell_release(n, c);
+}
 
 #define NCSTYLE_MASK      0x03ffu
 #define NCSTYLE_STANDOUT  0x0080u
@@ -2263,7 +2273,7 @@ API void ncfadectx_free(struct ncfadectx* nctx);
 
 // load up six cells with the EGCs necessary to draw a box. returns 0 on
 // success, -1 on error. on error, any cells this function might
-// have loaded before the error are cell_release()d. There must be at least
+// have loaded before the error are nccell_release()d. There must be at least
 // six EGCs in gcluster.
 static inline int
 cells_load_box(struct ncplane* n, uint32_t styles, uint64_t channels,
@@ -2278,15 +2288,15 @@ cells_load_box(struct ncplane* n, uint32_t styles, uint64_t channels,
             if(cell_prime(n, vl, gclusters + ulen, styles, channels) > 0){
               return 0;
             }
-            cell_release(n, hl);
+            nccell_release(n, hl);
           }
-          cell_release(n, lr);
+          nccell_release(n, lr);
         }
-        cell_release(n, ll);
+        nccell_release(n, ll);
       }
-      cell_release(n, ur);
+      nccell_release(n, ur);
     }
-    cell_release(n, ul);
+    nccell_release(n, ul);
   }
   return -1;
 }
@@ -2305,9 +2315,9 @@ ncplane_rounded_box(struct ncplane* n, uint32_t styles, uint64_t channels,
   if((ret = cells_rounded_box(n, styles, channels, &ul, &ur, &ll, &lr, &hl, &vl)) == 0){
     ret = ncplane_box(n, &ul, &ur, &ll, &lr, &hl, &vl, ystop, xstop, ctlword);
   }
-  cell_release(n, &ul); cell_release(n, &ur);
-  cell_release(n, &ll); cell_release(n, &lr);
-  cell_release(n, &hl); cell_release(n, &vl);
+  nccell_release(n, &ul); nccell_release(n, &ur);
+  nccell_release(n, &ll); nccell_release(n, &lr);
+  nccell_release(n, &hl); nccell_release(n, &vl);
   return ret;
 }
 
@@ -2329,9 +2339,9 @@ ncplane_perimeter_rounded(struct ncplane* n, uint32_t stylemask,
     return -1;
   }
   int r = ncplane_box_sized(n, &ul, &ur, &ll, &lr, &hl, &vl, dimy, dimx, ctlword);
-  cell_release(n, &ul); cell_release(n, &ur);
-  cell_release(n, &ll); cell_release(n, &lr);
-  cell_release(n, &hl); cell_release(n, &vl);
+  nccell_release(n, &ul); nccell_release(n, &ur);
+  nccell_release(n, &ll); nccell_release(n, &lr);
+  nccell_release(n, &hl); nccell_release(n, &vl);
   return r;
 }
 
@@ -2358,9 +2368,9 @@ ncplane_double_box(struct ncplane* n, uint32_t styles, uint64_t channels,
   if((ret = cells_double_box(n, styles, channels, &ul, &ur, &ll, &lr, &hl, &vl)) == 0){
     ret = ncplane_box(n, &ul, &ur, &ll, &lr, &hl, &vl, ystop, xstop, ctlword);
   }
-  cell_release(n, &ul); cell_release(n, &ur);
-  cell_release(n, &ll); cell_release(n, &lr);
-  cell_release(n, &hl); cell_release(n, &vl);
+  nccell_release(n, &ul); nccell_release(n, &ur);
+  nccell_release(n, &ll); nccell_release(n, &lr);
+  nccell_release(n, &hl); nccell_release(n, &vl);
   return ret;
 }
 
@@ -2382,9 +2392,9 @@ ncplane_perimeter_double(struct ncplane* n, uint32_t stylemask,
     return -1;
   }
   int r = ncplane_box_sized(n, &ul, &ur, &ll, &lr, &hl, &vl, dimy, dimx, ctlword);
-  cell_release(n, &ul); cell_release(n, &ur);
-  cell_release(n, &ll); cell_release(n, &lr);
-  cell_release(n, &hl); cell_release(n, &vl);
+  nccell_release(n, &ul); nccell_release(n, &ur);
+  nccell_release(n, &ll); nccell_release(n, &lr);
+  nccell_release(n, &hl); nccell_release(n, &vl);
   return r;
 }
 
diff --git a/src/demo/boxdemo.c b/src/demo/boxdemo.c
index 19616fd34..34327a8f1 100644
--- a/src/demo/boxdemo.c
+++ b/src/demo/boxdemo.c
@@ -95,7 +95,7 @@ int box_demo(struct notcurses* nc){
   nccell c = CELL_CHAR_INITIALIZER(' ');
   cell_set_bg_default(&c);
   ncplane_set_base_cell(n, &c);
-  cell_release(n, &c);
+  nccell_release(n, &c);
   ncplane_set_fg_rgb8(n, 180, 40, 180);
   ncplane_set_bg_default(n);
   if(notcurses_canutf8(nc)){
@@ -177,11 +177,11 @@ int box_demo(struct notcurses* nc){
     DEMO_RENDER(nc);
     nanosleep(&iterdelay, NULL);
   }
-  cell_release(n, &ul);
-  cell_release(n, &ur);
-  cell_release(n, &ll);
-  cell_release(n, &lr);
-  cell_release(n, &hl);
-  cell_release(n, &vl);
+  nccell_release(n, &ul);
+  nccell_release(n, &ur);
+  nccell_release(n, &ll);
+  nccell_release(n, &lr);
+  nccell_release(n, &hl);
+  nccell_release(n, &vl);
   return 0;
 }
diff --git a/src/demo/demo.c b/src/demo/demo.c
index b5122bc9f..c24e37de9 100644
--- a/src/demo/demo.c
+++ b/src/demo/demo.c
@@ -222,7 +222,7 @@ ext_demos(struct notcurses* nc, const char* spec){
     cell_set_fg_rgb8(&c, 0, 0, 0);
     cell_set_bg_rgb8(&c, 0, 0, 0);
     ncplane_set_base_cell(n, &c);
-    cell_release(n, &c);
+    nccell_release(n, &c);
 
     hud_schedule(demos[idx].name);
     ret = demos[idx].fxn(nc);
diff --git a/src/demo/eagle.c b/src/demo/eagle.c
index 09d198e7b..e110be9d0 100644
--- a/src/demo/eagle.c
+++ b/src/demo/eagle.c
@@ -118,7 +118,7 @@ draw_eagle(struct ncplane* n, const char* sprite){
   cell_set_fg_alpha(&bgc, CELL_ALPHA_TRANSPARENT);
   cell_set_bg_alpha(&bgc, CELL_ALPHA_TRANSPARENT);
   ncplane_set_base_cell(n, &bgc);
-  cell_release(n, &bgc);
+  nccell_release(n, &bgc);
   size_t s;
   int sbytes;
   for(s = 0 ; sprite[s] ; ++s){
diff --git a/src/demo/fallin.c b/src/demo/fallin.c
index c71ca3f35..0e270087c 100644
--- a/src/demo/fallin.c
+++ b/src/demo/fallin.c
@@ -163,13 +163,13 @@ int fallin_demo(struct notcurses* nc){
               // allow a fail if we were printing a wide char to the
               // last column of our plane
               if(!cell_double_wide_p(&c) || usex + 1 < x + newx){
-                cell_release(n, &c);
+                nccell_release(n, &c);
                 goto err;
               }
             }
           }
           usemap[usey * dimx + usex] = true;
-          cell_release(n, &c);
+          nccell_release(n, &c);
         }
       }
       // shuffle the new ncplane into the array
diff --git a/src/demo/grid.c b/src/demo/grid.c
index 821626214..5509583b3 100644
--- a/src/demo/grid.c
+++ b/src/demo/grid.c
@@ -23,15 +23,15 @@ release_cells(struct ncplane* n,
               nccell* ul, nccell* uc, nccell* ur,
               nccell* cl, nccell* cc, nccell* cr,
               nccell* ll, nccell* lc, nccell* lr){
-  cell_release(n, ul);
-  cell_release(n, uc);
-  cell_release(n, ur);
-  cell_release(n, cl);
-  cell_release(n, cc);
-  cell_release(n, cr);
-  cell_release(n, ll);
-  cell_release(n, lc);
-  cell_release(n, lr);
+  nccell_release(n, ul);
+  nccell_release(n, uc);
+  nccell_release(n, ur);
+  nccell_release(n, cl);
+  nccell_release(n, cc);
+  nccell_release(n, cr);
+  nccell_release(n, ll);
+  nccell_release(n, lc);
+  nccell_release(n, lr);
 }
 
 static int
diff --git a/src/demo/highcon.c b/src/demo/highcon.c
index 5edca0434..3a58ec819 100644
--- a/src/demo/highcon.c
+++ b/src/demo/highcon.c
@@ -132,6 +132,6 @@ int highcontrast_demo(struct notcurses* nc){
   ret = 0;
 
 err:
-  cell_release(n, &c);
+  nccell_release(n, &c);
   return ret;
 }
diff --git a/src/demo/hud.c b/src/demo/hud.c
index 4f15230d0..299856f7b 100644
--- a/src/demo/hud.c
+++ b/src/demo/hud.c
@@ -170,13 +170,13 @@ about_toggle(struct notcurses* nc){
     channels_set_bg_rgb(&channels, 0);
     if(cells_rounded_box(n, NCSTYLE_NONE, channels, &ul, &ur, &ll, &lr, &hl, &vl) == 0){
       if(ncplane_perimeter(n, &ul, &ur, &ll, &lr, &hl, &vl, 0) == 0){
-        cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
-        cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
+        nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
+        nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
         about = n;
         return;
       }
-      cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
-      cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
+      nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
+      nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
     }
   }
   ncplane_destroy(n);
@@ -340,12 +340,12 @@ hud_refresh(struct ncplane* n){
   cell_set_bg_alpha(&hl, CELL_ALPHA_BLEND);
   cell_set_bg_alpha(&vl, CELL_ALPHA_BLEND);
   if(ncplane_perimeter(n, &ul, &ur, &ll, &lr, &hl, &vl, 0)){
-    cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
-    cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
+    nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
+    nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
     return -1;
   }
-  cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
-  cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
+  nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
+  nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
   return 0;
 }
 
@@ -372,7 +372,7 @@ hud_print_finished(elem* list){
       ncplane_set_bg_alpha(hud, CELL_ALPHA_BLEND);
       ncplane_set_fg_rgb(hud, 0xffffff);
       ncplane_set_fg_alpha(hud, CELL_ALPHA_OPAQUE);
-      cell_release(hud, &c);
+      nccell_release(hud, &c);
       if(ncplane_printf_yx(hud, line, 1, "%d", e->frames) < 0){
         return -1;
       }
@@ -587,7 +587,7 @@ int demo_render(struct notcurses* nc){
     ncplane_set_bg_alpha(hud, CELL_ALPHA_BLEND);
     ncplane_set_fg_rgb(hud, 0x80d0ff);
     ncplane_set_fg_alpha(hud, CELL_ALPHA_OPAQUE);
-    cell_release(hud, &c);
+    nccell_release(hud, &c);
     ncplane_on_styles(hud, NCSTYLE_BOLD);
     if(ncplane_printf_yx(hud, 1, 1, "%d", elems->frames) < 0){
       return -1;
diff --git a/src/demo/intro.c b/src/demo/intro.c
index d59d8e965..bff0e1236 100644
--- a/src/demo/intro.c
+++ b/src/demo/intro.c
@@ -164,9 +164,9 @@ int intro(struct notcurses* nc){
                        NCBOXGRAD_TOP | NCBOXGRAD_BOTTOM | NCBOXGRAD_RIGHT | NCBOXGRAD_LEFT)){
     return -1;
   }
-  cell_release(ncp, &ul); cell_release(ncp, &ur);
-  cell_release(ncp, &ll); cell_release(ncp, &lr);
-  cell_release(ncp, &hl); cell_release(ncp, &vl);
+  nccell_release(ncp, &ul); nccell_release(ncp, &ur);
+  nccell_release(ncp, &ll); nccell_release(ncp, &lr);
+  nccell_release(ncp, &hl); nccell_release(ncp, &vl);
   const char s1[] = " Die Welt ist alles, was der Fall ist. ";
   const char str[] = " Wovon man nicht sprechen kann, darüber muss man schweigen. ";
   if(ncplane_set_fg_rgb8(ncp, 192, 192, 192)){
diff --git a/src/demo/jungle.c b/src/demo/jungle.c
index 9963b471f..23f3e4972 100644
--- a/src/demo/jungle.c
+++ b/src/demo/jungle.c
@@ -26640,7 +26640,7 @@ int jungle_demo(struct notcurses* nc){
       }
     }
   }
-  cell_release(n, &c);
+  nccell_release(n, &c);
   free(buf);
   int iter = 0;
   int64_t iterns = NANOSECS_IN_SEC / 30;
diff --git a/src/demo/mojibake.c b/src/demo/mojibake.c
index 3d50daf68..4a6d35658 100644
--- a/src/demo/mojibake.c
+++ b/src/demo/mojibake.c
@@ -3543,7 +3543,7 @@ makegroup(struct ncplane* title, int y, const char* emoji, const char* name){
       break;
     }
     int w = ncplane_putc_yx(n, y, x, &c);
-    cell_release(n, &c);
+    nccell_release(n, &c);
     if(w < 0){
       ncplane_destroy(n);
       return NULL;
diff --git a/src/demo/normal.c b/src/demo/normal.c
index bd9686e13..c1726cb30 100644
--- a/src/demo/normal.c
+++ b/src/demo/normal.c
@@ -172,7 +172,7 @@ int normal_demo(struct notcurses* nc){
   cell_set_fg_rgb8(&c, 0x0, 0x0, 0x0);
   cell_set_bg_rgb8(&c, 0x0, 0x0, 0x0);
   ncplane_set_base_cell(nstd, &c);
-  cell_release(nstd, &c);
+  nccell_release(nstd, &c);
   struct ncplane* n = NULL;
   struct ncvisual_options vopts = {
     .n = nstd,
@@ -250,7 +250,7 @@ int normal_demo(struct notcurses* nc){
   cell_set_fg_rgb8(&c, 0, 0, 0);
   cell_set_bg_rgb8(&c, 0, 0, 0);
   ncplane_set_base_cell(nstd, &c);
-  cell_release(nstd, &c);
+  nccell_release(nstd, &c);
   r = rotate_visual(nc, n, dy, dx);
   return r;
 
diff --git a/src/demo/reel.c b/src/demo/reel.c
index c3739dd47..e22d44396 100644
--- a/src/demo/reel.c
+++ b/src/demo/reel.c
@@ -81,7 +81,7 @@ tabletdraw(struct ncplane* w, int maxy, tabletctx* tctx, unsigned rgb){
         return -1;
       }
     }
-    cell_release(w, &c);
+    nccell_release(w, &c);
   }
   return y;
 }
diff --git a/src/demo/unicodeblocks.c b/src/demo/unicodeblocks.c
index ed1838bdb..62131efeb 100644
--- a/src/demo/unicodeblocks.c
+++ b/src/demo/unicodeblocks.c
@@ -97,8 +97,8 @@ draw_block(struct ncplane* nn, uint32_t blockstart){
   if(ncplane_box_sized(nn, &ul, &ur, &ll, &lr, &hl, &vl, dimy, dimx, control)){
     return -1;
   }
-  cell_release(nn, &ul); cell_release(nn, &ur); cell_release(nn, &hl);
-  cell_release(nn, &ll); cell_release(nn, &lr); cell_release(nn, &vl);
+  nccell_release(nn, &ul); nccell_release(nn, &ur); nccell_release(nn, &hl);
+  nccell_release(nn, &ll); nccell_release(nn, &lr); nccell_release(nn, &vl);
   int chunk;
   for(chunk = 0 ; chunk < BLOCKSIZE / CHUNKSIZE ; ++chunk){
     int z;
diff --git a/src/demo/whiteout.c b/src/demo/whiteout.c
index 351335830..1112c663c 100644
--- a/src/demo/whiteout.c
+++ b/src/demo/whiteout.c
@@ -64,7 +64,7 @@ lighten(struct ncplane* n, nccell* c, int distance, int y, int x){
 static inline int
 lightup_surrounding_cells(struct ncplane* n, nccell* lightup, int y, int x){
   lighten(n, lightup, 0, y, x);
-  cell_release(n, lightup);
+  nccell_release(n, lightup);
   return 0;
 }
 
@@ -199,7 +199,7 @@ message(struct ncplane* n, int maxy, int maxx, int num, int total,
   ncplane_putegc_yx(n, 0, 3, "╔", NULL);
   cell_load(n, &hl, "═");
   ncplane_hline(n, &hl, 20 - 4 - 1);
-  cell_release(n, &hl);
+  nccell_release(n, &hl);
   ncplane_putegc_yx(n, 0, 19, "╗", NULL);
   ncplane_putegc_yx(n, 1, 19, "║", NULL);
   ncplane_putegc_yx(n, 2, 19, "╨", NULL);
diff --git a/src/lib/fill.c b/src/lib/fill.c
index 4011e4d03..0bd4ee269 100644
--- a/src/lib/fill.c
+++ b/src/lib/fill.c
@@ -33,7 +33,7 @@ ncplane_polyfill_recurse(ncplane* n, int y, int x, const nccell* c, const char*
   if(strcmp(glust, filltarg)){
     return 0;
   }
-  if(cell_duplicate(n, cur, c) < 0){
+  if(nccell_duplicate(n, cur, c) < 0){
     return -1;
   }
   int r, ret = 1;
@@ -399,7 +399,7 @@ rotate_2x1_cw(ncplane* src, ncplane* dst, int srcy, int srcx, int dsty, int dstx
     return -1;
   }
   if(ncplane_at_yx_cell(src, srcy, srcx + 1, &c2) < 0){
-    cell_release(src, &c1);
+    nccell_release(src, &c1);
     return -1;
   }
   // there can be at most 4 colors and 4 transparencies:
@@ -440,7 +440,7 @@ rotate_2x1_ccw(ncplane* src, ncplane* dst, int srcy, int srcx, int dsty, int dst
     return -1;
   }
   if(ncplane_at_yx_cell(src, srcy, srcx + 1, &c2) < 0){
-    cell_release(src, &c1);
+    nccell_release(src, &c1);
     return -1;
   }
   uint32_t c1b = cell_bchannel_common(&c1);
diff --git a/src/lib/menu.c b/src/lib/menu.c
index 3f93e37e7..5f4735aea 100644
--- a/src/lib/menu.c
+++ b/src/lib/menu.c
@@ -307,7 +307,7 @@ write_header(ncmenu* ncm){
         if(ncplane_putc_yx(ncm->ncp, ypos, xoff + ncm->sections[i].shortcut_offset, &cl) < 0){
           return -1;
         }
-        cell_release(ncm->ncp, &cl);
+        nccell_release(ncm->ncp, &cl);
       }
       xoff += ncstrwidth(ncm->sections[i].name);
     }
@@ -386,7 +386,7 @@ ncmenu* ncmenu_create(ncplane* n, const ncmenu_options* opts){
         cell_set_fg_alpha(&c, CELL_ALPHA_TRANSPARENT);
         cell_set_bg_alpha(&c, CELL_ALPHA_TRANSPARENT);
         ncplane_set_base_cell(ret->ncp, &c);
-        cell_release(ret->ncp, &c);
+        nccell_release(ret->ncp, &c);
         if(write_header(ret) == 0){
           return ret;
         }
@@ -487,7 +487,7 @@ int ncmenu_unroll(ncmenu* n, int sectionidx){
         if(ncplane_putc_yx(n->ncp, ypos, xpos + 1 + sec->items[i].shortcut_offset, &cl) < 0){
           return -1;
         }
-        cell_release(n->ncp, &cl);
+        nccell_release(n->ncp, &cl);
       }
     }else{
       n->ncp->channels = n->headerchannels;
diff --git a/src/lib/notcurses.c b/src/lib/notcurses.c
index b84ced134..443a1e921 100644
--- a/src/lib/notcurses.c
+++ b/src/lib/notcurses.c
@@ -161,7 +161,7 @@ int ncplane_at_yx_cell(ncplane* n, int y, int x, nccell* c){
   if(y < n->leny && x < n->lenx){
     if(y >= 0 && x >= 0){
       nccell* targ = ncplane_cell_ref_yx(n, y, x);
-      if(cell_duplicate(n, c, targ) == 0){
+      if(nccell_duplicate(n, c, targ) == 0){
         return strlen(cell_extended_gcluster(n, targ));
       }
     }
@@ -1270,7 +1270,7 @@ int ncplane_set_base_cell(ncplane* ncp, const nccell* c){
   if(cell_wide_right_p(c)){
     return -1;
   }
-  return cell_duplicate(ncp, &ncp->basecell, c);
+  return nccell_duplicate(ncp, &ncp->basecell, c);
 }
 
 int ncplane_set_base(ncplane* ncp, const char* egc, uint32_t stylemask, uint64_t channels){
@@ -1278,7 +1278,7 @@ int ncplane_set_base(ncplane* ncp, const char* egc, uint32_t stylemask, uint64_t
 }
 
 int ncplane_base(ncplane* ncp, nccell* c){
-  return cell_duplicate(ncp, c, &ncp->basecell);
+  return nccell_duplicate(ncp, c, &ncp->basecell);
 }
 
 const char* cell_extended_gcluster(const ncplane* n, const nccell* c){
@@ -1390,7 +1390,7 @@ void ncplane_cursor_yx(const ncplane* n, int* y, int* x){
 
 static inline void
 cell_obliterate(ncplane* n, nccell* c){
-  cell_release(n, c);
+  nccell_release(n, c);
   cell_init(c);
 }
 
@@ -1401,7 +1401,7 @@ void scroll_down(ncplane* n){
     n->logrow = (n->logrow + 1) % n->leny;
     nccell* row = n->fb + nfbcellidx(n, n->y, 0);
     for(int clearx = 0 ; clearx < n->lenx ; ++clearx){
-      cell_release(n, &row[clearx]);
+      nccell_release(n, &row[clearx]);
     }
     memset(row, 0, sizeof(*row) * n->lenx);
   }else{
@@ -1477,7 +1477,7 @@ ncplane_put(ncplane* n, int y, int x, const char* egc, int cols,
     if(cell_wide_left_p(candidate)){
       cell_obliterate(n, &n->fb[nfbcellidx(n, n->y, n->x + 1)]);
     }
-    cell_release(n, candidate);
+    nccell_release(n, candidate);
     candidate->channels = targ->channels;
     candidate->stylemask = targ->stylemask;
     candidate->width = targ->width;
@@ -1685,7 +1685,7 @@ int ncplane_hline_interp(ncplane* n, const nccell* c, int len,
   int deltbb = bb2 - bb1;
   int ret;
   nccell dupc = CELL_TRIVIAL_INITIALIZER;
-  if(cell_duplicate(n, &dupc, c) < 0){
+  if(nccell_duplicate(n, &dupc, c) < 0){
     return -1;
   }
   bool fgdef = false, bgdef = false;
@@ -1712,7 +1712,7 @@ int ncplane_hline_interp(ncplane* n, const nccell* c, int len,
       break;
     }
   }
-  cell_release(n, &dupc);
+  nccell_release(n, &dupc);
   return ret;
 }
 
@@ -1738,7 +1738,7 @@ int ncplane_vline_interp(ncplane* n, const nccell* c, int len,
   int ret, ypos, xpos;
   ncplane_cursor_yx(n, &ypos, &xpos);
   nccell dupc = CELL_TRIVIAL_INITIALIZER;
-  if(cell_duplicate(n, &dupc, c) < 0){
+  if(nccell_duplicate(n, &dupc, c) < 0){
     return -1;
   }
   bool fgdef = false, bgdef = false;
@@ -1768,7 +1768,7 @@ int ncplane_vline_interp(ncplane* n, const nccell* c, int len,
       break;
     }
   }
-  cell_release(n, &dupc);
+  nccell_release(n, &dupc);
   return ret;
 }
 
@@ -1954,7 +1954,7 @@ void ncplane_erase(ncplane* n){
   if(n->sprite){
     sprixel_hide(n->sprite);
   }
-  // we must preserve the background, but a pure cell_duplicate() would be
+  // we must preserve the background, but a pure nccell_duplicate() would be
   // wiped out by the egcpool_dump(). do a duplication (to get the stylemask
   // and channels), and then reload.
   char* egc = cell_strdup(n, &n->basecell);
diff --git a/src/lib/progbar.c b/src/lib/progbar.c
index 019840ec4..714c245db 100644
--- a/src/lib/progbar.c
+++ b/src/lib/progbar.c
@@ -151,13 +151,13 @@ progbar_redraw(ncprogbar* n){
     if(horizontal){
       for(int freepos = 0 ; freepos < dimy ; ++freepos){
         nccell* c = ncplane_cell_ref_yx(ncp, freepos, pos);
-        cell_release(ncp, c);
+        nccell_release(ncp, c);
         cell_init(c);
       }
     }else{
       for(int freepos = 0 ; freepos < dimx ; ++freepos){
         nccell* c = ncplane_cell_ref_yx(ncp, pos, freepos);
-        cell_release(ncp, c);
+        nccell_release(ncp, c);
         cell_init(c);
       }
     }
diff --git a/src/lib/reel.c b/src/lib/reel.c
index e2c5374d7..64443be80 100644
--- a/src/lib/reel.c
+++ b/src/lib/reel.c
@@ -161,8 +161,8 @@ draw_borders(ncplane* n, unsigned mask, uint64_t channel, direction_e direction)
       ncplane_putc(n, &lr);
     }
   }
-  cell_release(n, &ul); cell_release(n, &ur); cell_release(n, &hl);
-  cell_release(n, &ll); cell_release(n, &lr); cell_release(n, &vl);
+  nccell_release(n, &ul); nccell_release(n, &ur); nccell_release(n, &hl);
+  nccell_release(n, &ll); nccell_release(n, &lr); nccell_release(n, &vl);
   return ret;
 }
 
diff --git a/src/lib/render.c b/src/lib/render.c
index c11f0ee63..49d965067 100644
--- a/src/lib/render.c
+++ b/src/lib/render.c
@@ -171,12 +171,12 @@ update_raster_stats(const struct timespec* time1, const struct timespec* time0,
   }
 }
 
-void cell_release(ncplane* n, nccell* c){
+void nccell_release(ncplane* n, nccell* c){
   pool_release(&n->pool, c);
 }
 
 // Duplicate one cell onto another when they share a plane. Convenience wrapper.
-int cell_duplicate(ncplane* n, nccell* targ, const nccell* c){
+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");
     return -1;
diff --git a/src/tests/cell.cpp b/src/tests/cell.cpp
index 226e0745f..b830dff91 100644
--- a/src/tests/cell.cpp
+++ b/src/tests/cell.cpp
@@ -39,7 +39,7 @@ TEST_CASE("Cell") {
     nccell c = CELL_TRIVIAL_INITIALIZER;
     CHECK(1 == cell_load(n_, &c, " "));
     CHECK(cell_simple_p(&c));
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
   }
 
   SUBCASE("MultibyteWidth") {
@@ -75,7 +75,7 @@ TEST_CASE("Cell") {
     CHECK(1 == cell_load(n_, &c, "i"));
     cell_set_fg_rgb8(&c, 255, 255, 255);
     ncplane_set_base_cell(n_, &c);
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
     CHECK(0 == notcurses_render(nc_));
     cell_off_styles(&c, NCSTYLE_ITALIC);
   }
@@ -88,7 +88,7 @@ TEST_CASE("Cell") {
     CHECK(1 == cell_load(n_, &c, "b"));
     cell_set_fg_rgb8(&c, 255, 255, 255);
     ncplane_set_base_cell(n_, &c);
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
     CHECK(0 == notcurses_render(nc_));
     cell_off_styles(&c, NCSTYLE_BOLD);
   }
@@ -101,7 +101,7 @@ TEST_CASE("Cell") {
     CHECK(1 == cell_load(n_, &c, "u"));
     cell_set_fg_rgb8(&c, 255, 255, 255);
     ncplane_set_base_cell(n_, &c);
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
     CHECK(0 == notcurses_render(nc_));
     cell_off_styles(&c, NCSTYLE_UNDERLINE);
   }
diff --git a/src/tests/fills.cpp b/src/tests/fills.cpp
index 76bbf1e0d..cfc96a5c5 100644
--- a/src/tests/fills.cpp
+++ b/src/tests/fills.cpp
@@ -568,9 +568,9 @@ TEST_CASE("Fills") {
           nccell c2 = CELL_TRIVIAL_INITIALIZER;
           CHECK(0 < ncplane_at_yx_cell(p2, y - 1, x - 1, &c2));
           CHECK(0 == cellcmp(p1, &c1, p2, &c2));
-          cell_release(p2, &c2);
+          nccell_release(p2, &c2);
         }
-        cell_release(p1, &c1);
+        nccell_release(p1, &c1);
       }
     }
     ncplane_destroy(p1);
diff --git a/src/tests/palette.cpp b/src/tests/palette.cpp
index 00707556d..721fe6a69 100644
--- a/src/tests/palette.cpp
+++ b/src/tests/palette.cpp
@@ -68,7 +68,7 @@ TEST_CASE("Palette256") {
     CHECK(0 == cell_set_fg_palindex(&c, 0x20));
     CHECK(0 == cell_set_bg_palindex(&c, 0x40));
     CHECK(1 == ncplane_putc_yx(n_, 0, 0, &c));
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
     nccell r = CELL_TRIVIAL_INITIALIZER;
     CHECK(0 < ncplane_at_yx_cell(n_, 0, 0, &r));
     CHECK(cell_fg_palindex_p(&r));
@@ -77,7 +77,7 @@ TEST_CASE("Palette256") {
     CHECK(CELL_ALPHA_OPAQUE == cell_bg_alpha(&r));
     CHECK(0x20 == cell_fg_palindex(&r));
     CHECK(0x40 == cell_bg_palindex(&r));
-    cell_release(n_, &r);
+    nccell_release(n_, &r);
   }
 
   SUBCASE("RenderCAttrs") {
@@ -88,7 +88,7 @@ TEST_CASE("Palette256") {
     CHECK(0 == ncplane_set_fg_palindex(n_, 0x20));
     CHECK(0 == ncplane_set_bg_palindex(n_, 0x40));
     CHECK(0 < ncplane_putc_yx(n_, 0, 0, &c));
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
     CHECK(0 == notcurses_render(nc_));
     nccell r = CELL_TRIVIAL_INITIALIZER;
     CHECK(nullptr != notcurses_at_yx(nc_, 0, 0, &r.stylemask, &r.channels));
@@ -98,7 +98,7 @@ TEST_CASE("Palette256") {
     CHECK(CELL_ALPHA_OPAQUE == cell_bg_alpha(&r));
     CHECK(0x20 == cell_fg_palindex(&r));
     CHECK(0x40 == cell_bg_palindex(&r));
-    cell_release(n_, &r);
+    nccell_release(n_, &r);
   }
 
   // common teardown
diff --git a/src/tests/plane.cpp b/src/tests/plane.cpp
index 5fe7ad3e2..6b9df0249 100644
--- a/src/tests/plane.cpp
+++ b/src/tests/plane.cpp
@@ -183,7 +183,7 @@ TEST_CASE("Plane") {
       CHECK(yidx == posy);
       CHECK(x - 1 == posx);
     }
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
     CHECK(0 == notcurses_render(nc_));
   }
 
@@ -202,7 +202,7 @@ TEST_CASE("Plane") {
       CHECK(y - 2 == posy);
       CHECK(xidx == posx - 1);
     }
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
     CHECK(0 == notcurses_render(nc_));
   }
 
@@ -319,9 +319,9 @@ TEST_CASE("Plane") {
     REQUIRE(2 == u1);
     REQUIRE(3 == u2);
     REQUIRE(1 == u3);
-    cell_release(n_, &cell1);
-    cell_release(n_, &cell2);
-    cell_release(n_, &cell3);
+    nccell_release(n_, &cell1);
+    nccell_release(n_, &cell2);
+    nccell_release(n_, &cell3);
   }
 
   SUBCASE("CellDuplicateCombining") {
@@ -340,15 +340,15 @@ TEST_CASE("Plane") {
     nccell cell4 = CELL_TRIVIAL_INITIALIZER;
     nccell cell5 = CELL_TRIVIAL_INITIALIZER;
     nccell cell6 = CELL_TRIVIAL_INITIALIZER;
-    CHECK(0 == cell_duplicate(n_, &cell4, &cell1));
-    CHECK(0 == cell_duplicate(n_, &cell5, &cell2));
-    CHECK(0 == cell_duplicate(n_, &cell6, &cell3));
-    cell_release(n_, &cell1);
-    cell_release(n_, &cell2);
-    cell_release(n_, &cell3);
-    cell_release(n_, &cell4);
-    cell_release(n_, &cell5);
-    cell_release(n_, &cell6);
+    CHECK(0 == nccell_duplicate(n_, &cell4, &cell1));
+    CHECK(0 == nccell_duplicate(n_, &cell5, &cell2));
+    CHECK(0 == nccell_duplicate(n_, &cell6, &cell3));
+    nccell_release(n_, &cell1);
+    nccell_release(n_, &cell2);
+    nccell_release(n_, &cell3);
+    nccell_release(n_, &cell4);
+    nccell_release(n_, &cell5);
+    nccell_release(n_, &cell6);
   }
 
   SUBCASE("CellMultiColumn") {
@@ -364,8 +364,8 @@ TEST_CASE("Plane") {
     REQUIRE(strlen(w2) == u2);
     CHECK(ncstrwidth(w1) == 1 + cell_double_wide_p(&c1));
     CHECK_FALSE(cell_double_wide_p(&c2));
-    cell_release(n_, &c1);
-    cell_release(n_, &c2);
+    nccell_release(n_, &c1);
+    nccell_release(n_, &c2);
   }
 
   // verifies that the initial userptr is what we provided, that it is a nullptr
@@ -558,7 +558,7 @@ TEST_CASE("Plane") {
     CHECK(0 == testcell.gcluster);
     CHECK(0 == testcell.stylemask);
     CHECK(0 == testcell.channels);
-    cell_release(n_, &testcell);
+    nccell_release(n_, &testcell);
     int dimy, dimx;
     ncplane_dim_yx(n_, &dimy, &dimx);
     REQUIRE(0 == ncplane_cursor_move_yx(n_, 1, dimx - strlen(STR2)));
@@ -596,7 +596,7 @@ TEST_CASE("Plane") {
     CHECK(0 == testcell.gcluster);
     CHECK(0 == testcell.stylemask);
     CHECK(0 == testcell.channels);
-    cell_release(n_, &testcell);
+    nccell_release(n_, &testcell);
     int dimy, dimx;
     ncplane_dim_yx(n_, &dimy, &dimx);
     REQUIRE(0 == ncplane_cursor_move_yx(n_, 1, dimx - mbstowcs(nullptr, STR2, 0)));
diff --git a/src/tests/rotate.cpp b/src/tests/rotate.cpp
index dc31d6114..b13e1bfb0 100644
--- a/src/tests/rotate.cpp
+++ b/src/tests/rotate.cpp
@@ -78,9 +78,9 @@ TEST_CASE("Rotate") {
     CHECK(-1 < cell_prime(testn, &vl, "█", 0, lr));
     CHECK(0 == ncplane_perimeter(testn, &tl, &tr, &bl, &br, &hl, &vl, 0));
     RotateCW(nc_, testn);
-    cell_release(testn, &tl); cell_release(testn, &tr);
-    cell_release(testn, &bl); cell_release(testn, &br);
-    cell_release(testn, &hl); cell_release(testn, &vl);
+    nccell_release(testn, &tl); nccell_release(testn, &tr);
+    nccell_release(testn, &bl); nccell_release(testn, &br);
+    nccell_release(testn, &hl); nccell_release(testn, &vl);
     CHECK(0 == ncplane_destroy(testn));
   }
 
diff --git a/src/tests/wide.cpp b/src/tests/wide.cpp
index bc5d46c47..9a6d88a7a 100644
--- a/src/tests/wide.cpp
+++ b/src/tests/wide.cpp
@@ -121,7 +121,7 @@ TEST_CASE("Wide") {
     nccell c = CELL_TRIVIAL_INITIALIZER;
     CHECK(0 < cell_load(n_, &c, w));
     CHECK(0 < ncplane_putc_yx(n_, 1, 0, &c));
-    cell_release(n_, &c);
+    nccell_release(n_, &c);
     ncplane_at_yx_cell(n_, 0, 0, &c);
     CHECK(0 == strcmp(cell_extended_gcluster(n_, &c), FROG));
     ncplane_at_yx_cell(n_, 0, 1, &c);
@@ -242,14 +242,14 @@ TEST_CASE("Wide") {
     nccell c = CELL_TRIVIAL_INITIALIZER;
     CHECK(0 < ncplane_at_yx_cell(ncp, 1, 0, &c));
     CHECK(!strcmp(cell_extended_gcluster(ncp, &c), "│"));
-    cell_release(ncp, &c);
+    nccell_release(ncp, &c);
     char* egc = notcurses_at_yx(nc_, 1, 0, &c.stylemask, &c.channels);
     REQUIRE(egc);
     CHECK(!strcmp(egc, "│"));
     free(egc);
     CHECK(0 < ncplane_at_yx_cell(ncp, 1, 3, &c));
     CHECK(!strcmp(cell_extended_gcluster(ncp, &c), "│"));
-    cell_release(ncp, &c);
+    nccell_release(ncp, &c);
     egc = notcurses_at_yx(nc_, 1, 3, &c.stylemask, &c.channels);
     REQUIRE(egc);
     CHECK(!strcmp(egc, "│"));
@@ -436,8 +436,8 @@ TEST_CASE("Wide") {
     CHECK(0 == ncplane_at_yx_cell(n_, 1, 2, &cr));
     CHECK(cell_simple_p(&cr));
     CHECK(0 == cr.gcluster);
-    cell_release(n_, &cl);
-    cell_release(n_, &cr);
+    nccell_release(n_, &cl);
+    nccell_release(n_, &cr);
     CHECK(chanright == chanleft);
     ncplane_destroy(p);
   }