diff --git a/test/tool/net/futex_test.lua b/test/tool/net/futex_test.lua
index 9f545b3d3..d5fa8d634 100644
--- a/test/tool/net/futex_test.lua
+++ b/test/tool/net/futex_test.lua
@@ -54,7 +54,7 @@ function Lock()
     end
 end
 function Unlock()
-    local old = mem:add(LOCK, -1)
+    local old = mem:fetch_add(LOCK, -1)
     if old == 2 then
         mem:store(LOCK, 0)
         mem:wake(LOCK, 1)
diff --git a/test/tool/net/mapshared_test.lua b/test/tool/net/mapshared_test.lua
index 3bd4e0898..8d4f2ca6f 100644
--- a/test/tool/net/mapshared_test.lua
+++ b/test/tool/net/mapshared_test.lua
@@ -45,15 +45,21 @@ ok, old = mem:cmpxchg(0, 0, 1)
 assert(ok and old == 0)
 ok, old = mem:cmpxchg(0, 666, 777)
 assert(not ok and old == 1)
-assert(mem:add(0, 3) == 1)
-assert(mem:load(0) == 4)
+assert(mem:fetch_add(0, 3) == 1)
+assert(mem:load(0) ==  0b00000100)
+assert(mem:fetch_xor(0,0b00000110) == 0b00000100)
+assert(mem:load(0) ==  0b00000010)
+assert(mem:fetch_and(0,0b00000110) == 0b00000010)
+assert(mem:load(0) ==  0b00000010)
+assert(mem:fetch_or(0, 0b00000110) == 0b00000010)
+assert(mem:load(0) ==  0b00000110)
 
 --------------------------------------------------------------------------------
 -- test atomic addition across concurrent processes
 
 function Worker()
     for i = 1,iterations do
-        mem:add(0, 1)
+        mem:fetch_add(0, 1)
     end
 end
 
diff --git a/third_party/lua/lunix.c b/third_party/lua/lunix.c
index fe913fb91..a36b2921a 100644
--- a/third_party/lua/lunix.c
+++ b/third_party/lua/lunix.c
@@ -2882,10 +2882,10 @@ static const luaL_Reg kLuaUnixMemoryMeth[] = {
     {"store", LuaUnixMemoryStore},      //
     {"xchg", LuaUnixMemoryXchg},        //
     {"cmpxchg", LuaUnixMemoryCmpxchg},  //
-    {"add", LuaUnixMemoryAdd},          //
-    {"and", LuaUnixMemoryAnd},          //
-    {"or", LuaUnixMemoryOr},            //
-    {"xor", LuaUnixMemoryXor},          //
+    {"fetch_add", LuaUnixMemoryAdd},    //
+    {"fetch_and", LuaUnixMemoryAnd},    //
+    {"fetch_or", LuaUnixMemoryOr},      //
+    {"fetch_xor", LuaUnixMemoryXor},    //
     {"wait", LuaUnixMemoryWait},        //
     {"wake", LuaUnixMemoryWake},        //
     {0},                                //
diff --git a/tool/net/help.txt b/tool/net/help.txt
index 32aed7740..b5223c77b 100644
--- a/tool/net/help.txt
+++ b/tool/net/help.txt
@@ -4620,7 +4620,7 @@ UNIX MODULE
     This operation happens atomically and provides the same memory
     barrier semantics as the aligned x86 LOCK CMPXCHG instruction.
 
-  unix.Memory:add(word_index:int, value:int)
+  unix.Memory:fetch_add(word_index:int, value:int)
       └─→ old:int
 
     Fetches then adds value.
@@ -4632,7 +4632,7 @@ UNIX MODULE
     This operation is atomic and provides the same memory barrier
     semantics as the aligned x86 LOCK XADD instruction.
 
-  unix.Memory:and(word_index:int, value:int)
+  unix.Memory:fetch_and(word_index:int, value:int)
       └─→ int
 
     Fetches and bitwise ands value.
@@ -4640,7 +4640,7 @@ UNIX MODULE
     This operation happens atomically and provides the same memory
     barrier ordering semantics as its x86 implementation.
 
-  unix.Memory:or(word_index:int, value:int)
+  unix.Memory:fetch_or(word_index:int, value:int)
       └─→ int
 
     Fetches and bitwise ors value.
@@ -4648,7 +4648,7 @@ UNIX MODULE
     This operation happens atomically and provides the same memory
     barrier ordering semantics as its x86 implementation.
 
-  unix.Memory:xor(word_index:int, value:int)
+  unix.Memory:fetch_xor(word_index:int, value:int)
       └─→ int
 
     Fetches and bitwise xors value.