diff --git a/luprex/cpp/core/animqueue.cpp b/luprex/cpp/core/animqueue.cpp
index 4a19fe5a..506ac0f8 100644
--- a/luprex/cpp/core/animqueue.cpp
+++ b/luprex/cpp/core/animqueue.cpp
@@ -171,7 +171,7 @@ void AnimStep::config_store_number(lua_State *L, int idx, float *target, float o
 void AnimStep::configure(LuaKeywordParser &kp, const AnimStep &aqback) {
     lua_State *L = kp.state();
     LuaVar value;
-    LuaStack LS(L, value);
+    LuaOldStack LS(L, value);
 
     if (kp.parse(value, "action")) {
         config_store_string(L, value.index(), &action_, 0, "action");
diff --git a/luprex/cpp/core/gui.cpp b/luprex/cpp/core/gui.cpp
index 91b53e66..96d31be7 100644
--- a/luprex/cpp/core/gui.cpp
+++ b/luprex/cpp/core/gui.cpp
@@ -59,7 +59,7 @@ eng::string Gui::menu_debug_string() const {
 LuaDefine(gui_menu_item, "action,label", "add a menu item to the current gui") {
     Gui *gui = Gui::fetch_global_pointer(L);
     LuaArg laction, llabel;
-    LuaStack LS(L, laction, llabel);
+    LuaOldStack LS(L, laction, llabel);
     eng::string action = LS.ckstring(laction);
     eng::string label = LS.ckstring(llabel);
     if (!sv::has_prefix(action, "cb_")) {
diff --git a/luprex/cpp/core/http.cpp b/luprex/cpp/core/http.cpp
index 659b4e2d..367321ee 100644
--- a/luprex/cpp/core/http.cpp
+++ b/luprex/cpp/core/http.cpp
@@ -625,7 +625,7 @@ void HttpClientRequest::set_content(const eng::string &content) {
     content_assigned_ = true;
 }
 
-void HttpClientRequest::set_verify_certificate(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_verify_certificate(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isboolean(val)) {
         check_fail(util::ss("verifycertificate must be a boolean"));
         return;
@@ -633,7 +633,7 @@ void HttpClientRequest::set_verify_certificate(LuaStack &LS, LuaSlot val) {
     set_verify_certificate(LS.ckboolean(val));
 }
 
-void HttpClientRequest::set_method(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_method(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isstring(val)) {
         check_fail(util::ss("method must be a string"));
         return;
@@ -641,7 +641,7 @@ void HttpClientRequest::set_method(LuaStack &LS, LuaSlot val) {
     set_method(LS.ckstring(val));
 }
 
-void HttpClientRequest::set_host(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_host(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isstring(val)) {
         check_fail(util::ss("host must be a string"));
         return;
@@ -649,7 +649,7 @@ void HttpClientRequest::set_host(LuaStack &LS, LuaSlot val) {
     set_host(LS.ckstring(val));
 }
 
-void HttpClientRequest::set_port(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_port(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isint(val)) {
         check_fail(util::ss("port must be an int"));
         return;
@@ -657,7 +657,7 @@ void HttpClientRequest::set_port(LuaStack &LS, LuaSlot val) {
     set_port(LS.ckint(val));
 }
 
-void HttpClientRequest::set_path(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_path(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isstring(val)) {
         check_fail(util::ss("path must be a string"));
         return;
@@ -665,7 +665,7 @@ void HttpClientRequest::set_path(LuaStack &LS, LuaSlot val) {
     set_path(LS.ckstring(val));
 }
 
-void HttpClientRequest::set_param(LuaStack &LS, LuaSlot key, LuaSlot val) {
+void HttpClientRequest::set_param(LuaCoreStack &LS, LuaSlot key, LuaSlot val) {
     if (!LS.isstring(key)) {
         check_fail(util::ss("url parameter key must be a string"));
         return;
@@ -677,20 +677,20 @@ void HttpClientRequest::set_param(LuaStack &LS, LuaSlot key, LuaSlot val) {
     set_param(LS.ckstring(key), LS.ckstring(val));
 }
 
-void HttpClientRequest::set_params(LuaStack &LS0, LuaSlot tab) {
+void HttpClientRequest::set_params(LuaCoreStack &LS0, LuaSlot tab) {
     if (!LS0.istable(tab)) {
         check_fail(util::ss("params must be a table"));
         return;
     }
     LuaVar key, val;
-    LuaStack LS(LS0.state(), key, val);
+    LuaOldStack LS(LS0.state(), key, val);
     LS.set(key, LuaNil);
     while (LS.next(tab, key, val)) {
         set_param(LS, key, val);
     }
 }
 
-void HttpClientRequest::set_url(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_url(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isstring(val)) {
         check_fail(util::ss("url must be a string"));
         return;
@@ -698,7 +698,7 @@ void HttpClientRequest::set_url(LuaStack &LS, LuaSlot val) {
     set_url(LS.ckstring(val));
 }
 
-void HttpClientRequest::set_mime_type(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_mime_type(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isstring(val)) {
         check_fail(util::ss("mime type must be a string"));
         return;
@@ -706,7 +706,7 @@ void HttpClientRequest::set_mime_type(LuaStack &LS, LuaSlot val) {
     set_mime_type(LS.ckstring(val));
 }
 
-void HttpClientRequest::set_content(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_content(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isstring(val)) {
         check_fail(util::ss("content must be a string"));
         return;
@@ -714,7 +714,7 @@ void HttpClientRequest::set_content(LuaStack &LS, LuaSlot val) {
     set_content(LS.ckstring(val));
 }
 
-void HttpClientRequest::set_jsonvalue(LuaStack &LS, LuaSlot val) {
+void HttpClientRequest::set_jsonvalue(LuaCoreStack &LS, LuaSlot val) {
     eng::string out;
     eng::string err = json::encode(LS, val, out, false, HttpParser::MAX_CONTENT_LENGTH);
     if (!err.empty()) {
@@ -736,7 +736,7 @@ void HttpClientRequest::set_defaults() {
 
 void HttpClientRequest::configure(LuaKeywordParser &kp) {
     LuaVar val;
-    LuaStack LS(kp.state(), val);
+    LuaOldStack LS(kp.state(), val);
     if (kp.parse(val, "method")) {
         set_method(LS, val);
     }
@@ -977,7 +977,7 @@ void HttpServerResponse::set_content(const eng::string &content) {
     content_assigned_ = true;
 }
 
-void HttpServerResponse::set_status(LuaStack &LS, LuaSlot val) {
+void HttpServerResponse::set_status(LuaCoreStack &LS, LuaSlot val) {
     int status = 0;
     if (LS.isstring(val)) {
         eng::string s = LS.ckstring(val);
@@ -995,7 +995,7 @@ void HttpServerResponse::set_status(LuaStack &LS, LuaSlot val) {
     set_status(status);
 }
 
-void HttpServerResponse::set_max_age(LuaStack &LS, LuaSlot val) {
+void HttpServerResponse::set_max_age(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isint(val)) {
         check_fail(util::ss("max-age must be an int"));
         return;
@@ -1003,7 +1003,7 @@ void HttpServerResponse::set_max_age(LuaStack &LS, LuaSlot val) {
     set_max_age(LS.ckint(val));
 }
 
-void HttpServerResponse::set_mime_type(LuaStack &LS, LuaSlot val) {
+void HttpServerResponse::set_mime_type(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isstring(val)) {
         check_fail(util::ss("mime type must be a string"));
         return;
@@ -1011,7 +1011,7 @@ void HttpServerResponse::set_mime_type(LuaStack &LS, LuaSlot val) {
     set_mime_type(LS.ckstring(val));
 }
 
-void HttpServerResponse::set_content(LuaStack &LS, LuaSlot val) {
+void HttpServerResponse::set_content(LuaCoreStack &LS, LuaSlot val) {
     if (!LS.isstring(val)) {
         check_fail(util::ss("content must be a string"));
         return;
@@ -1019,7 +1019,7 @@ void HttpServerResponse::set_content(LuaStack &LS, LuaSlot val) {
     set_content(LS.ckstring(val));
 }
 
-void HttpServerResponse::set_jsonvalue(LuaStack &LS, LuaSlot val) {
+void HttpServerResponse::set_jsonvalue(LuaCoreStack &LS, LuaSlot val) {
     eng::string out;
     eng::string err = json::encode(LS, val, out, false, HttpParser::MAX_CONTENT_LENGTH);
     if (!err.empty()) {
@@ -1032,7 +1032,7 @@ void HttpServerResponse::set_jsonvalue(LuaStack &LS, LuaSlot val) {
 
 void HttpServerResponse::configure(LuaKeywordParser &kp) {
     LuaVar val;
-    LuaStack LS(kp.state(), val);
+    LuaOldStack LS(kp.state(), val);
     if (kp.parse(val, "status")) {
         set_status(LS, val);
     }
@@ -1468,9 +1468,9 @@ bool HttpParser::parse_content(std::string_view &view, bool closed) {
     return true;
 }
 
-void HttpParser::store(LuaStack &LS0, LuaSlot tab) const {
+void HttpParser::store(LuaCoreStack &LS0, LuaSlot tab) const {
     LuaVar ptab, djson;
-    LuaStack LS(LS0.state(), ptab, djson);
+    LuaOldStack LS(LS0.state(), ptab, djson);
 
     LS.newtable(tab);
     if (!is_request_) {
@@ -1633,7 +1633,7 @@ void HttpParser::parse_request(std::string_view view, bool closed) {
     if (status_ == 0) status_ = 200;
 }
 
-void HttpParser::store_fail(LuaStack &LS, LuaSlot tab, int status_code, std::string_view error) {
+void HttpParser::store_fail(LuaCoreStack &LS, LuaSlot tab, int status_code, std::string_view error) {
     HttpParser parser;
     parser.fail(status_code, error);
     parser.store(LS, tab);
@@ -1659,7 +1659,7 @@ void HttpClientRequestMap::deserialize(StreamBuffer *sb) {
 LuaDefine(http_fixurl, "url", "validate URL and repair minor flaws in the URL syntax") {
     LuaArg url;
     LuaRet fixed;
-    LuaStack LS(L, url, fixed);
+    LuaOldStack LS(L, url, fixed);
     ParsedURL parsed(LS.ckstring(url));
     if (!parsed.valid) {
         luaL_error(L, "invalid URL, not fixable");
@@ -1715,7 +1715,7 @@ LuaDefine(http_clientrequest, "request",
     "|that would be sent.") {
     LuaArg tab;
     LuaRet str;
-    LuaStack LS(L, tab, str);
+    LuaOldStack LS(L, tab, str);
     LuaKeywordParser kp(LS, tab);
     HttpClientRequest req;
     req.configure(kp);
@@ -1774,7 +1774,7 @@ LuaDefine(http_clientresponse, "response",
     "|an actual HTTP response string.  This is for debugging only.") {
     LuaArg text;
     LuaRet tab;
-    LuaStack LS(L, text, tab);
+    LuaOldStack LS(L, text, tab);
     HttpParser parser;
     parser.parse_response(LS.ckstring(text), true, "GET");
     parser.store(LS, tab);
@@ -1829,7 +1829,7 @@ LuaDefine(http_serverrequest, "request",
     "|an actual HTTP request string.  This is for debugging only.") {
     LuaArg text;
     LuaRet tab;
-    LuaStack LS(L, text, tab);
+    LuaOldStack LS(L, text, tab);
     HttpParser parser;
     parser.parse_request(LS.ckstring(text), true);
     parser.store(LS, tab);
@@ -1887,7 +1887,7 @@ LuaDefine(http_serverresponse, "response",
     "|that would be sent.") {
     LuaArg tab;
     LuaRet str;
-    LuaStack LS(L, tab, str);
+    LuaOldStack LS(L, tab, str);
     LuaKeywordParser kp(LS, tab);
     HttpServerResponse resp;
     resp.configure(kp);
@@ -1901,7 +1901,7 @@ LuaDefine(http_serverresponse, "response",
 LuaDefine(http_validmime, "(mt)", "") {
     LuaArg str;
     LuaRet ok;
-    LuaStack LS(L, str, ok);
+    LuaOldStack LS(L, str, ok);
     LS.set(ok, valid_mime_type(LS.ckstring(str)));
     return LS.result();
 }
@@ -1909,7 +1909,7 @@ LuaDefine(http_validmime, "(mt)", "") {
 LuaDefine(http_statusstring, "(statuscode)", "Convert a 3-digit status code to a string") {
     LuaArg code;
     LuaRet str;
-    LuaStack LS(L, code, str);
+    LuaOldStack LS(L, code, str);
     int icode = LS.ckint(code);
     LS.set(str, status_code_to_string(icode));
     return LS.result();
@@ -1918,7 +1918,7 @@ LuaDefine(http_statusstring, "(statuscode)", "Convert a 3-digit status code to a
 LuaDefine(http_statuscode, "(statusstring)", "Convert a string to a 3-digit status code") {
     LuaArg str;
     LuaRet code;
-    LuaStack LS(L, code, str);
+    LuaOldStack LS(L, code, str);
     eng::string sstr = LS.ckstring(str);
     LS.set(code, status_code_from_string(sstr));
     int iresult = LS.result();
diff --git a/luprex/cpp/core/http.hpp b/luprex/cpp/core/http.hpp
index 4bb40e5a..2e29c0fe 100644
--- a/luprex/cpp/core/http.hpp
+++ b/luprex/cpp/core/http.hpp
@@ -87,17 +87,17 @@ public:
     void set_mime_type(const eng::string &mime_type);
     void set_content(const eng::string &content);
  
-    void set_verify_certificate(LuaStack &LS, LuaSlot val);
-    void set_method(LuaStack &LS, LuaSlot val);
-    void set_host(LuaStack &LS, LuaSlot val);
-    void set_port(LuaStack &LS, LuaSlot val);
-    void set_path(LuaStack &LS, LuaSlot path);
-    void set_param(LuaStack &LS, LuaSlot key, LuaSlot val);
-    void set_params(LuaStack &LS, LuaSlot tab);
-    void set_url(LuaStack &LS, LuaSlot val);
-    void set_mime_type(LuaStack &LS, LuaSlot val);
-    void set_content(LuaStack &LS, LuaSlot val);
-    void set_jsonvalue(LuaStack &LS, LuaSlot val);
+    void set_verify_certificate(LuaCoreStack &LS, LuaSlot val);
+    void set_method(LuaCoreStack &LS, LuaSlot val);
+    void set_host(LuaCoreStack &LS, LuaSlot val);
+    void set_port(LuaCoreStack &LS, LuaSlot val);
+    void set_path(LuaCoreStack &LS, LuaSlot path);
+    void set_param(LuaCoreStack &LS, LuaSlot key, LuaSlot val);
+    void set_params(LuaCoreStack &LS, LuaSlot tab);
+    void set_url(LuaCoreStack &LS, LuaSlot val);
+    void set_mime_type(LuaCoreStack &LS, LuaSlot val);
+    void set_content(LuaCoreStack &LS, LuaSlot val);
+    void set_jsonvalue(LuaCoreStack &LS, LuaSlot val);
 
     // Set default values for method and port.
     // This must be done after setting regular values.
@@ -198,11 +198,11 @@ public:
     void set_mime_type(const eng::string &mime_type);
     void set_content(const eng::string &content);
  
-    void set_status(LuaStack &LS, LuaSlot val);
-    void set_max_age(LuaStack &LS, LuaSlot val);
-    void set_mime_type(LuaStack &LS, LuaSlot val);
-    void set_content(LuaStack &LS, LuaSlot val);
-    void set_jsonvalue(LuaStack &LS, LuaSlot val);
+    void set_status(LuaCoreStack &LS, LuaSlot val);
+    void set_max_age(LuaCoreStack &LS, LuaSlot val);
+    void set_mime_type(LuaCoreStack &LS, LuaSlot val);
+    void set_content(LuaCoreStack &LS, LuaSlot val);
+    void set_jsonvalue(LuaCoreStack &LS, LuaSlot val);
 
     // Set default values.
     //
@@ -388,7 +388,7 @@ public:
 
     // Store the parsed fields into a lua table.
     //
-    void store(LuaStack &LS, LuaSlot tab) const;
+    void store(LuaCoreStack &LS, LuaSlot tab) const;
 
     // The parser will not try to parse content longer than this.
     //
@@ -420,7 +420,7 @@ public:
 
     // Synthesize an error and store it in lua.
     //
-    static void store_fail(LuaStack &LS, LuaSlot tab, int status, std::string_view error);
+    static void store_fail(LuaCoreStack &LS, LuaSlot tab, int status, std::string_view error);
 };
 
 class HttpClientRequestMap : public eng::map<int64_t, HttpClientRequest> {
diff --git a/luprex/cpp/core/json.cpp b/luprex/cpp/core/json.cpp
index a2ced793..fb9b742e 100644
--- a/luprex/cpp/core/json.cpp
+++ b/luprex/cpp/core/json.cpp
@@ -311,7 +311,7 @@ static bool decode_number(lua_State *L, std::string_view &v) {
     // is OK.
     if (sv::valid_number(n, true, true, false, false)) {
         int64_t i = sv::to_int64(n);
-        if (!LuaStack::int64_storable(i)) return false;
+        if (!LuaOldStack::int64_storable(i)) return false;
         lua_pushnumber(L, double(i));
         return true;
     } else {
@@ -361,7 +361,7 @@ static bool decode_int_string(lua_State *L, std::string_view &v) {
     // Make sure the number fits in a lua double,
     // and push it on the stack.
     int64_t i = sv::to_int64(n);
-    if (!LuaStack::int64_storable(i)) {
+    if (!LuaOldStack::int64_storable(i)) {
         return false;
     }
     lua_pushnumber(L, double(i));
@@ -515,7 +515,7 @@ static bool decode_value(lua_State *L, std::string_view &v) {
 
 namespace json {
 
-eng::string encode(LuaStack &LS, LuaSlot in, eng::string &out, bool indent, int maxlen) {
+eng::string encode(LuaCoreStack &LS, LuaSlot in, eng::string &out, bool indent, int maxlen) {
     eng::ostringstream oss;
 
     // Call the recursive encoder.  Clean up any crap on the lua stack afterward.
@@ -540,7 +540,7 @@ eng::string encode(LuaStack &LS, LuaSlot in, eng::string &out, bool indent, int
     }
 }
 
-bool decode(LuaStack &LS, LuaSlot out, std::string_view v) {
+bool decode(LuaCoreStack &LS, LuaSlot out, std::string_view v) {
     lua_State *L = LS.state();
 
     // Try to read a single value from the view.
@@ -661,7 +661,7 @@ LuaDefine(json_encode, "data, indent, maxlen",
     "|") {
     LuaArg data, indent, maxlen;
     LuaRet encoded;
-    LuaStack LS(L, data, indent, maxlen, encoded);
+    LuaOldStack LS(L, data, indent, maxlen, encoded);
     eng::string out;
     eng::string error = json::encode(LS, data, out, LS.ckboolean(indent), LS.ckint(maxlen));
     if (!error.empty()) {
@@ -695,7 +695,7 @@ LuaDefine(json_decode, "data",
     "|") {
     LuaArg encoded;
     LuaRet data;
-    LuaStack LS(L, encoded, data);
+    LuaOldStack LS(L, encoded, data);
     std::string_view v = LS.ckstringview(encoded);
     bool ok = json::decode(LS, data, v);
     if (!ok) {
@@ -707,7 +707,7 @@ LuaDefine(json_decode, "data",
 // LuaDefine(base64_encode, "data", "") {
 //     LuaArg str;
 //     LuaRet ret;
-//     LuaStack LS(L, str, ret);
+//     LuaOldStack LS(L, str, ret);
 //     eng::string cstr = LS.ckstring(str);
 //     eng::ostringstream oss;
 //     util::base64_encode(cstr, &oss);
@@ -718,7 +718,7 @@ LuaDefine(json_decode, "data",
 // LuaDefine(base64_decode, "data", "") {
 //     LuaArg str;
 //     LuaRet ret;
-//     LuaStack LS(L, str, ret);
+//     LuaOldStack LS(L, str, ret);
 //     eng::string cstr = LS.ckstring(str);
 //     eng::ostringstream oss;
 //     util::base64_decode(cstr, &oss);
diff --git a/luprex/cpp/core/json.hpp b/luprex/cpp/core/json.hpp
index 80d0e3a6..35e06cd0 100644
--- a/luprex/cpp/core/json.hpp
+++ b/luprex/cpp/core/json.hpp
@@ -17,7 +17,7 @@ namespace json {
     // Returns an error message.  If the error message is an
     // empty string, then the encoding was successful.
     //
-    eng::string encode(LuaStack &LS, LuaSlot in, eng::string &out, bool indent, int maxlen);
+    eng::string encode(LuaCoreStack &LS, LuaSlot in, eng::string &out, bool indent, int maxlen);
 
     // Decode json.
     //
@@ -27,7 +27,7 @@ namespace json {
     // In that case, we return false and set 'out' to the
     // token 'error'.
     //
-    bool decode(LuaStack &LS, LuaSlot out, std::string_view in);
+    bool decode(LuaCoreStack &LS, LuaSlot out, std::string_view in);
 }
     
 #endif // JSON_HPP
diff --git a/luprex/cpp/core/luaconsole.cpp b/luprex/cpp/core/luaconsole.cpp
index 55093169..228aa953 100644
--- a/luprex/cpp/core/luaconsole.cpp
+++ b/luprex/cpp/core/luaconsole.cpp
@@ -9,7 +9,7 @@
 #include <iostream>
 
 LuaConsole::LuaConsole() {
-    lua_state_ = LuaStack::newstate(eng::l_alloc);
+    lua_state_ = LuaOldStack::newstate(eng::l_alloc);
     clear_raw_input();
 }
 
diff --git a/luprex/cpp/core/luasnap.cpp b/luprex/cpp/core/luasnap.cpp
index ae307e71..f7b70087 100644
--- a/luprex/cpp/core/luasnap.cpp
+++ b/luprex/cpp/core/luasnap.cpp
@@ -10,8 +10,8 @@
 
 
 LuaSnap::LuaSnap() {
-    state_ = LuaStack::newstate(eng::l_alloc);
-    LuaStack LS(state_);
+    state_ = LuaOldStack::newstate(eng::l_alloc);
+    LuaOldStack LS(state_);
 
     // Create the persist table and the unpersist table.
     //
@@ -36,7 +36,7 @@ void LuaSnap::serialize(StreamBuffer *sb) {
     // lua variables that we'll need.
     LuaVar key, value;
     LuaRet permstable, regcopy;
-    LuaStack LS(state_, permstable, regcopy, key, value);
+    LuaOldStack LS(state_, permstable, regcopy, key, value);
 
     // Construct a copy of the registry table.
     LS.set(regcopy, LuaNewTable);
@@ -93,7 +93,7 @@ void LuaSnap::deserialize(StreamBuffer *sb) {
     // Set up a stack frame.
     LuaArg permstable, regcopy;
     LuaVar key, value;
-    LuaStack LS(state_, permstable, regcopy, key, value);
+    LuaOldStack LS(state_, permstable, regcopy, key, value);
 
     assert(LS.istable(regcopy));
 
diff --git a/luprex/cpp/core/luastack.cpp b/luprex/cpp/core/luastack.cpp
index 4358ae07..08562033 100644
--- a/luprex/cpp/core/luastack.cpp
+++ b/luprex/cpp/core/luastack.cpp
@@ -236,7 +236,7 @@ eng::string LuaCoreStack::classname(LuaSlot tab) const {
     eng::string result;
     if ((istable(tab)) && (gettabletype(tab) == LUA_TT_CLASS)) {
         LuaVar classes, name, dup;
-        LuaStack LS(L_, classes, name, dup);
+        LuaOldStack LS(L_, classes, name, dup);
         // Get the classes table from the registry.
         LS.rawget(classes, LuaRegistry, "classes");
 
@@ -268,7 +268,7 @@ eng::string LuaCoreStack::classname(LuaSlot tab) const {
 eng::string LuaCoreStack::getclass(LuaSlot classtab, LuaSlot classname) const {
     lua_checkstack(L_, 20);
     LuaVar globtab, cname;
-    LuaStack LS(L_, globtab, cname);
+    LuaOldStack LS(L_, globtab, cname);
     LS.getglobaltable(globtab);
 
     if (LS.isstring(classname)) {
@@ -329,7 +329,7 @@ eng::string LuaCoreStack::getclass(LuaSlot tab, std::string_view name) const {
 void LuaCoreStack::makeclass(LuaSlot classtab, LuaSlot classname) const {
     lua_checkstack(L_, 20);
     LuaVar classes, globtab, cname;
-    LuaStack LS(L_, classes, globtab, cname);
+    LuaOldStack LS(L_, classes, globtab, cname);
 
     // Validate the class name.
     assert(LS.validclassname(classname));
@@ -371,7 +371,7 @@ void LuaCoreStack::makeclass(LuaSlot tab, std::string_view name) const {
 
 void LuaCoreStack::maketan(LuaSlot tab, int64_t id) const {
     LuaVar tangibles, metatab;
-    LuaStack LS(L_, tangibles, metatab);
+    LuaOldStack LS(L_, tangibles, metatab);
     
     // Try to get the existing tangible.
     LS.rawget(tangibles, LuaRegistry, "tangibles");
diff --git a/luprex/cpp/core/luastack.hpp b/luprex/cpp/core/luastack.hpp
index a8b5cd7c..e8a8e3a3 100644
--- a/luprex/cpp/core/luastack.hpp
+++ b/luprex/cpp/core/luastack.hpp
@@ -1,20 +1,20 @@
 /////////////////////////////////////////////////////////
 //
 //
-// LUASTACK
+// LuaOldStack
 //
 // The standard lua C API asks you to work with a stack machine. You're supposed
 // to manually push and pop values on the lua stack. I find this difficult, I
 // find it hard to remember what stack position contains what value.
 //
-// To make it easier, I've created this module, "LuaStack."  This module
+// To make it easier, I've created this module, "LuaOldStack."  This module
 // creates the illusion that you're working with local variables that contain
 // lua values.
 //
 // Of course, this is all using the lua stack under the covers.  Lua
 // local variables are actually just lua stack addresses.  But that's
 // all kept fairly well hidden.  When you use Lua local variables, and
-// the accessors inside class LuaStack, it appears that you're
+// the accessors inside class LuaOldStack, it appears that you're
 // manipulating data using local variables instead of using a stack.
 // For people like me, that's easier to think about.
 //
@@ -31,7 +31,7 @@
 //     LuaVar loc1, loc2, loc3;   // Declare local variables for other purposes.
 //
 //     // Assign every local var a stack index.
-//     LuaStack LS(L, arg1, arg2, ret1, loc1, loc2, loc3);
+//     LuaOldStack LS(L, arg1, arg2, ret1, loc1, loc2, loc3);
 //
 //     // manipulate the data in the lua local variables...
 //     LS.rawget(loc1, arg1, arg2);
@@ -39,15 +39,15 @@
 // }
 //
 // Class LuaArg, LuaRet, and LuaVar are all lua local variables.
-// The luastack constructor assigns each one of them a position on
+// The LuaOldStack constructor assigns each one of them a position on
 // the lua stack.  It also makes sure that the arguments are in
 // the LuaArg variables, and it makes sure that the LuaRet values
 // are the only thing left on the stack at return time.
 //
-// Class LuaStack provides a complete catalog of accessors
+// Class LuaOldStack provides a complete catalog of accessors
 // like 'rawget' - roughly speaking, it provides equivalents to
 // every major accessor in the lua API.  However, the accessors
-// provided by LuaStack take input and output from lua locals, not
+// provided by LuaOldStack take input and output from lua locals, not
 // from the stack.  For example, consider this:
 //
 //    LS.rawget(value, tab, key);
@@ -56,20 +56,20 @@
 // This does a rawget on 'table', with the specified 'key', and
 // stores the result in 'value'.  Nothing is added to or removed
 // from the lua stack.  In general, none of the accessors in class
-// LuaStack add anything to the stack, or pop anything from the
+// LuaOldStack add anything to the stack, or pop anything from the
 // stack.
 //
-// Class LuaStack can also do automatic type conversions.  For
+// Class LuaOldStack can also do automatic type conversions.  For
 // example, suppose you do this:
 //
 //    LS.rawget(value, tab, key);
 //
 // Nominally, you would expect value, tab, and key to be lua local
-// variables. But if you pass a eng::string for key, then LuaStack will
-// automatically convert it.  In general, class LuaStack can
+// variables. But if you pass a eng::string for key, then LuaOldStack will
+// automatically convert it.  In general, class LuaOldStack can
 // convert lua_Integer, lua_Number, eng::string, bool, and LuaNil.
 //
-// On output, LuaStack can convert lua_Integers, lua_Numbers, and
+// On output, LuaOldStack can convert lua_Integers, lua_Numbers, and
 // eng::strings.  In this case, strict type checking is done.  If
 // there is a type mismatch, a lua error is thrown.
 //
@@ -90,20 +90,20 @@
 /////////////////////////////////////////////////////////
 //
 //
-// LuaStack type checking
+// LuaOldStack type checking
 //
-// LuaStack contains accessors for type checking.  These include:
+// LuaOldStack contains accessors for type checking.  These include:
 //
-//     bool LuaStack::isnumber(LuaSlot s)
-//     bool LuaStack::isinteger(LuaSlot s)
-//     bool LuaStack::isstring(LuaSlot s)
+//     bool LuaOldStack::isnumber(LuaSlot s)
+//     bool LuaOldStack::isinteger(LuaSlot s)
+//     bool LuaOldStack::isstring(LuaSlot s)
 //     etc...
 //
 // And it also contains operations that throw errors:
 //
-//     void LuaStack::checknumber(LuaSlot s)
-//     void LuaStack::checkinteger(LuaSlot s)
-//     void LuaStack::checkstring(LuaSlot s)
+//     void LuaOldStack::checknumber(LuaSlot s)
+//     void LuaOldStack::checkinteger(LuaSlot s)
+//     void LuaOldStack::checkstring(LuaSlot s)
 //     etc...
 //
 // These are different from the lua builtins in that they are strict.
@@ -112,10 +112,10 @@
 //
 // These functions do checking and also conversion at the same time:
 //
-//     lua_Integer  LuaStack::ckinteger(LuaSlot s)
-//     lua_Number   LuaStack::cknumber(LuaSlot s)
-//     eng::string  LuaStack::ckstring(LuaSlot s)
-//     lua_State   *LuaStack::ckthread(LuaSlot s)
+//     lua_Integer  LuaOldStack::ckinteger(LuaSlot s)
+//     lua_Number   LuaOldStack::cknumber(LuaSlot s)
+//     eng::string  LuaOldStack::ckstring(LuaSlot s)
+//     lua_State   *LuaOldStack::ckthread(LuaSlot s)
 //
 // Like the other operations, they are strict.
 //
@@ -151,8 +151,8 @@
 /////////////////////////////////////////////////////////
 
 
-#ifndef LUASTACK_HPP
-#define LUASTACK_HPP
+#ifndef LuaOldStack_HPP
+#define LuaOldStack_HPP
 
 #include "wrap-string.hpp"
 #include "wrap-set.hpp"
@@ -180,7 +180,7 @@ public:
     }
     
     friend class LuaCoreStack;
-    friend class LuaStack;
+    friend class LuaOldStack;
     friend class LuaExtStack;
 };
 
@@ -476,7 +476,7 @@ public:
     static bool int64_storable(int64_t v) { return (v <= MAXINT) && (v >= -MAXINT); }
 };
 
-class LuaStack : public LuaCoreStack {
+class LuaOldStack : public LuaCoreStack {
 private:
     int narg_;
     int ngap_;
@@ -549,7 +549,7 @@ private:
 
 public:
     template<class... SS>
-    LuaStack(lua_State *L, SS & ... stackslots) {
+    LuaOldStack(lua_State *L, SS & ... stackslots) {
         L_ = L;
         count_slots<0, 0, 0>(stackslots...);
         if (lua_gettop(L) < narg_) {
@@ -573,10 +573,140 @@ public:
         return nret_;
     }
 
-    ~LuaStack() {};
+    ~LuaOldStack() {};
 };
 
 
+class LuaDefStack : public LuaCoreStack {
+private:
+    int nret_;
+    int narg_;
+    int nvar_;
+
+    template<class... SS>
+    void assign_slots(int retp, int argp, int varp, LuaRet &v, SS & ... stackslots) {
+        v.index_ = retp;
+        assign_slots(retp+1, argp, varp, stackslots...);
+    }
+    template<class... SS>
+    void assign_slots(int retp, int argp, int varp, LuaArg &v, SS & ... stackslots) {
+        v.index_ = argp;
+        assign_slots(retp, argp + 1, varp, stackslots...);
+    }
+    template<class... SS>
+    void assign_slots(int retp, int argp, int varp, LuaVar &v, SS & ... stackslots) {
+        v.index_ = varp;
+        assign_slots(retp, argp, varp+1, stackslots...);
+    }
+    void assign_slots(int retp, int argp, int varp) {}
+
+    template<int NRET, int NARG, int NVAR, class... SS>
+    void count_slots(LuaRet &v, SS & ... stackslots)
+    {
+        count_slots<NRET+1, NARG, NVAR>(stackslots...);
+    }
+    template<int NRET, int NARG, int NVAR, class... SS>
+    void count_slots(LuaArg &v, SS & ... stackslots)
+    {
+        count_slots<NRET, NARG+1, NVAR>(stackslots...);
+    }
+    template<int NRET, int NARG, int NVAR, class... SS>
+    void count_slots(LuaVar &v, SS & ... stackslots)
+    {
+        count_slots<NRET, NARG, NVAR+1>(stackslots...);
+    }
+    template<int NRET, int NARG, int NVAR>
+    void count_slots() {
+        nret_ = NRET;
+        narg_ = NARG;
+        nvar_ = NVAR;
+    }
+
+public:
+    template<class... SS>
+    LuaDefStack(lua_State *L, SS & ... stackslots) {
+        L_ = L;
+        count_slots<0, 0, 0>(stackslots...);
+        if (lua_gettop(L_) != narg_) {
+            luaL_error(L_, "function expects exactly %d arguments", narg_);
+        }
+        int tot = narg_ + nvar_ + nret_;
+        lua_checkstack(L, tot + 20);
+        for (int i = 0; i < nret_; i ++) {
+            lua_pushnil(L_);
+            lua_insert(L_, i + 1);
+        }
+        for (int i = 0; i < nvar_; i++) {
+            lua_pushnil(L_);
+        }
+        assign_slots(1, 1 + nret_, 1 + nret_ + narg_, stackslots...);
+    }
+
+    ~LuaDefStack() {
+        if (!lua_isthrowing(L_)) {
+            lua_settop(L_, nret_);
+        };
+    }
+};
+
+class LuaExtStack : public LuaCoreStack {
+private:
+    int oldtop_;
+    int nvar_;
+
+    template<class... SS>
+    void assign_slots(int varp, LuaVar &v, SS & ... stackslots) {
+        v.index_ = varp;
+        assign_slots(varp+1, stackslots...);
+    }
+    void assign_slots(int varp) {}
+
+    template<int NVAR, class... SS>
+    void count_slots(LuaVar &v, SS & ... stackslots)
+    {
+        count_slots<NVAR+1>(stackslots...);
+    }
+    template<int NVAR>
+    void count_slots() {
+        nvar_ = NVAR;
+    }
+
+public:
+    template<class... SS>
+    LuaExtStack(lua_State *L, SS & ... stackslots) {
+        L_ = L;
+        count_slots<0>(stackslots...);
+        lua_checkstack(L_, nvar_ + 20);
+        oldtop_ = lua_gettop(L_);
+        for (int i = 0; i < nvar_; i++) {
+            lua_pushnil(L_);
+        }
+        assign_slots(oldtop_ + 1, stackslots...);
+    }
+
+    template<class... SS>
+    LuaExtStack(const LuaCoreStack &LS0, SS & ... stackslots) {
+        L_ = LS0.state();
+        count_slots<0>(stackslots...);
+        lua_checkstack(L_, nvar_ + 20);
+        oldtop_ = lua_gettop(L_);
+        for (int i = 0; i < nvar_; i++) {
+            lua_pushnil(L_);
+        }
+        assign_slots(oldtop_ + 1, stackslots...);
+    }
+
+    ~LuaExtStack() {
+        if (!lua_isthrowing(L_)) {
+            lua_settop(L_, oldtop_);
+        }
+     }
+
+    void forcediscard() {
+        lua_settop(L_, oldtop_);
+    }
+};
+
 // This is a helper class to help parse tables full of keywords.
 class LuaKeywordParser {
     struct cmp_char {
@@ -595,7 +725,7 @@ public:
     // If the slot is not a table, sets the not_table
     // flag and creates a dummy table in the slot.
     LuaKeywordParser(lua_State *L, int slot);
-    LuaKeywordParser(const LuaStack &LS, LuaSlot slot) : LuaKeywordParser(LS.state(), slot.index()) {}
+    LuaKeywordParser(const LuaCoreStack &LS, LuaSlot slot) : LuaKeywordParser(LS.state(), slot.index()) {}
 
     // Fetch a value from the table.  This never throws.
     // Return true if the value is non-nil.
@@ -682,4 +812,4 @@ public:
 #define LuaAssert(L, x) if (!(x)) { luaL_error((L), "Assert failed: %s (file %s line %d)", LuaStringify(x), __FILE__, __LINE__); }
 #define LuaAssertStrEq(L, x, y) { eng::string _s1_(x); eng::string _s2_(y); if (_s1_ != _s2_) luaL_error((L), "Assert failed: value=%s (file %s line %d)", _s1_.c_str(), __FILE__, __LINE__); }
 
-#endif // LUASTACK_HPP
+#endif // LuaOldStack_HPP
diff --git a/luprex/cpp/core/planemap.cpp b/luprex/cpp/core/planemap.cpp
index ae04f10c..f564243e 100644
--- a/luprex/cpp/core/planemap.cpp
+++ b/luprex/cpp/core/planemap.cpp
@@ -830,7 +830,7 @@ void PlaneMap::untrack_all() {
 void PlaneScan::configure(LuaKeywordParser &kp) {
     lua_State *L = kp.state();
     LuaVar val, vx, vy, vz;
-    LuaStack LS(L, val, vx, vy, vz);
+    LuaOldStack LS(L, val, vx, vy, vz);
 
     bool have_plane = false;
     bool have_center = false;
diff --git a/luprex/cpp/core/pprint.cpp b/luprex/cpp/core/pprint.cpp
index ab778790..8b3a8b6f 100644
--- a/luprex/cpp/core/pprint.cpp
+++ b/luprex/cpp/core/pprint.cpp
@@ -10,7 +10,7 @@
 class PrintMachine {
 public:
     LuaVar tabchpos_;
-    LuaStack LS_;
+    LuaOldStack LS_;
     int next_id_;
     bool indent_;
     std::ostream *output_;
@@ -103,7 +103,7 @@ public:
         lua_State *L = LS_.state();
         lua_checkstack(L, 20);
         LuaVar loffset, pairs, key, val, lchpos, nextseq;
-        LuaStack LS(L, loffset, pairs, key, val, lchpos, nextseq);
+        LuaOldStack LS(L, loffset, pairs, key, val, lchpos, nextseq);
 
         // Determine the extended type of the object. If the
         // expand flag is true, try to coerce it to a general table.
@@ -212,7 +212,7 @@ public:
     }
 
     // Atomic print interface.
-    PrintMachine(LuaStack &LS0, LuaSlot root, bool quote, std::ostream *os) :
+    PrintMachine(LuaCoreStack &LS0, LuaSlot root, bool quote, std::ostream *os) :
             LS_(LS0.state(), tabchpos_) {
         output_ = os;
         atomic_print(LS_.xtype(root), root, quote);
@@ -220,7 +220,7 @@ public:
     }
 
     // Pretty print interface.
-    PrintMachine(LuaStack &LS0, LuaSlot root, bool indent, int level, bool expand, std::ostream *os) : 
+    PrintMachine(LuaCoreStack &LS0, LuaSlot root, bool indent, int level, bool expand, std::ostream *os) : 
             LS_(LS0.state(), tabchpos_) {
         next_id_ = 1;
         indent_ = indent;
@@ -248,7 +248,7 @@ public:
 
 void PrettyPrintOptions::parse(LuaKeywordParser &kp) {
     LuaVar option;
-    LuaStack LS(kp.state(), option);
+    LuaOldStack LS(kp.state(), option);
     if (kp.parse(option, "indent")) {
         indent = LS.ckboolean(option);
     }
@@ -261,11 +261,11 @@ void PrettyPrintOptions::parse(LuaKeywordParser &kp) {
     LS.result();
 }
 
-void atomic_print(LuaStack &LS, LuaSlot val, bool quote, std::ostream *os) {
+void atomic_print(LuaCoreStack &LS, LuaSlot val, bool quote, std::ostream *os) {
     PrintMachine pm(LS, val, quote, os);
 }
 
-void pprint(LuaStack &LS, LuaSlot val, const PrettyPrintOptions &opts, std::ostream *os) {
+void pprint(LuaCoreStack &LS, LuaSlot val, const PrettyPrintOptions &opts, std::ostream *os) {
     PrintMachine pm(LS, val, opts.indent, opts.level, opts.expand, os);
 }
 
@@ -279,7 +279,7 @@ LuaDefine(string_pprint, "obj1, obj2, ...",
     "|") {
     int n = lua_gettop(L);
     LuaRet result;
-    LuaStack LS(L, result);
+    LuaOldStack LS(L, result);
     util::ostringstream oss;
     for (int i = 1; i <= n; i++) {
         LuaSpecial root(i);
@@ -310,7 +310,7 @@ LuaDefine(string_pprintx, "options",
     LuaArg loptions;
     LuaRet result;
     LuaVar value;
-    LuaStack LS(L, loptions, result, value);
+    LuaOldStack LS(L, loptions, result, value);
     PrettyPrintOptions options;
     LuaKeywordParser kp(LS, loptions);
     options.parse(kp);
@@ -333,7 +333,7 @@ LuaDefine(string_print, "obj",
     "|") {
     LuaArg val;
     LuaRet result;
-    LuaStack LS(L, val, result);
+    LuaOldStack LS(L, val, result);
     eng::ostringstream oss;
     atomic_print(LS, val, false, &oss);
     LS.set(result, oss.str());
@@ -350,7 +350,7 @@ LuaDefine(tostring, "obj",
     "|") {
     LuaArg val;
     LuaRet result;
-    LuaStack LS(L, val, result);
+    LuaOldStack LS(L, val, result);
     eng::ostringstream oss;
     atomic_print(LS, val, false, &oss);
     LS.set(result, oss.str());
@@ -360,7 +360,7 @@ LuaDefine(tostring, "obj",
 LuaDefine(string_isidentifier, "str", "return true if the string is a valid lua identifier") {
     LuaArg str;
     LuaRet result;
-    LuaStack LS(L, str, result);
+    LuaOldStack LS(L, str, result);
     if (LS.isstring(str)) {
         eng::string s = LS.ckstring(str);
         LS.set(result, sv::is_lua_id(s));
diff --git a/luprex/cpp/core/pprint.hpp b/luprex/cpp/core/pprint.hpp
index 10ca7066..7f4a7729 100644
--- a/luprex/cpp/core/pprint.hpp
+++ b/luprex/cpp/core/pprint.hpp
@@ -36,10 +36,10 @@ struct PrettyPrintOptions {
 // it just prints "<table>".  This routine is the heart of the lua
 // primitives 'print' and 'tostring'.
 //
-void atomic_print(LuaStack &LS, LuaSlot val, bool quote, std::ostream *os);
+void atomic_print(LuaCoreStack &LS, LuaSlot val, bool quote, std::ostream *os);
 
 // Pretty print to a stream.
 //
-void pprint(LuaStack &LS, LuaSlot val, const PrettyPrintOptions &opts, std::ostream *os);
+void pprint(LuaCoreStack &LS, LuaSlot val, const PrettyPrintOptions &opts, std::ostream *os);
 
 #endif // PPRINT_HPP
\ No newline at end of file
diff --git a/luprex/cpp/core/serializelua.cpp b/luprex/cpp/core/serializelua.cpp
index 4c690346..07142d7c 100644
--- a/luprex/cpp/core/serializelua.cpp
+++ b/luprex/cpp/core/serializelua.cpp
@@ -12,14 +12,14 @@ class DeserializeError {
 
 class Deserializer {
     LuaVar id_to_value_;
-    LuaStack LS_;
+    LuaOldStack LS_;
     eng::string &error_;
     StreamBuffer *sb_;
     int next_id_;
 
     void deserialize_table_r(LuaSlot target) {
         LuaVar key, val;
-        LuaStack LS(LS_.state(), key, val);
+        LuaOldStack LS(LS_.state(), key, val);
         LS.newtable(target);
         LS.rawset(id_to_value_, next_id_++, target);
         bool hasmeta = sb_->read_bool();
@@ -104,7 +104,7 @@ class Deserializer {
     }
 
 public:
-    Deserializer(LuaStack &LS0, LuaSlot val, StreamBuffer *sb, eng::string &error) :
+    Deserializer(LuaCoreStack &LS0, LuaSlot val, StreamBuffer *sb, eng::string &error) :
         LS_(LS0.state(), id_to_value_), error_(error), sb_(sb), next_id_(1) {
         LS_.newtable(id_to_value_);
         int top = lua_gettop(LS_.state());
@@ -137,14 +137,14 @@ public:
 class Serializer {
     LuaVar lookup_;
     LuaVar value_to_id_;
-    LuaStack LS_;
+    LuaOldStack LS_;
     eng::string &error_;
     StreamBuffer *sb_;
     int next_id_;
 
     void serialize_table_r(LuaSlot tab) {
         LuaVar key, val;
-        LuaStack SLS(LS_.state(), key, val);
+        LuaOldStack SLS(LS_.state(), key, val);
         sb_->write_uint8(LUA_TT_GENERAL);
         SLS.getmetatable(val, tab);
         if (SLS.isnil(val)) {
@@ -265,7 +265,7 @@ class Serializer {
     }
 
 public:
-    Serializer(LuaStack &LS0, LuaSlot val, StreamBuffer *sb, eng::string &error) :
+    Serializer(LuaCoreStack &LS0, LuaSlot val, StreamBuffer *sb, eng::string &error) :
         LS_(LS0.state(), lookup_, value_to_id_), error_(error), sb_(sb), next_id_(1) {
         LS_.newtable(value_to_id_);
         sb_->write_uint16(0xD096);
@@ -274,13 +274,13 @@ public:
     }
 };
 
-eng::string serialize_lua(LuaStack &LS0, LuaSlot val, StreamBuffer *sb) {
+eng::string serialize_lua(LuaCoreStack &LS0, LuaSlot val, StreamBuffer *sb) {
     eng::string error;
     Serializer sz(LS0, val, sb, error);
     return error;
 };
 
-eng::string deserialize_lua(LuaStack &LS0, LuaSlot val, StreamBuffer *sb) {
+eng::string deserialize_lua(LuaCoreStack &LS0, LuaSlot val, StreamBuffer *sb) {
     eng::string error;
     Deserializer dsz(LS0, val, sb, error);
     if (!error.empty()) {
@@ -328,7 +328,7 @@ LuaDefine(table_serialize, "value",
     "|") {
     LuaArg value;
     LuaRet str;
-    LuaStack LS(L, value, str);
+    LuaOldStack LS(L, value, str);
     StreamBuffer sb;
     eng::string error = serialize_lua(LS, value, &sb);
     if (!error.empty()) {
@@ -347,7 +347,7 @@ LuaDefine(table_deserialize, "binary",
     "|") {
     LuaArg str;
     LuaRet value;
-    LuaStack LS(L, value, str);
+    LuaOldStack LS(L, value, str);
     std::string_view s = LS.ckstringview(str);
     StreamBuffer sb(s);
     eng::string error = deserialize_lua(LS, value, &sb);
diff --git a/luprex/cpp/core/serializelua.hpp b/luprex/cpp/core/serializelua.hpp
index feafced6..c3b8f34f 100644
--- a/luprex/cpp/core/serializelua.hpp
+++ b/luprex/cpp/core/serializelua.hpp
@@ -25,7 +25,7 @@
 // If there is an error, returns an error message.  In this case, the
 // streambuffer contains garbage.
 //
-eng::string serialize_lua(LuaStack &LS0, LuaSlot val, StreamBuffer *sb);
+eng::string serialize_lua(LuaCoreStack &LS0, LuaSlot val, StreamBuffer *sb);
 
 // deserialize_lua
 //
@@ -35,6 +35,6 @@ eng::string serialize_lua(LuaStack &LS0, LuaSlot val, StreamBuffer *sb);
 // If there is an error, returns an error message.  In this case, the
 // streambuffer is likely only partially consumed.
 //
-eng::string deserialize_lua(LuaStack &LS0, LuaSlot val, StreamBuffer *sb);
+eng::string deserialize_lua(LuaCoreStack &LS0, LuaSlot val, StreamBuffer *sb);
 
 #endif // SERIALIZELUA_HPP
diff --git a/luprex/cpp/core/source.cpp b/luprex/cpp/core/source.cpp
index 8aa824b6..54e07ad7 100644
--- a/luprex/cpp/core/source.cpp
+++ b/luprex/cpp/core/source.cpp
@@ -21,7 +21,7 @@
 LuaDefine(makeclass, "classname", "create a class if it doesn't already exist") {
     LuaArg classname;
     LuaRet classtab;
-    LuaStack LS(L, classname, classtab);
+    LuaOldStack LS(L, classname, classtab);
     if (!LS.isstring(classname)) {
         luaL_error(L, "class name must be a string");
     }
@@ -35,7 +35,7 @@ LuaDefine(makeclass, "classname", "create a class if it doesn't already exist")
 LuaDefine(getclass, "classname", "get the classtab with the specified name") {
     LuaArg classname;
     LuaRet classtab;
-    LuaStack LS(L, classname, classtab);
+    LuaOldStack LS(L, classname, classtab);
     eng::string err = LS.getclass(classtab, classname);
     if (err != "") {
         luaL_error(L, "%s", err.c_str());
@@ -46,7 +46,7 @@ LuaDefine(getclass, "classname", "get the classtab with the specified name") {
 LuaDefine(classname, "classtable", "get the class name from a class table") {
     LuaArg table;
     LuaRet result;
-    LuaStack LS(L, table, result);
+    LuaOldStack LS(L, table, result);
     eng::string rstr = LS.classname(table);
     if (rstr == "") {
         LS.set(result, LuaNil);
@@ -67,7 +67,7 @@ static void get_reg_name(std::string_view name, std::string_view &classname, std
     }
 }
 
-static void get_info_table(LuaStack &LS, LuaSlot db, LuaSlot info, const eng::string &fn) {
+static void get_info_table(LuaCoreStack &LS, LuaSlot db, LuaSlot info, const eng::string &fn) {
     LS.rawget(info, db, fn);
     if (!LS.istable(info)) {
         LS.set(info, LuaNewTable);
@@ -76,9 +76,9 @@ static void get_info_table(LuaStack &LS, LuaSlot db, LuaSlot info, const eng::st
     LS.rawset(info, "name", fn);
 }
 
-static void calculate_loadresult(LuaStack &LS0, LuaSlot info, const eng::string &fn, const eng::string &code) {
+static void calculate_loadresult(LuaCoreStack &LS0, LuaSlot info, const eng::string &fn, const eng::string &code) {
     LuaVar loadresult;
-    LuaStack LS(LS0.state(), loadresult);
+    LuaOldStack LS(LS0.state(), loadresult);
     if (code == "") {
         LS.rawset(info, "loadresult", "missing or empty source file");
     } else {
@@ -93,8 +93,8 @@ static void calculate_loadresult(LuaStack &LS0, LuaSlot info, const eng::string
 void SourceDB::diff(const SourceDB &auth, StreamBuffer *sb) {
     LuaVar sdb, sfn, sinfo, shash, sseq;
     LuaVar mdb, mfn, minfo, mhash, mseq, mcode;
-    LuaStack SLS(lua_state_, sdb, sfn, sinfo, shash, sseq);
-    LuaStack MLS(auth.lua_state_, mdb, mfn, minfo, mhash, mseq, mcode);
+    LuaOldStack SLS(lua_state_, sdb, sfn, sinfo, shash, sseq);
+    LuaOldStack MLS(auth.lua_state_, mdb, mfn, minfo, mhash, mseq, mcode);
     sb->write_int32(0);
     int wc_after = sb->total_writes();
     int nupdates = 0;
@@ -152,7 +152,7 @@ void SourceDB::diff(const SourceDB &auth, StreamBuffer *sb) {
 bool SourceDB::patch(StreamBuffer *sb, DebugCollector *dbc) {
     lua_State *L = lua_state_;
     LuaVar db, info;
-    LuaStack LS(L, db, info);
+    LuaOldStack LS(L, db, info);
     LS.rawget(db, LuaRegistry, "sourcedb");
     int nupdates = sb->read_int32();
     for (int i = 0; i < nupdates; i++) {
@@ -179,7 +179,7 @@ bool SourceDB::patch(StreamBuffer *sb, DebugCollector *dbc) {
 void SourceDB::set(const eng::string &fn, const eng::string &code, int sequence) {
     lua_State *L = lua_state_;
     LuaVar db, info;
-    LuaStack LS(L, db, info);
+    LuaOldStack LS(L, db, info);
     LS.rawget(db, LuaRegistry, "sourcedb");
     get_info_table(LS, db, info, fn);
     LS.rawset(info, "sequence", sequence);
@@ -193,7 +193,7 @@ void SourceDB::set(const eng::string &fn, const eng::string &code, int sequence)
 eng::string SourceDB::get(const eng::string &fn) {
     lua_State *L = lua_state_;
     LuaVar db, info, code, sequence, loadresult;
-    LuaStack LS(L, db, info, code, sequence, loadresult);
+    LuaOldStack LS(L, db, info, code, sequence, loadresult);
     LS.rawget(db, LuaRegistry, "sourcedb");
     LS.rawget(info, db, fn);
     if (!LS.istable(info)) {
@@ -220,7 +220,7 @@ eng::string SourceDB::get(const eng::string &fn) {
 void SourceDB::update(const util::LuaSourceVec &source) {
     lua_State *L = lua_state_;
     LuaVar sourcedb, info;
-    LuaStack LS(L, sourcedb, info);
+    LuaOldStack LS(L, sourcedb, info);
 
     // Get and clear the source database.
     LS.rawget(sourcedb, LuaRegistry, "sourcedb");
@@ -250,7 +250,7 @@ void SourceDB::update(const util::LuaSourceVec &source) {
 //
 static void source_clear_globals(lua_State *L) {
     LuaVar classname, classtab, key, globtab, classes;
-    LuaStack LS(L, classname, classtab, key, globtab, classes);
+    LuaOldStack LS(L, classname, classtab, key, globtab, classes);
 
     LS.getglobaltable(globtab);
     LS.cleartable(globtab, true);
@@ -271,7 +271,7 @@ static void source_clear_globals(lua_State *L) {
 //
 static void source_load_cfunctions(lua_State *L) {
     LuaVar classobj;
-    LuaStack LS(L, classobj);
+    LuaOldStack LS(L, classobj);
     for (auto r = LuaFunctionReg::All; r != nullptr; r=r->next()) {
         lua_CFunction func = r->get_func();
         if ((func != nullptr) && (!r->get_sandbox())) {
@@ -294,7 +294,7 @@ static void source_load_cfunctions(lua_State *L) {
 //
 static void source_load_cconstants(lua_State *L) {
     LuaVar classobj, value;
-    LuaStack LS(L, classobj, value);
+    LuaOldStack LS(L, classobj, value);
     for (auto r = LuaConstantReg::All; r != nullptr; r=r->next()) {
         if (r->get_tokenvalue().empty()) {
             LS.set(value, r->get_numbervalue());
@@ -319,7 +319,7 @@ static void source_load_cconstants(lua_State *L) {
 //
 static eng::string source_load_lfunctions(lua_State *L) {
     LuaVar sourcedb, key, info, seq, closure, err;
-    LuaStack LS(L, sourcedb, key, info, seq, closure, err);
+    LuaOldStack LS(L, sourcedb, key, info, seq, closure, err);
 
     // Get the source database.
     LS.rawget(sourcedb, LuaRegistry, "sourcedb");
@@ -364,7 +364,7 @@ static eng::string source_load_lfunctions(lua_State *L) {
 eng::string SourceDB::rebuild() {
     lua_State *L = lua_state_;
     LuaVar mathclass, httpclass, jsonnull;
-    LuaStack LS(L, mathclass, httpclass, jsonnull);
+    LuaOldStack LS(L, mathclass, httpclass, jsonnull);
     source_clear_globals(L);
     source_load_cfunctions(L);
     source_load_cconstants(L);    
@@ -376,7 +376,7 @@ eng::string SourceDB::rebuild() {
 void SourceDB::run_unittests() {
     lua_State *L = lua_state_;
     LuaVar unittests, name, func, err, globtab;
-    LuaStack LS(L, unittests, name, func, err, globtab);
+    LuaOldStack LS(L, unittests, name, func, err, globtab);
 
     LS.getglobaltable(globtab);
     LS.rawget(unittests, globtab, "unittests");
@@ -414,7 +414,7 @@ void SourceDB::run_unittests() {
 void SourceDB::init(lua_State *L) {
     lua_state_ = L;
     LuaVar globtab, persist, unpersist, classname, classtab, funcname, funcp, rawfunc, nullstring;
-    LuaStack LS(L, globtab, persist, unpersist, classname, classtab, funcname, funcp, rawfunc, nullstring);
+    LuaOldStack LS(L, globtab, persist, unpersist, classname, classtab, funcname, funcp, rawfunc, nullstring);
     LS.getglobaltable(globtab);
     LS.rawset(LuaRegistry, "sourcedb", LuaNewTable);
 
@@ -470,10 +470,10 @@ void SourceDB::deserialize_source(util::LuaSourceVec *sv, StreamBuffer *sb) {
 
 // This function should not touch the dlmalloc heap.
 void SourceDB::register_lua_builtins() {
-    lua_State *L = LuaStack::newstate(nullptr);
+    lua_State *L = LuaOldStack::newstate(nullptr);
     luaL_openlibs(L);
     LuaVar globals, lclassname, lfuncname, classtab, func;
-    LuaStack LS(L, globals, lclassname, lfuncname, classtab, func);
+    LuaOldStack LS(L, globals, lclassname, lfuncname, classtab, func);
     LS.getglobaltable(globals);
 
     // Iterate over the function registry, copying function pointers from
@@ -527,10 +527,10 @@ void SourceDB::register_lua_builtins() {
 }
 
 
-eng::string SourceDB::function_docs(const LuaStack &LS0, LuaSlot fn) {
+eng::string SourceDB::function_docs(const LuaCoreStack &LS0, LuaSlot fn) {
     lua_State *L = LS0.state();
     LuaVar sourcedb, fname, finfo, code;
-    LuaStack LS(L, sourcedb, fname, finfo, code);
+    LuaOldStack LS(L, sourcedb, fname, finfo, code);
 
     if (LS.iscfunction(fn)) {
         lua_CFunction cfn = lua_tocfunction(L, fn.index());
@@ -607,7 +607,7 @@ eng::string SourceDB::function_docs(const LuaStack &LS0, LuaSlot fn) {
 // These should go away eventually.  They're for debugging.
 LuaDefine(coroutine_setnextid, "thread,id", "set the next id of a thread (debugging only)") {
     LuaArg co, lid;
-    LuaStack LS(L, co, lid);
+    LuaOldStack LS(L, co, lid);
     lua_State *CO = LS.ckthread(co);
     lua_Number id = LS.ckinteger(lid);
     lua_setnextid(CO, id);
@@ -617,7 +617,7 @@ LuaDefine(coroutine_setnextid, "thread,id", "set the next id of a thread (debugg
 LuaDefine(coroutine_getnextid, "thread", "get the next id of a thread (debugging only)") {
     LuaArg co;
     LuaRet lid;
-    LuaStack LS(L, co, lid);
+    LuaOldStack LS(L, co, lid);
     lua_State *CO = LS.ckthread(co);
     LS.set(lid, lua_getnextid(CO));
     return LS.result();
@@ -766,7 +766,7 @@ LuaSandboxBuiltin(math_log10, "", "");
 LuaNumberConstant(math_pi, M_PI, "");
 LuaNumberConstant(math_huge, HUGE_VAL, "");
 LuaNumberConstant(math_nan, NAN, "");
-LuaNumberConstant(math_maxint, LuaStack::MAXINT, "");
+LuaNumberConstant(math_maxint, LuaOldStack::MAXINT, "");
 
 // math.random and math.randomseed are in world-accessor.cpp, because
 // generating random numbers must manipulate global state which is
diff --git a/luprex/cpp/core/source.hpp b/luprex/cpp/core/source.hpp
index 6e1ed175..055551d0 100644
--- a/luprex/cpp/core/source.hpp
+++ b/luprex/cpp/core/source.hpp
@@ -180,7 +180,7 @@ public:
     static void register_lua_builtins();
     
     // Get function documentation.
-    static eng::string function_docs(const LuaStack &LS, LuaSlot slot);
+    static eng::string function_docs(const LuaCoreStack &LS, LuaSlot slot);
 
     // Serialize and unserialize a source vector.
     //
diff --git a/luprex/cpp/core/table.cpp b/luprex/cpp/core/table.cpp
index e3788b70..b8b22771 100644
--- a/luprex/cpp/core/table.cpp
+++ b/luprex/cpp/core/table.cpp
@@ -5,7 +5,7 @@
 #include "source.hpp"
 
 
-bool table_equal(LuaStack &LS, LuaSlot t1, LuaSlot t2) {
+bool table_equal(LuaCoreStack &LS, LuaSlot t1, LuaSlot t2) {
     lua_State *L = LS.state();
     int top = lua_gettop(L);
     LS.checktable(t1, "table1");
@@ -33,7 +33,7 @@ bool table_equal(LuaStack &LS, LuaSlot t1, LuaSlot t2) {
 LuaDefine(table_equal, "table1,table2", "return true if two tables contain the same keys and values") {
     LuaArg t1, t2;
     LuaRet eql;
-    LuaStack LS(L, t1, t2, eql);
+    LuaOldStack LS(L, t1, t2, eql);
     LS.set(eql, table_equal(LS, t1, t2));
     return LS.result();
 }
@@ -121,7 +121,7 @@ LuaDefine(table_count, "table", "return the number of keys in table") {
 LuaDefine(table_clear, "table,metaflag", "clear all keys, and optionally the metatable") {
     LuaArg tab, clearmeta;
     LuaVar metatable, metafield;
-    LuaStack LS(L, tab, clearmeta, metatable, metafield);
+    LuaOldStack LS(L, tab, clearmeta, metatable, metafield);
     LS.checktable(tab, "table");
     if (LS.ckboolean(clearmeta)) {
         LS.getmetatable(metatable, tab);
@@ -142,7 +142,7 @@ LuaDefine(table_clear, "table,metaflag", "clear all keys, and optionally the met
 LuaDefine(table_getflagbits, "table", "get the table's flag bits (debugging only)") {
     LuaArg tab;
     LuaRet bits;
-    LuaStack LS(L, tab, bits);
+    LuaOldStack LS(L, tab, bits);
     uint16_t ubits = lua_getflagbits(L, tab.index());
     LS.set(bits, ubits);
     return LS.result();
@@ -150,7 +150,7 @@ LuaDefine(table_getflagbits, "table", "get the table's flag bits (debugging only
 
 LuaDefine(table_setflagbits, "table,bits", "set the table's flag bits (debugging only)") {
     LuaArg tab, bits;
-    LuaStack LS(L, tab, bits);
+    LuaOldStack LS(L, tab, bits);
     uint16_t ubits = LS.ckinteger(bits);
     lua_setflagbits(L, tab.index(), ubits);
     return LS.result();
@@ -232,7 +232,7 @@ int deque_make_room(lua_State *L, int deque, int left, int fill, int max) {
 LuaDefine(deque_create, "", "create a deque") {
     LuaRet rdeque;
     LuaVar classobj;
-    LuaStack LS(L, rdeque, classobj);
+    LuaOldStack LS(L, rdeque, classobj);
     const int imax = 4;
     eng::string err = LS.getclass(classobj, "deque");
     if (err != "") {
@@ -251,7 +251,7 @@ LuaDefine(deque_create, "", "create a deque") {
 
 LuaDefine(deque_pushl, "deque,value", "push onto the left end of a deque") {
     LuaArg deque, elt;
-    LuaStack LS(L, deque, elt);
+    LuaOldStack LS(L, deque, elt);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     max = deque_make_room(L, deque.index(), left, fill, max);
@@ -265,7 +265,7 @@ LuaDefine(deque_pushl, "deque,value", "push onto the left end of a deque") {
 
 LuaDefine(deque_pushr, "deque,value", "push onto the right end of a deque") {
     LuaArg deque, elt;
-    LuaStack LS(L, deque, elt);
+    LuaOldStack LS(L, deque, elt);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     max = deque_make_room(L, deque.index(), left, fill, max);
@@ -279,7 +279,7 @@ LuaDefine(deque_pushr, "deque,value", "push onto the right end of a deque") {
 LuaDefine(deque_popl, "deque", "pop the left end of a deque") {
     LuaArg deque;
     LuaRet result;
-    LuaStack LS(L, deque, result);
+    LuaOldStack LS(L, deque, result);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     if (fill == 0) {
@@ -297,7 +297,7 @@ LuaDefine(deque_popl, "deque", "pop the left end of a deque") {
 LuaDefine(deque_popr, "deque", "pop the right end of a deque") {
     LuaArg deque;
     LuaRet result;
-    LuaStack LS(L, deque, result);
+    LuaOldStack LS(L, deque, result);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     if (fill == 0) {
@@ -315,7 +315,7 @@ LuaDefine(deque_popr, "deque", "pop the right end of a deque") {
 LuaDefine(deque_nthl, "deque,n", "return the nth item from the left end of a deque") {
     LuaArg deque, nn;
     LuaRet result;
-    LuaStack LS(L, deque, nn, result);
+    LuaOldStack LS(L, deque, nn, result);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     int n = LS.ckint(nn);
@@ -331,7 +331,7 @@ LuaDefine(deque_nthl, "deque,n", "return the nth item from the left end of a deq
 LuaDefine(deque_nthr, "deque,n", "return the nth item from the right end of a deque") {
     LuaArg deque, nn;
     LuaRet result;
-    LuaStack LS(L, deque, nn, result);
+    LuaOldStack LS(L, deque, nn, result);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     int n = LS.ckint(nn);
@@ -346,7 +346,7 @@ LuaDefine(deque_nthr, "deque,n", "return the nth item from the right end of a de
 
 LuaDefine(deque_setl, "deque,n,value", "set the nth item from the left end of a deque") {
     LuaArg deque, nn, val;
-    LuaStack LS(L, deque, nn, val);
+    LuaOldStack LS(L, deque, nn, val);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     int n = LS.ckint(nn);
@@ -361,7 +361,7 @@ LuaDefine(deque_setl, "deque,n,value", "set the nth item from the left end of a
 
 LuaDefine(deque_setr, "deque,n,value", "set the nth item from the right end of a deque") {
     LuaArg deque, nn, val;
-    LuaStack LS(L, deque, nn, val);
+    LuaOldStack LS(L, deque, nn, val);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     int n = LS.ckint(nn);
@@ -378,7 +378,7 @@ LuaDefine(deque_findl, "deque,value", "find the first occurence of value in dequ
     LuaArg deque, val;
     LuaRet pos;
     LuaVar check;
-    LuaStack LS(L, deque, val, pos, check);
+    LuaOldStack LS(L, deque, val, pos, check);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     for (int i = 0; i < fill; i++) {
@@ -397,7 +397,7 @@ LuaDefine(deque_findr, "deque,value", "find the first occurrence of value in deq
     LuaArg deque, val;
     LuaRet pos;
     LuaVar check;
-    LuaStack LS(L, deque, val, pos, check);
+    LuaOldStack LS(L, deque, val, pos, check);
     int left, fill, max;
     deque_get_info(L, deque.index(), &left, &fill, &max);
     int base = left + fill - 1;
@@ -416,7 +416,7 @@ LuaDefine(deque_findr, "deque,value", "find the first occurrence of value in deq
 LuaDefine(deque_size, "deque", "return the number of items in the deque") {
     LuaArg deque;
     LuaRet size;
-    LuaStack LS(L, deque, size);
+    LuaOldStack LS(L, deque, size);
     LS.checktable(deque, "deque");
     LS.rawget(size, deque, DEQUE_FILL);
     LS.checknumber(size, "deque size");
@@ -534,10 +534,10 @@ static void auxsort (lua_State *L, int tab, int l, int u) {
     }                          /* repeat the routine for the larger one */
 }
 
-bool table_getpairs(LuaStack &LS0, LuaSlot tab, LuaSlot pairs, bool sort) {
+bool table_getpairs(LuaCoreStack &LS0, LuaSlot tab, LuaSlot pairs, bool sort) {
     lua_State *L = LS0.state();
     LuaVar key, value;
-    LuaStack LS(L, key, value);
+    LuaOldStack LS(L, key, value);
     bool sorted = true;
     // Create the table, store the initial 1.
     int total = lua_nkeys(L, tab.index());
@@ -602,7 +602,7 @@ LuaDefine(table_sortedpairs, "table",
     "|") {
     LuaArg tab;
     LuaRet closure, rtab, key;
-    LuaStack LS(L, tab, closure, rtab, key);
+    LuaOldStack LS(L, tab, closure, rtab, key);
     bool sorted = table_getpairs(LS, tab, rtab, true);
     if (!sorted) {
         luaL_error(L, "Cannot sort the table keys");
@@ -625,7 +625,7 @@ LuaDefine(table_semisortedpairs, "table",
     "|") {
     LuaArg tab;
     LuaRet closure, rtab, key;
-    LuaStack LS(L, tab, closure, rtab, key);
+    LuaOldStack LS(L, tab, closure, rtab, key);
     table_getpairs(LS, tab, rtab, true);
     LS.set(closure, lfn_table_nextsortedpair);
     LS.set(key, LuaNil);
@@ -665,7 +665,7 @@ LuaDefine(genlt, "obj1,obj2",
     "|") {
     LuaArg o1,o2;
     LuaRet lt;
-    LuaStack LS(L, o1, o2, lt);
+    LuaOldStack LS(L, o1, o2, lt);
     int ltf = lua_genlt(L, o1.index(), o2.index());
     LS.set(lt, ltf ? true:false);
     return LS.result();
diff --git a/luprex/cpp/core/table.hpp b/luprex/cpp/core/table.hpp
index dba1ad22..3198dbd3 100644
--- a/luprex/cpp/core/table.hpp
+++ b/luprex/cpp/core/table.hpp
@@ -16,14 +16,14 @@
 //
 // True if two tables contain the same key/value pairs.
 //
-bool table_equal(LuaStack &LS0, LuaSlot tab1, LuaSlot tab2);
+bool table_equal(LuaCoreStack &LS0, LuaSlot tab1, LuaSlot tab2);
 
 // table_getpairs
 //
 // Get a table containing the key-value pairs in tab.  Optionally sort
 // the pairs.  Return true if all keys were sortable.
 //
-bool table_getpairs(LuaStack &LS0, LuaSlot tab, LuaSlot pairs, bool sort);
+bool table_getpairs(LuaCoreStack &LS0, LuaSlot tab, LuaSlot pairs, bool sort);
 
 
 #endif // TABLE_HPP
diff --git a/luprex/cpp/core/world-accessor.cpp b/luprex/cpp/core/world-accessor.cpp
index 06d88ecd..19157bb1 100644
--- a/luprex/cpp/core/world-accessor.cpp
+++ b/luprex/cpp/core/world-accessor.cpp
@@ -5,9 +5,9 @@
 #include <cmath>
 #include <iostream>
 
-static void tangible_getall(LuaStack &LS0, LuaSlot list, const util::IdVector &idv) {
+static void tangible_getall(LuaCoreStack &LS0, LuaSlot list, const util::IdVector &idv) {
     LuaVar tangibles, tan;
-    LuaStack LS(LS0.state(), tangibles, tan);
+    LuaOldStack LS(LS0.state(), tangibles, tan);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     assert(LS.istable(tangibles));
     LS.set(list, LuaNewTable);
@@ -25,7 +25,7 @@ LuaDefine(tangible_animstate, "tan",
     "|Returns six values: graphic,plane,x,y,z,facing.") {
     LuaArg tanobj;
     LuaRet graphic, plane, x, y, z, facing;
-    LuaStack LS(L, tanobj, graphic, plane, x, y, z, facing);
+    LuaOldStack LS(L, tanobj, graphic, plane, x, y, z, facing);
     World *w = World::fetch_global_pointer(L);
     Tangible *tan = w->tangible_get(LS, tanobj, false);
     const AnimStep &aqback = tan->anim_queue_.back();
@@ -43,7 +43,7 @@ LuaDefine(tangible_xyz, "tan",
     "|Returns three values: x, y, z") {
     LuaArg tanobj;
     LuaRet x, y, z;
-    LuaStack LS(L, tanobj, x, y, z);
+    LuaOldStack LS(L, tanobj, x, y, z);
     World *w = World::fetch_global_pointer(L);
     Tangible *tan = w->tangible_get(LS, tanobj, false);
     const AnimStep &aqback = tan->anim_queue_.back();
@@ -58,7 +58,7 @@ LuaDefine(tangible_animate, "tan,configtable",
     "|The configtable is a table containing any of the following:"
     "|action,graphic,plane,x,y,z,facing") {
     LuaArg tanobj, config;
-    LuaStack LS(L, tanobj, config);
+    LuaOldStack LS(L, tanobj, config);
     LuaKeywordParser kp(LS, config);
     World *w = World::fetch_global_pointer(L);
     Tangible *tan = w->tangible_get(LS, tanobj, false);
@@ -81,7 +81,7 @@ LuaDefine(tangible_setclass, "tan,class",
     "|given an __index metamethod that points at the class table.") {
     LuaArg tanobj, classname;
     LuaVar classtab, mt;
-    LuaStack LS(L, tanobj, classname, classtab, mt);
+    LuaOldStack LS(L, tanobj, classname, classtab, mt);
     World *w = World::fetch_global_pointer(L);
     w->tangible_get(LS, tanobj, false);
     eng::string err = LS.getclass(classtab, classname);
@@ -100,7 +100,7 @@ LuaDefine(tangible_getclass, "tan",
     LuaArg tanobj;
     LuaVar mt, classtab;
     LuaRet classname;
-    LuaStack LS(L, tanobj, mt, classtab, classname);
+    LuaOldStack LS(L, tanobj, mt, classtab, classname);
     World *w = World::fetch_global_pointer(L);
     w->tangible_get(LS, tanobj, false);
     LS.getmetatable(mt, tanobj);
@@ -119,7 +119,7 @@ LuaDefine(tangible_delete, "tan",
     "|This cannot be used to delete player tangibles,"
     "|To delete a player, use tangible.redirect") {
     LuaArg tanobj;
-    LuaStack LS(L, tanobj);
+    LuaOldStack LS(L, tanobj);
     World *w = World::fetch_global_pointer(L);
     Tangible *tan = w->tangible_get(LS, tanobj, true);
     if (tan == nullptr) {
@@ -140,7 +140,7 @@ LuaDefine(tangible_build, "config",
     LuaArg config;
     LuaVar classname, classtab, mt;
     LuaRet database;
-    LuaStack LS(L, config, classname, classtab, database, mt);
+    LuaOldStack LS(L, config, classname, classtab, database, mt);
     LuaKeywordParser kp(LS, config);
 
     // Get the class of the new tangible.
@@ -192,7 +192,7 @@ LuaDefine(tangible_get, "id",
     LuaArg id;
     LuaVar tangibles;
     LuaRet database;
-    LuaStack LS(L, id, tangibles, database);
+    LuaOldStack LS(L, id, tangibles, database);
     int64_t nid = LS.ckinteger(id);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(database, tangibles, id);
@@ -205,7 +205,7 @@ LuaDefine(tangible_get, "id",
 LuaDefine(tangible_redirect, "tan1,tan2,bulldozetan1", 
     "|Redirect is not working yet") {
     LuaArg actor1, actor2, bldz;
-    LuaStack LS(L, actor1, actor2, bldz);
+    LuaOldStack LS(L, actor1, actor2, bldz);
     World *w = World::fetch_global_pointer(L);
     bool bulldoze = LS.ckboolean(bldz);
     Tangible *tan1 = w->tangible_get(LS, actor1, false);
@@ -231,7 +231,7 @@ LuaDefine(tangible_id, "tan",
     "|in the released version.") {
     LuaArg tanobj;
     LuaRet id;
-    LuaStack LS(L, tanobj, id);
+    LuaOldStack LS(L, tanobj, id);
     int64_t tid = LS.tanid(tanobj);
     if (tid == 0) {
         luaL_error(L, "Not a tangible");
@@ -244,7 +244,7 @@ LuaDefine(tangible_actor, "",
     "|Return the current actor.") {
     LuaRet actor;
     LuaVar tangibles;
-    LuaStack LS(L, tangibles, actor);
+    LuaOldStack LS(L, tangibles, actor);
     World *w = World::fetch_global_pointer(L);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(actor, tangibles, w->lthread_actor_id_);
@@ -255,7 +255,7 @@ LuaDefine(tangible_place, "",
     "|Return the current place.") {
     LuaRet place;
     LuaVar tangibles;
-    LuaStack LS(L, tangibles, place);
+    LuaOldStack LS(L, tangibles, place);
     World *w = World::fetch_global_pointer(L);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(place, tangibles, w->lthread_place_id_);
@@ -269,7 +269,7 @@ LuaDefine(tangible_near, "tan,radius,omit_nowhere,omit_self",
     "|tangible passed in is omitted from the results.") {
     LuaArg ltan, lradius, lomit_nowhere, lomit_self;
     LuaRet list;
-    LuaStack LS(L, ltan, lradius, lomit_nowhere, lomit_self, list);
+    LuaOldStack LS(L, ltan, lradius, lomit_nowhere, lomit_self, list);
     World *w = World::fetch_global_pointer(L);
     Tangible *tan = w->tangible_get(LS, ltan, false);
     const AnimStep &aqback = tan->anim_queue_.back();
@@ -293,7 +293,7 @@ LuaDefine(tangible_scan, "plane,x,y,radius,omit_nowhere",
     "|the scan returns empty.") {
     LuaArg lplane, lx, ly, lradius, lomit_nowhere;
     LuaRet list;
-    LuaStack LS(L, lplane, lx, ly, lradius, lomit_nowhere, list);
+    LuaOldStack LS(L, lplane, lx, ly, lradius, lomit_nowhere, list);
     World *w = World::fetch_global_pointer(L);
 
     PlaneScan scan;
@@ -367,7 +367,7 @@ LuaDefine(tangible_find, "config",
     "|") {
     LuaArg config;
     LuaRet result;
-    LuaStack LS(L, config, result);
+    LuaOldStack LS(L, config, result);
     LuaKeywordParser kw(LS, config);
     PlaneScan scan;
     scan.configure(kw);
@@ -446,7 +446,7 @@ LuaDefine(tangible_start, "tangible,function,arg1,arg2...",
     w->guard_blockable(L, "tangible.start");
 
     LuaVar mt, classtab, plthreads, thread, thinfo, func, tanlist;
-    LuaStack LS(L, mt, classtab, plthreads, thread, thinfo, func, tanlist);
+    LuaOldStack LS(L, mt, classtab, plthreads, thread, thinfo, func, tanlist);
     LuaSpecial place(1);
     LuaSpecial fname(2);
 
@@ -537,7 +537,7 @@ LuaDefine(wait, "nticks",
 
     // Parse the argument.
     LuaArg seconds;
-    LuaStack LS(L, seconds);
+    LuaOldStack LS(L, seconds);
     int64_t n = LS.ckinteger(seconds);
     if ((n < 0) || (n > 1000000)) {
         luaL_error(L, "Argument to wait must be between 0 and 1000000");
@@ -603,7 +603,7 @@ LuaDefine(math_random, "(args...)",
             highf = std::floor(lua_tonumber(L, arg));
             arg += 1;
         }
-        if ((lowf < -LuaStack::MAXINT) || (highf > LuaStack::MAXINT)) {
+        if ((lowf < -LuaOldStack::MAXINT) || (highf > LuaOldStack::MAXINT)) {
             luaL_error(L, "math.random range exceeds MAXINT");
             return 0;
         }
@@ -636,8 +636,8 @@ LuaDefine(math_random, "(args...)",
         }
         double dseed = lua_tonumber(L, -2);
         double dcount = lua_tonumber(L, -1);
-        seed = uint64_t(dseed) & LuaStack::MAXINT;
-        count = uint64_t(dcount) & LuaStack::MAXINT;
+        seed = uint64_t(dseed) & LuaOldStack::MAXINT;
+        count = uint64_t(dcount) & LuaOldStack::MAXINT;
         if (dseed < 0) {
             salt = 0x35c9a6082a097ade;
         } else {
@@ -645,7 +645,7 @@ LuaDefine(math_random, "(args...)",
         }
         lua_pop(L, 2);
         lua_pushstring(L, "count");
-        lua_pushnumber(L, double((count + 1) & LuaStack::MAXINT));
+        lua_pushnumber(L, double((count + 1) & LuaOldStack::MAXINT));
         lua_rawset(L, 1);
     } else {
         World *w = World::fetch_global_pointer(L);
@@ -692,7 +692,7 @@ LuaDefine(math_randomstate, "seed",
     double seed;
     if (lua_gettop(L) == 0) {
         World *w = World::fetch_global_pointer(L);
-        int64_t iseed = (w->id_global_pool_.get_seqno() & LuaStack::MAXINT) + 1;
+        int64_t iseed = (w->id_global_pool_.get_seqno() & LuaOldStack::MAXINT) + 1;
         seed = -iseed;
     } else if (lua_gettop(L) == 1) {
         if (lua_type(L, 1) != LUA_TNUMBER) {
@@ -700,7 +700,7 @@ LuaDefine(math_randomstate, "seed",
             return 0;
         }
         seed = lua_tonumber(L, 1);
-        if ((seed < 0.0) || (seed > LuaStack::MAXINT) || (std::floor(seed) != seed)) {
+        if ((seed < 0.0) || (seed > LuaOldStack::MAXINT) || (std::floor(seed) != seed)) {
             luaL_error(L, "math.randomstate seed must be an integer 0-MAXINT");
             return 0;
         }
@@ -732,7 +732,7 @@ LuaDefine(pprint, "obj1, obj2, ...",
     World *w = World::fetch_global_pointer(L);
     std::ostream *ostream = w->lthread_print_stream();
     int n = lua_gettop(L);
-    LuaStack LS(L);
+    LuaOldStack LS(L);
     for (int i = 1; i <= n; i++) {
         LuaSpecial root(i);
         pprint(LS, root, PrettyPrintOptions(), ostream);
@@ -763,7 +763,7 @@ LuaDefine(pprintx, "options",
     std::ostream *ostream = w->lthread_print_stream();
     LuaArg loptions;
     LuaVar value;
-    LuaStack LS(L, loptions, value);
+    LuaOldStack LS(L, loptions, value);
     PrettyPrintOptions options;
     LuaKeywordParser kp(LS, loptions);
     options.parse(kp);
@@ -779,7 +779,7 @@ LuaDefine(print, "obj1, obj2, ...",
     "|Print object or objects.") {
     World *w = World::fetch_global_pointer(L);
     std::ostream *ostream = w->lthread_print_stream();
-    LuaStack LS(L);
+    LuaOldStack LS(L);
     int n = lua_gettop(L);
     for (int i = 1; i <= n; i++) {
         LuaSpecial root(i);
@@ -795,7 +795,7 @@ LuaDefine(doc, "function",
     World *w = World::fetch_global_pointer(L);
     std::ostream *ostream = w->lthread_print_stream();
     LuaArg func;
-    LuaStack LS(L, func);
+    LuaOldStack LS(L, func);
     eng::string doc = SourceDB::function_docs(LS, func);
     if (doc == "") {
         (*ostream) << "no doc found" << std::endl;
@@ -810,7 +810,7 @@ int lfn_http_request(lua_State *L, const char *method) {
 
     LuaArg request;
     LuaRet response;
-    LuaStack LS(L, request, response);
+    LuaOldStack LS(L, request, response);
     LuaKeywordParser kp(LS, request);
     HttpClientRequest req;
     
@@ -856,11 +856,11 @@ LuaDefine(http_post, "request",
     return lfn_http_request(L, "POST");
 }
 
-void global_set(LuaStack &LS0, const eng::string &gvar, LuaSlot value) {
+void global_set(LuaCoreStack &LS0, const eng::string &gvar, LuaSlot value) {
     lua_State *L = LS0.state();
     World *w = World::fetch_global_pointer(L);
     LuaVar globaldb, copy;
-    LuaStack LS(L, globaldb, copy);
+    LuaOldStack LS(L, globaldb, copy);
 
     // Serialize then deserialize the data, to produce a copy.
     StreamBuffer sb;
@@ -936,7 +936,7 @@ LuaDefine(global_set, "varname, value",
     "|") {
     LuaArg varname;
     LuaArg value;
-    LuaStack LS(L, varname, value);
+    LuaOldStack LS(L, varname, value);
 
     // Check the varname argument.
     eng::string gvar = LS.ckstring(varname);
@@ -961,7 +961,7 @@ LuaDefine(global_get, "varname",
     LuaArg varname;
     LuaRet value;
     LuaVar globaldb;
-    LuaStack LS(L, varname, value, globaldb);
+    LuaOldStack LS(L, varname, value, globaldb);
     LS.rawget(globaldb, LuaRegistry, "globaldb");
     LS.rawget(value, globaldb, varname);
     return LS.result();
@@ -977,7 +977,7 @@ LuaDefine(global_once, "varname",
     LuaArg varname;
     LuaRet result;
     LuaVar globaldb, flag;
-    LuaStack LS(L, varname, flag, result, globaldb);
+    LuaOldStack LS(L, varname, flag, result, globaldb);
 
     // Check the varname argument.
     eng::string gvar = LS.ckstring(varname);
@@ -1009,7 +1009,7 @@ LuaDefine(global_clearonce, "varname",
     "|") {
     LuaArg varname;
     LuaVar null;
-    LuaStack LS(L, varname, null);
+    LuaOldStack LS(L, varname, null);
 
     // Check the varname argument.
     eng::string gvar = LS.ckstring(varname);
diff --git a/luprex/cpp/core/world-core.cpp b/luprex/cpp/core/world-core.cpp
index 7340a4f2..87066479 100644
--- a/luprex/cpp/core/world-core.cpp
+++ b/luprex/cpp/core/world-core.cpp
@@ -42,7 +42,7 @@ World::World(WorldType wt) {
 
     // Prepare to manipulate the lua state.
     LuaVar world, globtab;
-    LuaStack LS(state(), world, globtab);
+    LuaOldStack LS(state(), world, globtab);
 
     // Put the world pointer into the lua registry.
     World::store_global_pointer(state(), this);
@@ -134,7 +134,7 @@ World::TanVector World::tangible_get_all(const IdVector &ids) const {
     return result;
 }
 
-Tangible *World::tangible_get(const LuaStack &LS, LuaSlot tab, bool allowdel) {
+Tangible *World::tangible_get(const LuaCoreStack &LS, LuaSlot tab, bool allowdel) {
     int64_t id = LS.tanid(tab);
     if (id == 0) {
         luaL_error(LS.state(), "parameter is not a tangible");
@@ -158,7 +158,7 @@ Tangible *World::tangible_make(lua_State *L, int64_t id, const eng::string &plan
 
     LuaVar metatab;
     LuaRet database;
-    LuaStack LS(L, database, metatab);
+    LuaOldStack LS(L, database, metatab);
 
     // Create the C++ part of the structure.
     UniqueTangible &t = tangibles_[id];
@@ -185,7 +185,7 @@ Tangible *World::tangible_make(lua_State *L, int64_t id, const eng::string &plan
 void World::tangible_delete(int64_t id) {
     lua_State *L = state();
     LuaVar tangibles, database, metatab;
-    LuaStack LS(L, tangibles, database, metatab);
+    LuaOldStack LS(L, tangibles, database, metatab);
 
     // Fetch the C++ side of the tangible.
     auto iter = tangibles_.find(id);
@@ -243,7 +243,7 @@ int64_t World::create_login_actor() {
     Tangible *tan = tangible_make(state(), id, "nowhere", true);
     LuaArg database;
     LuaVar classtab, mt;
-    LuaStack LS(state(), database, classtab, mt);
+    LuaOldStack LS(state(), database, classtab, mt);
     LS.makeclass(classtab, "login");
     LS.getmetatable(mt, database);
     LS.rawset(mt, "__index", classtab);
@@ -264,7 +264,7 @@ eng::string World::probe_lua(int64_t actor_id, const eng::string &lua) {
     }
 
     LuaVar closure;
-    LuaStack LS(L, closure);
+    LuaOldStack LS(L, closure);
 
     // create the compiled closure.
     int status = luaL_loadbuffer(L, lua.c_str(), lua.size(), "=probe");
@@ -316,7 +316,7 @@ void World::update_gui(int64_t actor_id, int64_t place_id, Gui *gui) {
     lua_State *L = state();
 
     LuaVar actor, place, ugui, func, tangibles, mt, index;
-    LuaStack LS(L, actor, place, ugui, func, tangibles, mt, index);
+    LuaOldStack LS(L, actor, place, ugui, func, tangibles, mt, index);
 
     // Get the actor and place.
     LS.rawget(tangibles, LuaRegistry, "tangibles");
@@ -394,7 +394,7 @@ void World::http_response(const HttpParser &response) {
 
     // Get the place and thread as lua objects.
     LuaVar tangibles, place, mt, threads, thinfo, thread;
-    LuaStack LS(state(), tangibles, place, mt, threads, thinfo, thread);
+    LuaOldStack LS(state(), tangibles, place, mt, threads, thinfo, thread);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(place, tangibles, request.place_id());
     if (!LS.istable(place)) {
@@ -420,7 +420,7 @@ void World::http_response(const HttpParser &response) {
 
     // Push the response onto the awakening thread.
     LuaRet responsetable;
-    LuaStack LSCO(CO, responsetable);
+    LuaOldStack LSCO(CO, responsetable);
     response.store(LSCO, responsetable);
 
     // Clean up lua stacks.
@@ -475,7 +475,7 @@ HttpServerResponse World::http_serve(const HttpParser &request) {
 
     lua_State *L = state();
     LuaVar www, func, reqtab;
-    LuaStack LS(L, www, func, reqtab);
+    LuaOldStack LS(L, www, func, reqtab);
     
     // Get the www class.  If there's no such class,
     // return a 503 Service Unavailable to the client.
@@ -605,7 +605,7 @@ void World::invoke_lua(int64_t actor_id, int64_t place_id, const eng::string &ac
     // Set up for lua manipulation.
     lua_State *L = state();
     LuaVar func, tangibles, place, mt, thread, thinfo, threads;
-    LuaStack LS(L, func, tangibles, place, mt, thread, thinfo, threads);
+    LuaOldStack LS(L, func, tangibles, place, mt, thread, thinfo, threads);
 
     // create the compiled closure.
     int status = luaL_loadbuffer(L, action.c_str(), action.size(), "=invoke");
@@ -689,7 +689,7 @@ void World::invoke_plan(int64_t actor_id, int64_t place_id, const eng::string &a
     // Set up for Lua manipulation.
     lua_State *L = state();
     LuaVar actor, place, func, tangibles, mt, index, thread, threads, thinfo, message, invdata;
-    LuaStack LS(L, actor, place, func, tangibles, mt, index, thread, threads, thinfo, message, invdata);
+    LuaOldStack LS(L, actor, place, func, tangibles, mt, index, thread, threads, thinfo, message, invdata);
 
     // Get the actor and place.
     LS.rawget(tangibles, LuaRegistry, "tangibles");
@@ -794,7 +794,7 @@ void World::guard_blockable(lua_State *L, const char *fn) {
 
 void World::guard_nopredict(lua_State *L, const char *fn) {
     // Caution: this code must be equivalent to the
-    // code in LuaStack::guard_nopredict.
+    // code in LuaOldStack::guard_nopredict.
     if (lthread_thread_id_ == 0) {
         return;
     }
@@ -815,7 +815,7 @@ void World::run_scheduled_threads() {
     assert(stack_is_clear());
     lua_State *L = state();
     LuaVar tangibles, place, mt, threads, thinfo, actorid, isnew, useppool, thread, print;
-    LuaStack LS(L, tangibles, place, mt, threads, thinfo, actorid, isnew, useppool, thread, print);
+    LuaOldStack LS(L, tangibles, place, mt, threads, thinfo, actorid, isnew, useppool, thread, print);
 
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     while (thread_sched_.ready(clock_)) {
@@ -865,7 +865,7 @@ void World::run_scheduled_threads() {
             // Remove from thread table.
             LS.rawget(print, thinfo, "print");
             LS.rawset(threads, sched.thread_id(), LuaNil);
-            LuaStack LSCO(CO);
+            LuaOldStack LSCO(CO);
             if (LS.ckboolean(print)) {
                 for (int i = 1; i <= lua_gettop(CO); i++) {
                     pprint(LSCO, LuaSpecial(i), PrettyPrintOptions(), ostream);
diff --git a/luprex/cpp/core/world-difftab.cpp b/luprex/cpp/core/world-difftab.cpp
index c286191f..2aaf7bf1 100644
--- a/luprex/cpp/core/world-difftab.cpp
+++ b/luprex/cpp/core/world-difftab.cpp
@@ -27,7 +27,7 @@
 // Given a table and an tnmap, return the table number of the table.
 // Returns zero if the table doesn't have a table number.
 //
-static int get_table_number(LuaStack &MLS, LuaSlot mval, LuaSlot mtnmap) {
+static int get_table_number(LuaCoreStack &MLS, LuaSlot mval, LuaSlot mtnmap) {
     lua_State *L = MLS.state();
     lua_pushvalue(L, mval.index());
     lua_rawget(L, mtnmap.index());
@@ -40,8 +40,8 @@ static int get_table_number(LuaStack &MLS, LuaSlot mval, LuaSlot mtnmap) {
 }
 
 
-static bool equivalent_values(LuaStack &MLS, LuaSlot mval, LuaSlot mtnmap,
-                              LuaStack &SLS, LuaSlot sval, LuaSlot stnmap) {
+static bool equivalent_values(LuaCoreStack &MLS, LuaSlot mval, LuaSlot mtnmap,
+                              LuaCoreStack &SLS, LuaSlot sval, LuaSlot stnmap) {
     switch (MLS.xtype(mval)) {
     case LUA_TBOOLEAN: {
         if (SLS.type(sval) != LUA_TBOOLEAN) return false;
@@ -92,7 +92,7 @@ static bool equivalent_values(LuaStack &MLS, LuaSlot mval, LuaSlot mtnmap,
     }
 }
 
-static void transmit_value(LuaStack &MLS, LuaSlot mval, LuaSlot mtnmap, StreamBuffer *sb) {
+static void transmit_value(LuaCoreStack &MLS, LuaSlot mval, LuaSlot mtnmap, StreamBuffer *sb) {
     switch (MLS.xtype(mval)) {
     case LUA_TBOOLEAN: {
         sb->write_uint8(LUA_TBOOLEAN);
@@ -189,12 +189,12 @@ static void transmit_value_debug_string(StreamBuffer *sb, eng::ostringstream &os
     }
 }
 
-static bool diff_tables(LuaStack &SLS0, LuaSlot stnmap, LuaSlot stab,
-                        LuaStack &MLS0, LuaSlot mtnmap, LuaSlot mtab,
+static bool diff_tables(LuaCoreStack &SLS0, LuaSlot stnmap, LuaSlot stab,
+                        LuaCoreStack &MLS0, LuaSlot mtnmap, LuaSlot mtab,
                         bool cmeta, StreamBuffer *sb) {
     LuaVar skey, mkey, sval, mval, mnil;
-    LuaStack SLS(SLS0.state(), skey, sval);
-    LuaStack MLS(MLS0.state(), mkey, mval, mnil);
+    LuaOldStack SLS(SLS0.state(), skey, sval);
+    LuaOldStack MLS(MLS0.state(), mkey, mval, mnil);
     assert(MLS.istable(mtab));
     assert(SLS.istable(stab));
     MLS.set(mnil, LuaNil);
@@ -262,7 +262,7 @@ static eng::string diff_tables_debug_string(StreamBuffer *sb) {
     return oss.str();
 }
 
-static void set_transmitted_value(LuaStack &LS, LuaSlot tangibles, LuaSlot ntmap, LuaSlot target, StreamBuffer *sb, const char *dbinfo, DebugCollector *dbc) {
+static void set_transmitted_value(LuaCoreStack &LS, LuaSlot tangibles, LuaSlot ntmap, LuaSlot target, StreamBuffer *sb, const char *dbinfo, DebugCollector *dbc) {
     int kind = sb->read_uint8();
     switch (kind) {
     case LUA_TBOOLEAN: {
@@ -322,9 +322,9 @@ static void set_transmitted_value(LuaStack &LS, LuaSlot tangibles, LuaSlot ntmap
     }
 }
 
-static void patch_table(LuaStack &LS0, LuaSlot tangibles, LuaSlot ntmap, LuaSlot tab, StreamBuffer *sb, DebugCollector *dbc) {
+static void patch_table(LuaCoreStack &LS0, LuaSlot tangibles, LuaSlot ntmap, LuaSlot tab, StreamBuffer *sb, DebugCollector *dbc) {
     LuaVar key, val;
-    LuaStack LS(LS0.state(), key, val);
+    LuaOldStack LS(LS0.state(), key, val);
     int ndiffs = sb->read_int32();
     for (int i = 0; i < ndiffs; i++) {
         set_transmitted_value(LS, tangibles, ntmap, key, sb, "key=", dbc);
@@ -341,7 +341,7 @@ static void patch_table(LuaStack &LS0, LuaSlot tangibles, LuaSlot ntmap, LuaSlot
 void World::patch_numbered_tables(StreamBuffer *sb, DebugCollector *dbc) {
     lua_State *L = state();
     LuaVar tangibles, ntmap, tab;
-    LuaStack LS(L, tangibles, ntmap, tab);
+    LuaOldStack LS(L, tangibles, ntmap, tab);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(ntmap, LuaRegistry, "ntmap");
     assert(LS.istable(tangibles));
@@ -361,8 +361,8 @@ void World::patch_numbered_tables(StreamBuffer *sb, DebugCollector *dbc) {
 void World::diff_numbered_tables(lua_State *master, StreamBuffer *sb) {
     lua_State *synch = state();
     LuaVar sntmap, mntmap, stnmap, mtnmap, stab, mtab;
-    LuaStack SLS(synch, sntmap, stnmap, stab);
-    LuaStack MLS(master, mntmap, mtnmap, mtab);
+    LuaOldStack SLS(synch, sntmap, stnmap, stab);
+    LuaOldStack MLS(master, mntmap, mtnmap, mtab);
     SLS.rawget(sntmap, LuaRegistry, "ntmap");
     MLS.rawget(mntmap, LuaRegistry, "ntmap");
     SLS.rawget(stnmap, LuaRegistry, "tnmap");
@@ -400,7 +400,7 @@ void World::diff_numbered_tables(lua_State *master, StreamBuffer *sb) {
 void World::patch_tangible_databases(StreamBuffer *sb, DebugCollector *dbc) {
     lua_State *L = state();
     LuaVar tangibles, ntmap, tab;
-    LuaStack LS(L, tangibles, ntmap, tab);
+    LuaOldStack LS(L, tangibles, ntmap, tab);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(ntmap, LuaRegistry, "ntmap");
     assert(LS.istable(tangibles));
@@ -420,8 +420,8 @@ void World::patch_tangible_databases(StreamBuffer *sb, DebugCollector *dbc) {
 void World::diff_tangible_databases(const IdVector &basis, lua_State *master, StreamBuffer *sb) {
     lua_State *synch = state();
     LuaVar stnmap, mtnmap, stangibles, mtangibles, stab, mtab;
-    LuaStack SLS(synch, stnmap, stangibles, stab);
-    LuaStack MLS(master, mtnmap, mtangibles, mtab);
+    LuaOldStack SLS(synch, stnmap, stangibles, stab);
+    LuaOldStack MLS(master, mtnmap, mtangibles, mtab);
     SLS.rawget(stnmap, LuaRegistry, "tnmap");
     MLS.rawget(mtnmap, LuaRegistry, "tnmap");
     SLS.rawget(stangibles, LuaRegistry, "tangibles");
@@ -456,7 +456,7 @@ LuaDefine(table_diffcompare, "mtnmap,mtab,stnmap,stab", "for unit testing only")
     LuaArg mtnmap, mtab, mstnmap, mstab;
     LuaRet dbgstring;
     LuaVar tthread;
-    LuaStack MLS(L, mtnmap, mtab, mstnmap, mstab, dbgstring, tthread);
+    LuaOldStack MLS(L, mtnmap, mtab, mstnmap, mstab, dbgstring, tthread);
     // Check the arguments.
     MLS.checktable(mtnmap, "mtnmap");
     MLS.checktable(mstnmap, "mstnmap");
@@ -471,7 +471,7 @@ LuaDefine(table_diffcompare, "mtnmap,mtab,stnmap,stab", "for unit testing only")
     lua_pushvalue(L, mstab.index());
     lua_xmove(L, synch, 2);
     LuaArg stnmap,stab;
-    LuaStack SLS(synch, stnmap, stab);
+    LuaOldStack SLS(synch, stnmap, stab);
 
     // Call tablecmp_diff.
     StreamBuffer sb;
@@ -486,7 +486,7 @@ LuaDefine(table_diffapply, "mtnmap,mtab,mstab", "for unit testing only") {
     LuaArg mtnmap, mtab, mstab;
     LuaRet eql, eqlstr, rtab;
     LuaVar tthread, tangibles, mntmap, key, val;
-    LuaStack MLS(L, mtnmap, mtab, mstab, eql, eqlstr, rtab, tthread, tangibles, mntmap, key, val);
+    LuaOldStack MLS(L, mtnmap, mtab, mstab, eql, eqlstr, rtab, tthread, tangibles, mntmap, key, val);
     // Check the arguments.
     MLS.checktable(mtnmap, "mtnmap");
     MLS.checktable(mtab, "mtab");
@@ -510,7 +510,7 @@ LuaDefine(table_diffapply, "mtnmap,mtab,mstab", "for unit testing only") {
     lua_pushvalue(L, mstab.index());
     lua_xmove(L, synch, 2);
     LuaArg stnmap, stab;
-    LuaStack SLS(synch, stnmap, stab);
+    LuaOldStack SLS(synch, stnmap, stab);
 
     // Call diff_tables and patch_tables
     StreamBuffer sb;
diff --git a/luprex/cpp/core/world-diffxmit.cpp b/luprex/cpp/core/world-diffxmit.cpp
index edc76abf..0eb145d6 100644
--- a/luprex/cpp/core/world-diffxmit.cpp
+++ b/luprex/cpp/core/world-diffxmit.cpp
@@ -224,7 +224,7 @@ void World::patch_tanclass(StreamBuffer *sb, DebugCollector *dbc) {
     DebugBlock dbb(dbc, "patch_tanclass");
     lua_State *L = state();
     LuaVar tangibles, tab, meta, sclass;
-    LuaStack LS(L, tangibles, tab, meta, sclass);
+    LuaOldStack LS(L, tangibles, tab, meta, sclass);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
 
     int nmodified = sb->read_int32();
@@ -249,8 +249,8 @@ void World::diff_tanclass(int64_t actor_id, World *master, StreamBuffer *xsb) {
     StreamBuffer tsb;
 
     LuaVar stangibles, mtangibles, stab, mtab, smeta, mmeta, sclass, mclass;
-    LuaStack SLS(state(), stangibles, stab, smeta, sclass);
-    LuaStack MLS(master->state(), mtangibles, mtab, mmeta, mclass);
+    LuaOldStack SLS(state(), stangibles, stab, smeta, sclass);
+    LuaOldStack MLS(master->state(), mtangibles, mtab, mmeta, mclass);
     SLS.rawget(stangibles, LuaRegistry, "tangibles");
     MLS.rawget(mtangibles, LuaRegistry, "tangibles");
 
diff --git a/luprex/cpp/core/world-pairtab.cpp b/luprex/cpp/core/world-pairtab.cpp
index fc1b829b..81004b60 100644
--- a/luprex/cpp/core/world-pairtab.cpp
+++ b/luprex/cpp/core/world-pairtab.cpp
@@ -21,7 +21,7 @@ int World::number_lua_tables(const IdVector &basis) {
     // explicit stack (the lua stack).
     lua_State *L = state();
     LuaVar tnmap, ntmap, tangibles, tab, key, val, xid;
-    LuaStack LS(L, tnmap, ntmap, tangibles, tab, key, val, xid);
+    LuaOldStack LS(L, tnmap, ntmap, tangibles, tab, key, val, xid);
     LS.set(tnmap, LuaNewTable);
     LS.set(ntmap, LuaNewTable);
     LS.rawset(LuaRegistry, "tnmap", tnmap);
@@ -79,8 +79,8 @@ int World::number_lua_tables(const IdVector &basis) {
 void World::pair_lua_tables(const IdVector &basis, lua_State *master) {
     lua_State *synch = state();
     LuaVar stangibles, mtangibles, sntmap, mntmap, stnmap, mtnmap, stab, mtab, skey, mkey, sval, mval, sidx, midx;
-    LuaStack SLS(synch, stangibles, stab, skey, sval, sntmap, stnmap, sidx);
-    LuaStack MLS(master, mtangibles, mtab, mkey, mval, mntmap, mtnmap, midx);
+    LuaOldStack SLS(synch, stangibles, stab, skey, sval, sntmap, stnmap, sidx);
+    LuaOldStack MLS(master, mtangibles, mtab, mkey, mval, mntmap, mtnmap, midx);
 
     // Fetch the tangible databases
     SLS.rawget(stangibles, LuaRegistry, "tangibles");
@@ -178,7 +178,7 @@ int World::number_remaining_tables(const IdVector &basis, lua_State *master) {
     // explicit stack (the lua stack).
     lua_State *L = master;
     LuaVar tnmap, ntmap, tangibles, tab, key, val, xid;
-    LuaStack LS(L, tnmap, ntmap, tangibles, tab, key, val, xid);
+    LuaOldStack LS(L, tnmap, ntmap, tangibles, tab, key, val, xid);
     LS.rawget(tnmap, LuaRegistry, "tnmap");
     LS.rawget(ntmap, LuaRegistry, "ntmap");
     LS.rawget(tangibles, LuaRegistry, "tangibles");
@@ -242,7 +242,7 @@ int World::number_remaining_tables(const IdVector &basis, lua_State *master) {
 
 void World::create_new_tables(int n) {
     LuaVar tnmap, ntmap, tab;
-    LuaStack LS(state(), tnmap, ntmap, tab);
+    LuaOldStack LS(state(), tnmap, ntmap, tab);
     LS.rawget(tnmap, LuaRegistry, "tnmap");
     LS.rawget(ntmap, LuaRegistry, "ntmap");
     assert(LS.istable(tnmap));
@@ -261,7 +261,7 @@ void World::create_new_tables(int n) {
 
 void World::unnumber_lua_tables() {
     // All we have to do is remove these tables from the registry.
-    LuaStack LS(state());
+    LuaOldStack LS(state());
     LS.rawset(LuaRegistry, "tnmap", LuaNil);
     LS.rawset(LuaRegistry, "ntmap", LuaNil);
 }
diff --git a/luprex/cpp/core/world-testing.cpp b/luprex/cpp/core/world-testing.cpp
index 8fe81c0f..3560aac7 100644
--- a/luprex/cpp/core/world-testing.cpp
+++ b/luprex/cpp/core/world-testing.cpp
@@ -50,7 +50,7 @@ eng::string World::tangibles_near_debug_string(int64_t actor, int64_t distance)
 eng::string World::tangible_pprint(int64_t id) const {
     lua_State *L = state();
     LuaVar tangibles, tan, meta;
-    LuaStack LS(L, tangibles, tan, meta);
+    LuaOldStack LS(L, tangibles, tan, meta);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(tan, tangibles, id);
     eng::ostringstream oss;
@@ -68,7 +68,7 @@ eng::string World::tangible_pprint(int64_t id) const {
 eng::string World::numbered_tables_debug_string() const {
     lua_State *L = state();
     LuaVar ntmap, tab, tid;
-    LuaStack LS(L, ntmap, tab, tid);
+    LuaOldStack LS(L, ntmap, tab, tid);
     eng::vector<eng::string> result;
     eng::ostringstream oss;
 
@@ -98,8 +98,8 @@ eng::string World::numbered_tables_debug_string() const {
 eng::string World::paired_tables_debug_string(lua_State *master) const {
     lua_State *synch = state();
     LuaVar mntmap, sntmap, mtab, stab, mtid, stid;
-    LuaStack MLS(master, mntmap, mtab, mtid);
-    LuaStack SLS(synch, sntmap, stab, stid);
+    LuaOldStack MLS(master, mntmap, mtab, mtid);
+    LuaOldStack SLS(synch, sntmap, stab, stid);
     eng::vector<std::pair<eng::string, eng::string>> result;
     eng::ostringstream oss;
 
@@ -139,7 +139,7 @@ eng::string World::paired_tables_debug_string(lua_State *master) const {
 void World::tangible_set_string(int64_t id, const eng::string &path, const eng::string &value) {
     lua_State *L = state();
     LuaVar tangibles, tab, subtab;
-    LuaStack LS(L, tangibles, tab, subtab);
+    LuaOldStack LS(L, tangibles, tab, subtab);
 
     // Fetch the lua side of the tangible.
     LS.rawget(tangibles, LuaRegistry, "tangibles");
@@ -172,7 +172,7 @@ void World::tangible_set_string(int64_t id, const eng::string &path, const eng::
 void World::tangible_copy_global(int64_t id, const eng::string &path, const eng::string &global) {
     lua_State *L = state();
     LuaVar tangibles, tab, subtab, globtab, value;
-    LuaStack LS(L, tangibles, tab, subtab, globtab, value);
+    LuaOldStack LS(L, tangibles, tab, subtab, globtab, value);
 
     // Fetch the lua side of the tangible.
     LS.rawget(tangibles, LuaRegistry, "tangibles");
@@ -205,7 +205,7 @@ void World::tangible_copy_global(int64_t id, const eng::string &path, const eng:
 
 void World::tangible_set_class(int64_t id, const eng::string &c) const {
     LuaVar tangibles, tan, meta, sclass;
-    LuaStack LS(state(), tangibles, tan, meta, sclass);
+    LuaOldStack LS(state(), tangibles, tan, meta, sclass);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(tan, tangibles, id);
     assert(LS.istable(tan));
@@ -221,7 +221,7 @@ void World::tangible_set_class(int64_t id, const eng::string &c) const {
 
 eng::string World::tangible_get_class(int64_t id) const {
     LuaVar tangibles, tan, meta, sclass;
-    LuaStack LS(state(), tangibles, tan, meta, sclass);
+    LuaOldStack LS(state(), tangibles, tan, meta, sclass);
     LS.rawget(tangibles, LuaRegistry, "tangibles");
     LS.rawget(tan, tangibles, id);
     assert(LS.istable(tan));
diff --git a/luprex/cpp/core/world.hpp b/luprex/cpp/core/world.hpp
index 9fb7ba69..108da3bc 100644
--- a/luprex/cpp/core/world.hpp
+++ b/luprex/cpp/core/world.hpp
@@ -151,7 +151,7 @@ public:
     // a deleted tangible.  In that case, this function returns nullptr,
     // but this is not a Lua error.
     //
-    Tangible *tangible_get(const LuaStack &LS, LuaSlot slot, bool allowdel);
+    Tangible *tangible_get(const LuaCoreStack &LS, LuaSlot slot, bool allowdel);
     
     // Get pointers to many tangibles.
     //
@@ -240,7 +240,7 @@ public:
 
     // Check if the world is authoritative.
     //
-    bool is_authoritative() const { return LuaStack::is_authoritative(world_type_); }
+    bool is_authoritative() const { return LuaOldStack::is_authoritative(world_type_); }
     
     // Get a table showing all outstanding HTTP requests.
     //
@@ -560,7 +560,7 @@ private:
     std::unique_ptr<eng::ostringstream> lthread_prints_;
 
     friend class Tangible;  
-    friend void global_set(LuaStack &LS0, const eng::string &gvar, LuaSlot value); 
+    friend void global_set(LuaCoreStack &LS0, const eng::string &gvar, LuaSlot value); 
     friend int lfn_tangible_animate(lua_State *L);
     friend int lfn_tangible_build(lua_State *L);
     friend int lfn_tangible_redirect(lua_State *L);