diff --git a/.gitignore b/.gitignore
index ef34e54c..d3c62ffd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,6 +12,7 @@ dist/
 *~
 .DS_Store
 thumbs.db
+gmon.out
 
 # exclude unused and scratch pad files
 .trash
diff --git a/api/lua/definition/poptracker.lua b/api/lua/definition/poptracker.lua
index 9a101f9d..c83ba6cd 100644
--- a/api/lua/definition/poptracker.lua
+++ b/api/lua/definition/poptracker.lua
@@ -83,6 +83,12 @@ function Tracker:UiHint(name, value) end
 ---@type boolean
 Tracker.BulkUpdate = false
 
+---Allow to evaluate logic rules fewer times than items are updated.
+---Only available in PopTracker, since 0.27.1.
+---Use as: `if Tracker.AllowDeferredLogicUpdate == false then Tracker.AllowDeferredLogicUpdate = true end`
+---@type boolean
+Tracker.AllowDeferredLogicUpdate = false
+
 
 ---- ScriptHost ----
 
diff --git a/doc/PACKS.md b/doc/PACKS.md
index 5da5885c..1c5e59e9 100644
--- a/doc/PACKS.md
+++ b/doc/PACKS.md
@@ -110,6 +110,7 @@ The following interfaces are provided:
 * `mixed :FindObjectForCode(string)`: returns items for `code` or location section for `@location/section`
 * `void :UiHint(name, value)`: sends a hint to the Ui, see [Ui Hints](#ui-hints). Only available in PopTracker, since 0.11.0
 * `bool .BulkUpdate`: can be set to true from Lua to pause running logic rules.
+* `bool .AllowDeferredLogicUpdate`: can be set to true from Lua to allow evaluating logic rules fewer times than items are updated.
 
 
 ### global ScriptHost
diff --git a/src/core/baseitem.h b/src/core/baseitem.h
index 2776d29b..316eb698 100644
--- a/src/core/baseitem.h
+++ b/src/core/baseitem.h
@@ -64,7 +64,7 @@ class BaseItem { // TODO: move stuff over to JsonItem; TODO: make some stuff pur
     std::string _id;
     std::string _name;
     Type _type = Type::NONE;
-    std::list<std::string> _codes;
+    std::vector<std::string> _codes;
     bool _capturable = false;
     bool _loop = false;
     bool _allowDisabled = false;
@@ -122,9 +122,10 @@ class BaseItem { // TODO: move stuff over to JsonItem; TODO: make some stuff pur
     }
     
     
-    virtual int providesCode(const std::string code) const { // FIXME: make this pure?
-        if (_count && canProvideCode(code)) return _count;
-        return (_stage1 && canProvideCode(code));
+    virtual int providesCode(const std::string& code) const { // FIXME: make this pure?
+        if (_count && canProvideCode(code))
+            return _count;
+        return _stage1 && canProvideCode(code);
     }
     
     virtual bool canProvideCode(const std::string& code) const { // FIXME: make this pure?
diff --git a/src/core/jsonitem.cpp b/src/core/jsonitem.cpp
index fb9a6e7d..b976e91c 100644
--- a/src/core/jsonitem.cpp
+++ b/src/core/jsonitem.cpp
@@ -24,7 +24,7 @@ std::string JsonItem::getCodesString() const {
     return s;
 }
 
-const std::list<std::string>& JsonItem::getCodes(int stage) const {
+const std::vector<std::string>& JsonItem::getCodes(int stage) const {
     if (_type == Type::TOGGLE) return _codes;
     if (stage>=0 && (size_t)stage<_stages.size()) return _stages[stage].getCodes();
     return _codes;
@@ -117,7 +117,15 @@ JsonItem JsonItem::FromJSON(json& j)
     item._stage2 = std::max(0,std::min(to_int(j["initial_stage_idx"],0), (int)item._stages.size()-1));
     item._count  = std::max(item._minCount, std::min(to_int(j["initial_quantity"],0), item._maxCount));
     if (item._type == Type::CONSUMABLE && item._count > 0) item._stage1=1;
-    
+
+#ifdef JSONITEM_CI_QUIRK
+    for (const auto& code : item._codes)
+        item._ciAllCodes.emplace(toLower(code));
+    for (const auto& stage : item._stages)
+        for (const auto& code : stage.getCodes())
+            item._ciAllCodes.emplace(toLower(code));
+#endif
+
     return item;
 }
 
diff --git a/src/core/jsonitem.h b/src/core/jsonitem.h
index 76a02697..1494184f 100644
--- a/src/core/jsonitem.h
+++ b/src/core/jsonitem.h
@@ -5,6 +5,8 @@
 #include <luaglue/luainterface.h>
 #include <algorithm>
 #include <nlohmann/json.hpp>
+#include <algorithm>
+#include <unordered_set>
 #ifdef _MSC_VER
 #define strncasecmp _strnicmp
 #define strcasecmp _stricmp
@@ -24,7 +26,7 @@ class JsonItem final : public LuaInterface<JsonItem>, public BaseItem {
     
     class Stage final {
     protected:
-        std::list<std::string> _codes;
+        std::vector<std::string> _codes;
         std::list<std::string> _secondaryCodes;
         std::string _img;
         std::string _disabledImg;
@@ -42,11 +44,18 @@ class JsonItem final : public LuaInterface<JsonItem>, public BaseItem {
         const std::string& getDisabledImage() const { return _disabledImg; }
         const std::list<std::string>& getImageMods() const { return _imgMods; }
         const std::list<std::string>& getDisabledImageMods() const { return _disabledImgMods; }
-        const std::list<std::string>& getCodes() const { return _codes; }
+        const std::vector<std::string>& getCodes() const { return _codes; }
         const std::list<std::string>& getSecondaryCodes() const { return _secondaryCodes; }
         std::string getCodesString() const;
         bool hasCode(const std::string& code) const { // NOTE: this is called canProvideCode in lua
+#ifdef JSONITEM_CI_QUIRK
+            const auto cmp = [&code](const std::string& s) {
+                return code.length() == s.length() && strcasecmp(code.c_str(), s.c_str()) == 0;
+            };
+            return std::find_if(_codes.begin(), _codes.end(), cmp) != _codes.end();
+#else
             return std::find(_codes.begin(), _codes.end(), code) != _codes.end();
+#endif
         }
         bool hasSecondaryCode(const std::string& code) const {
             return std::find(_secondaryCodes.begin(), _secondaryCodes.end(), code) != _secondaryCodes.end();
@@ -54,7 +63,7 @@ class JsonItem final : public LuaInterface<JsonItem>, public BaseItem {
         const bool getInheritCodes() const { return _inheritCodes; }
         const std::string& getName() const { return _name; }
     };
-    
+
 protected:
     std::vector<Stage> _stages;
     bool _imgOverridden = false;
@@ -69,7 +78,23 @@ class JsonItem final : public LuaInterface<JsonItem>, public BaseItem {
     bool _imgChanged = false;
     bool _ignoreUserInput = false;
 
-public:    
+#ifdef JSONITEM_CI_QUIRK
+    // CI comparison in list is way too expensive, so we create a lowercase set instead
+    std::unordered_set<std::string> _ciAllCodes; // includes codes for stages
+#endif
+
+public:
+    static void toLowerInPlace(std::string& s)
+    {
+        std::transform(s.begin(), s.end(), s.begin(), ::tolower);
+    }
+
+    static std::string toLower(std::string s)
+    {
+        toLowerInPlace(s);
+        return s;
+    }
+
     virtual size_t getStageCount() const override { return _stages.size(); }
     
     virtual const std::string& getImage(size_t stage) const override {
@@ -100,9 +125,16 @@ class JsonItem final : public LuaInterface<JsonItem>, public BaseItem {
         return _name;
     }
 
+#ifdef JSONITEM_CI_QUIRK
+    bool canProvideCodeLower(const std::string& code) const
+    {
+        return _ciAllCodes.count(code);
+    }
+#endif
+
     virtual bool canProvideCode(const std::string& code) const override {
 #ifdef JSONITEM_CI_QUIRK
-        auto cmp = [&code](const std::string& s) {
+        const auto cmp = [&code](const std::string& s) {
             return code.length() == s.length() && strcasecmp(code.c_str(), s.c_str()) == 0;
         };
         if (std::find_if(_codes.begin(), _codes.end(), cmp) != _codes.end()) return true;
@@ -115,28 +147,58 @@ class JsonItem final : public LuaInterface<JsonItem>, public BaseItem {
         return false;
     }
 
-    virtual int providesCode(const std::string code) const override {
-        // TODO: split at ':' for consumables to be able to check for a specific amount?
+private:
+    int providesCodeImpl(const std::string& code, bool assumeCanProvide) const
+    {
         if (_type == Type::COMPOSITE_TOGGLE) {
             // composites do not provide left/right codes since that would duplicate numbers
+#ifdef JSONITEM_CI_QUIRK
+            const auto cmp = [&code](const std::string& s) {
+                return code.length() == s.length() && strcasecmp(code.c_str(), s.c_str()) == 0;
+            };
+            if (std::find_if(_codes.begin(), _codes.end(), cmp) != _codes.end())
+#else
             if (std::find(_codes.begin(), _codes.end(), code) != _codes.end())
+#endif
                 return ((_stage2&1) ? 1 : 0) + ((_stage2&2) ? 1 : 0);
-            else
-                return 0;
+            return 0;
         }
-        if ((int)_stages.size()>_stage2) {
-            if (_allowDisabled && !_stage1) return 0;
+
+        if ((int)_stages.size() > _stage2) {
+            if (_allowDisabled && !_stage1)
+                return 0;
             for (int i=_stage2; i>=0; i--) {
-                if (_stages[i].hasCode(code)) return 1;
-                if (!_stages[i].getInheritCodes()) break;
+                if (_stages[i].hasCode(code))
+                    return 1;
+                if (!_stages[i].getInheritCodes())
+                    break;
             }
             return false;
         }
-        if (_count && canProvideCode(code)) return _count;
-        return (_stage1 && canProvideCode(code));
+
+        if (_count && (assumeCanProvide || canProvideCode(code)))
+            return _count;
+        return _stage1 && (assumeCanProvide || canProvideCode(code));
+    }
+
+public:
+#ifdef JSONITEM_CI_QUIRK
+    int providesCodeLower(const std::string& code) const
+    {
+        if (!canProvideCodeLower(code))
+            return 0;
+        return providesCodeImpl(code, true);
+    }
+#endif
+
+    int providesCode(const std::string& code) const override
+    {
+        // TODO: split at ':' for consumables to be able to check for a specific amount?
+        return providesCodeImpl(code, false);
     }
-    virtual std::string getCodesString() const override;
-    virtual const std::list<std::string>& getCodes(int stage) const;
+
+    std::string getCodesString() const override;
+    const std::vector<std::string>& getCodes(int stage) const;
     
     virtual bool changeState(BaseItem::Action action) override {
         if (_ignoreUserInput)
diff --git a/src/core/jsonutil.h b/src/core/jsonutil.h
index 08de17f7..bee07c92 100644
--- a/src/core/jsonutil.h
+++ b/src/core/jsonutil.h
@@ -36,7 +36,8 @@ static nlohmann::json parse_jsonc(std::string& s)
     return j;
 }
 
-static void commasplit(const std::string& s, std::list<std::string>& l)
+template <template <typename...> class T>
+void commasplit(const std::string& s, T<std::string>& l)
 {
     auto sta = s.find_first_not_of(' '); // ltrim
     auto end = s.find(',');
@@ -55,17 +56,19 @@ static void commasplit(const std::string& s, std::list<std::string>& l)
         l.push_back(s.substr(sta, end - sta));
 }
 
-static std::list<std::string> commasplit(const std::string& s)
+template <template <typename...> class T>
+static T<std::string> commasplit(const std::string& s)
 {
-    std::list<std::string> lst;
-    commasplit(s, lst);
+    T<std::string> lst;
+    commasplit<T>(s, lst);
     return lst;
 }
 
-static std::list<std::string> commasplit(std::string&& s)
+template <template <typename...> class T>
+static T<std::string> commasplit(std::string&& s)
 {
     std::string tmp = s;
-    return commasplit(tmp);
+    return commasplit<T>(tmp);
 }
 
 
diff --git a/src/core/luaitem.cpp b/src/core/luaitem.cpp
index 50bb5b40..045f4e51 100644
--- a/src/core/luaitem.cpp
+++ b/src/core/luaitem.cpp
@@ -122,7 +122,7 @@ bool LuaItem::Lua_NewIndex(lua_State *L, const char *key) {
     } else if (strcmp(key,"IconMods")==0) {
         // NOTE: these are applied on top of .Icon ImageReference
         std::string s = luaL_checkstring(L,-1);
-        auto mods = commasplit(s);
+        auto mods = commasplit<std::list>(s);
         if (_extraImgMods != mods) {
             _extraImgMods = mods;
             parseFullImg();
@@ -188,7 +188,7 @@ bool LuaItem::canProvideCode(const std::string& code) const
     return res;
 }
 
-int LuaItem::providesCode(const std::string code) const
+int LuaItem::providesCode(const std::string& code) const
 {
     if (!_providesCodeFunc.valid()) return false;
     lua_rawgeti(_L, LUA_REGISTRYINDEX, _providesCodeFunc.ref);
@@ -353,7 +353,7 @@ void LuaItem::parseFullImg()
         _imgMods = _extraImgMods;
     } else {
         _img = _fullImg.substr(0, pos);
-        _imgMods = commasplit(_fullImg.substr(pos + 1));
+        _imgMods = commasplit<std::list>(_fullImg.substr(pos + 1));
         _imgMods.insert(_imgMods.end(), _extraImgMods.begin(), _extraImgMods.end());
     }
 }
diff --git a/src/core/luaitem.h b/src/core/luaitem.h
index 6e85b30f..f4e83664 100644
--- a/src/core/luaitem.h
+++ b/src/core/luaitem.h
@@ -20,7 +20,7 @@ class LuaItem final : public LuaInterface<LuaItem>, public BaseItem {
     LuaVariant Get(const char* key);
     
     virtual bool canProvideCode(const std::string& code) const override;
-    virtual int providesCode(const std::string code) const override;
+    int providesCode(const std::string& code) const override;
     virtual bool changeState(Action action) override;
     
     virtual void SetOverlay(const char* text) override {
diff --git a/src/core/tracker.cpp b/src/core/tracker.cpp
index 2fe8d99f..b3aaeac4 100644
--- a/src/core/tracker.cpp
+++ b/src/core/tracker.cpp
@@ -173,6 +173,7 @@ bool Tracker::AddItems(const std::string& file) {
     }
     
     _providerCountCache.clear();
+    _objectCache.clear();
     _accessibilityStale = true;
     _visibilityStale = true;
     for (auto& v : j) {
@@ -312,6 +313,7 @@ bool Tracker::AddLocations(const std::string& file) {
     }
     
     _providerCountCache.clear();
+    _objectCache.clear();
     _sectionRefs.clear();
     _accessibilityStale = true;
     _visibilityStale = true;
@@ -441,11 +443,23 @@ int Tracker::ProviderCountForCode(const std::string& code)
         res = Tracker::runLuaFunction(_L, code);
         goto done;
     }
+
     // other codes count items
+#ifdef JSONITEM_CI_QUIRK
+    {
+        const auto lower = JsonItem::toLower(code);
+        for (const auto& item : _jsonItems)
+        {
+            res += item.providesCodeLower(lower);
+        }
+    }
+#else
     for (const auto& item : _jsonItems)
     {
         res += item.providesCode(code);
     }
+#endif
+
     for (const auto& item : _luaItems)
     {
         res += item.providesCode(code);
@@ -459,6 +473,12 @@ int Tracker::ProviderCountForCode(const std::string& code)
 
 Tracker::Object Tracker::FindObjectForCode(const char* code)
 {
+    const auto it = _objectCache.find(std::string_view(code));
+    if (it != _objectCache.end()) {
+        if (*code == '@')
+            _isIndirectConnection = true; // if called during rule resolution, this skips the cache
+        return it->second;
+    }
     if (*code == '@') { // location section
         const char *start = code+1;
         const char *t = strrchr(start, '/');
@@ -471,7 +491,7 @@ Tracker::Object Tracker::FindObjectForCode(const char* code)
                 if (sec.getName() != secname)
                     continue;
                 _isIndirectConnection = true; // if called during rule resolution, this skips the cache
-                return &sec;
+                return _objectCache.emplace(code, &sec).first->second;
             }
         }
     }
@@ -480,17 +500,25 @@ Tracker::Object Tracker::FindObjectForCode(const char* code)
         auto& loc = getLocation(start, true);
         if (!loc.getID().empty()) {
             _isIndirectConnection = true;
-            return &loc;
+            return _objectCache.emplace(code, &loc).first->second;
         }
     } else {
+#ifdef JSONITEM_CI_QUIRK
+        const auto lower = JsonItem::toLower(code);
         for (auto& item : _jsonItems) {
-            if (item.canProvideCode(code)) {
-                return &item;
-            }
+            if (item.canProvideCodeLower(lower))
+                return _objectCache.emplace(code, &item).first->second;
         }
+#else
+        for (auto& item : _jsonItems) {
+            if (item.canProvideCode(code))
+                return _objectCache.emplace(code, &item).first->second;
+        }
+#endif
+
         for (auto& item : _luaItems) {
             if (item.canProvideCode(code)) {
-                return &item;
+                return _objectCache.emplace(code, &item).first->second;
             }
         }
     }
@@ -503,6 +531,19 @@ void Tracker::UiHint(const std::string& name, const std::string& value)
     onUiHint.emit(this, name, value);
 }
 
+template <typename T>
+static void eraseDuplicates(std::list<T>& list)
+{
+    // This keeps the last occurence.
+    // FIXME: Complexity is awful.
+    auto it = list.begin();
+    while (it != list.end()) {
+        auto cur = it++;
+        if (std::find(it, list.end(), *cur) != list.end())
+            list.erase(cur);
+    }
+}
+
 int Tracker::Lua_Index(lua_State *L, const char* key) {
     if (strcmp(key, "ActiveVariantUID") == 0) {
         lua_pushstring(L, _pack->getVariant().c_str());
@@ -510,6 +551,9 @@ int Tracker::Lua_Index(lua_State *L, const char* key) {
     } else if (strcmp(key, "BulkUpdate") == 0) {
         lua_pushboolean(L, _bulkUpdate);
         return 1;
+    } else if (strcmp(key, "AllowDefferedLogicUpdate") == 0) {
+        lua_pushboolean(L, _allowDeferredLogicUpdate);
+        return 1;
     } else {
         printf("Tracker::Lua_Index(\"%s\") unknown\n", key);
     }
@@ -521,16 +565,24 @@ bool Tracker::Lua_NewIndex(lua_State *L, const char* key) {
         luaL_error(L, "Tried to write read-only property Tracker.%s", key);
     } else if (strcmp(key, "BulkUpdate") == 0) {
         bool val = lua_isnumber(L, -1) ? (lua_tonumber(L, -1) != 0) : lua_toboolean(L, -1);
-        if (!val) {
-            for (const auto& id: _bulkItemUpdates) // TODO: erase dusplicates
+        if (_bulkUpdate && !val) {
+            eraseDuplicates(_bulkItemUpdates);
+            for (const auto& id: _bulkItemUpdates)
                 onStateChanged.emit(this, id);
             _bulkItemUpdates.clear();
-            for (const auto& id: _bulkItemDisplayUpdates) // TODO: erase dusplicates
+            eraseDuplicates(_bulkItemDisplayUpdates);
+            for (const auto& id: _bulkItemDisplayUpdates)
                 onDisplayChanged.emit(this, id);
             _bulkItemDisplayUpdates.clear();
+            _bulkUpdate = false;
+            onBulkUpdateDone.emit(this);
+        } else {
+            _bulkUpdate = val;
         }
-        _bulkUpdate = val;
         return true;
+    } else if (strcmp(key, "AllowDefferedLogicUpdate") == 0) {
+        bool val = lua_isnumber(L, -1) ? (lua_tonumber(L, -1) != 0) : lua_toboolean(L, -1);
+        _allowDeferredLogicUpdate = val;
     }
     return false;
 }
@@ -559,14 +611,24 @@ bool Tracker::hasLayout(const std::string& name) const
 }
 const BaseItem& Tracker::getItemByCode(const std::string& code) const
 {
+#ifdef JSONITEM_CI_QUIRK
+    const auto lower = JsonItem::toLower(code);
     for (const auto& item: _jsonItems) {
-        if (item.canProvideCode(code)) return item;
+        if (item.canProvideCodeLower(lower))
+            return item;
     }
-    
+#else
+    for (const auto& item: _jsonItems) {
+        if (item.canProvideCode(code))
+            return item;
+    }
+#endif
+
     for (const auto& item: _luaItems) {
-        if (item.canProvideCode(code)) return item;
+        if (item.canProvideCode(code))
+            return item;
     }
-    
+
     return blankItem;
 }
 BaseItem& Tracker::getItemById(const std::string& id)
@@ -670,6 +732,16 @@ void Tracker::rebuildSectionRefs()
     }
 }
 
+bool Tracker::isBulkUpdate() const
+{
+    return _bulkUpdate;
+}
+
+bool Tracker::allowDeferredLogicUpdate() const
+{
+    return _allowDeferredLogicUpdate;
+}
+
 const Pack* Tracker::getPack() const
 {
     return _pack;
@@ -900,6 +972,7 @@ bool Tracker::isVisible(const Location& location)
 LuaItem * Tracker::CreateLuaItem()
 {
     _luaItems.push_back({});
+    _objectCache.clear();
     LuaItem& i = _luaItems.back();
     i.setID(++_lastItemID);
     i.onChange += {this, [this](void* sender) {
@@ -1103,13 +1176,16 @@ bool Tracker::loadState(nlohmann::json& state)
             }
         }
     }
-    for (const auto& id: _bulkItemUpdates) // TODO: erase dusplicates
+    eraseDuplicates(_bulkItemUpdates);
+    for (const auto& id: _bulkItemUpdates)
         onStateChanged.emit(this, id);
     _bulkItemUpdates.clear();
-    for (const auto& id: _bulkItemDisplayUpdates) // TODO: erase dusplicates
+    eraseDuplicates(_bulkItemDisplayUpdates);
+    for (const auto& id: _bulkItemDisplayUpdates)
         onDisplayChanged.emit(this, id);
     _bulkItemDisplayUpdates.clear();
     _bulkUpdate = false;
+    onBulkUpdateDone.emit(this);
 
     return true;
 }
diff --git a/src/core/tracker.h b/src/core/tracker.h
index 0492ef2f..766de736 100644
--- a/src/core/tracker.h
+++ b/src/core/tracker.h
@@ -77,7 +77,8 @@ class Tracker final : public LuaInterface<Tracker> {
     Signal<const std::string&> onStateChanged;
     Signal<const std::string&> onDisplayChanged; // changed display of an item
     Signal<const std::string&, const std::string&> onUiHint;
-    
+    Signal<> onBulkUpdateDone;
+
     const LayoutNode& getLayout(const std::string& name) const;
     bool hasLayout(const std::string& name) const;
     const BaseItem& getItemByCode(const std::string& code) const;
@@ -101,6 +102,9 @@ class Tracker final : public LuaInterface<Tracker> {
     bool isVisible(const Location& location);
     bool isVisible(const Location::MapLocation& mapLoc);
 
+    bool isBulkUpdate() const;
+    bool allowDeferredLogicUpdate() const;
+
     const Pack* getPack() const;
 
     bool changeItemState(const std::string& id, BaseItem::Action action);
@@ -121,9 +125,11 @@ class Tracker final : public LuaInterface<Tracker> {
     std::map<std::string, AccessibilityLevel> _accessibilityCache;
     std::map<std::string, bool> _visibilityCache;
     std::map<std::string, int> _providerCountCache;
+    std::map<const std::string, Object, std::less<>> _objectCache;
     std::list<std::string> _bulkItemUpdates;
     std::list<std::string> _bulkItemDisplayUpdates;
     bool _bulkUpdate = false;
+    bool _allowDeferredLogicUpdate = false; /// opt-in flag to use onBulkUpdate to update state just once at the end
     bool _accessibilityStale = false;
     bool _visibilityStale = false;
     bool _isIndirectConnection = false; /// flag to skip cache for codes that depend on locations
diff --git a/src/ui/trackerview.cpp b/src/ui/trackerview.cpp
index 9921290e..b48149d9 100644
--- a/src/ui/trackerview.cpp
+++ b/src/ui/trackerview.cpp
@@ -173,7 +173,7 @@ Item* TrackerView::makeItem(int x, int y, int width, int height, const ::BaseIte
                 f = img;
             } else {
                 f = img.substr(0, p);
-                filters = imageModsToFilters(_tracker, commasplit(img.substr(p + 1)));
+                filters = imageModsToFilters(_tracker, commasplit<std::list>(img.substr(p + 1)));
             }
             std::string s;
             _tracker->getPack()->ReadFile(f, s);
@@ -253,6 +253,10 @@ TrackerView::TrackerView(int x, int y, int w, int h, Tracker* tracker, const std
     _tracker->onDisplayChanged += {this, [this](void *s, const std::string& check) {
         updateDisplay(check);
     }};
+    _tracker->onBulkUpdateDone += { this, [this](void *s) {
+        if (_tracker->allowDeferredLogicUpdate())
+            updateLocations();
+    }};
     _tracker->onLocationSectionChanged += {this, [this](void *s, const LocationSection& sec) {
         updateLocation(sec.getParentID());
         for (const auto& pair: _tracker->getReferencingSections(sec))
@@ -268,6 +272,7 @@ TrackerView::~TrackerView()
     _tracker->onLayoutChanged -= this;
     _tracker->onStateChanged -= this;
     _tracker->onDisplayChanged -= this;
+    _tracker->onBulkUpdateDone -= this;
     _tracker->onLocationSectionChanged -= this;
     _tracker->onUiHint -= this;
     _tracker = nullptr;
@@ -448,7 +453,7 @@ void TrackerView::updateDisplay(const std::string& itemid)
                 f = img;
             } else {
                 f = img.substr(0, p);
-                filters = imageModsToFilters(_tracker, commasplit(img.substr(p + 1)));
+                filters = imageModsToFilters(_tracker, commasplit<std::list>(img.substr(p + 1)));
             }
             std::string s;
             _tracker->getPack()->ReadFile(f, s);
@@ -524,7 +529,8 @@ void TrackerView::updateState(const std::string& itemid)
     for (auto w: _items[itemid]) {
         updateItem(w, item);
     }
-    updateLocations();
+    if (!_tracker->isBulkUpdate() || !_tracker->allowDeferredLogicUpdate())
+        updateLocations();
 }
 
 size_t TrackerView::addLayoutNodes(Container* container, const std::list<LayoutNode>& nodes, size_t depth)
diff --git a/src/uilib/colorhelper.h b/src/uilib/colorhelper.h
index 23cbec53..fd6d3c6d 100644
--- a/src/uilib/colorhelper.h
+++ b/src/uilib/colorhelper.h
@@ -33,7 +33,8 @@ static Uint32 getPixel(SDL_Surface* surf, unsigned x, unsigned y)
 
 
 #if defined BW_LUMINOSITY
-static uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
+static inline __attribute__((always_inline))
+uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
 {
     uint16_t v = 0;
     v += (((uint16_t)r)*21);
@@ -49,7 +50,8 @@ static uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
                       ((b)>=(a) && (b)>=(c)) ? (b) : (c) )
 #define MIN3(a,b,c) ( ((a)<=(b) && (a)<=(c)) ? (a) : \
                       ((b)<=(a) && (b)<=(c)) ? (b) : (c) )
-static uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
+static inline __attribute__((always_inline))
+uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
 {
     uint16_t v = MAX3(r, g, b);
     v += MIN3(r, g, b);
@@ -59,7 +61,8 @@ static uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
     return (uint8_t)((v+1)/2);
 }
 #else // BW_AVERAGE
-static uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
+static inline __attribute__((always_inline))
+uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
 {
     uint16_t v = r; v += g; v += b;
     if (darken) {
@@ -68,13 +71,15 @@ static uint8_t makeGreyscale(uint8_t r, uint8_t g, uint8_t b, bool darken)
     return (uint8_t)((2*v+3)/6);
 }
 #endif
+
 static SDL_Color makeGreyscale(SDL_Color c, bool darken)
 {
     uint8_t w = makeGreyscale(c.r,c.g,c.b, darken);
     return { w, w, w, c.a };
 }
 
-static inline uint32_t bytesToUint(const uint8_t* b, const uint8_t bytespp)
+static inline __attribute__((always_inline))
+uint32_t bytesToUint(const uint8_t* b, const uint8_t bytespp)
 {
     // this is basically like memcpy, but there is no actual 24bit uint
     uint32_t res = 0;
@@ -89,7 +94,8 @@ static inline uint32_t bytesToUint(const uint8_t* b, const uint8_t bytespp)
     return res;
 }
 
-static inline void uintToBytes(uint32_t d, uint8_t* b, const uint8_t bytespp)
+static inline __attribute__((always_inline))
+void uintToBytes(uint32_t d, uint8_t* b, const uint8_t bytespp)
 {
     // this is basically like memcpy, but there is no actual 24bit uint
     for (uint8_t i=0; i<bytespp; i++) {
@@ -102,7 +108,8 @@ static inline void uintToBytes(uint32_t d, uint8_t* b, const uint8_t bytespp)
     }
 }
 
-static inline void _makeGreyscaleRGB(SDL_Surface *surf, bool darken)
+static inline __attribute__((always_inline))
+void _makeGreyscaleRGB(SDL_Surface *surf, bool darken)
 {
     const uint8_t bytespp = surf->format->BytesPerPixel;
     uint8_t* data = (uint8_t*)surf->pixels;
@@ -124,13 +131,18 @@ static inline void _makeGreyscaleRGB(SDL_Surface *surf, bool darken)
     }
 }
 
-static inline SDL_Surface *makeGreyscale(SDL_Surface *surf, bool darken)
+static inline __attribute__((always_inline))
+SDL_Surface *makeGreyscale(SDL_Surface *surf, bool darken)
 {
     // inline since it should only be used in a few places
-    if (SDL_LockSurface(surf) != 0) {
-        fprintf(stderr, "makeGreyscale: Could not lock surface: %s\n",
-                SDL_GetError());
-        return surf;
+    // by inlining all of it, we get rid of 'darken' during runtime regardless of optimization level,
+    // but profiling output (gprof) will be less readable
+    if (SDL_MUSTLOCK(surf)) {
+        if (SDL_LockSurface(surf) != 0) {
+            fprintf(stderr, "makeGreyscale: Could not lock surface: %s\n",
+                    SDL_GetError());
+            return surf;
+        }
     }
     if (surf->format->BitsPerPixel <= 8 && surf->format->palette) {
         // convert palette to greyscale
@@ -139,22 +151,26 @@ static inline SDL_Surface *makeGreyscale(SDL_Surface *surf, bool darken)
         for (int i=0; i<ncolors; i++) {
             pal->colors[i] = makeGreyscale(surf->format->palette->colors[i], darken);
         }
-        SDL_UnlockSurface(surf);
-        
+        if (SDL_MUSTLOCK(surf))
+            SDL_UnlockSurface(surf);
+
         SDL_SetSurfacePalette(surf, pal); // refcount++
         SDL_FreePalette(pal); // refcount--, will not actually free it here
     }
     else if (surf->format->palette) {
         fprintf(stderr, "makeGreyscale: Unsupported palette: %hhubit\n",
                 surf->format->BitsPerPixel);
-        SDL_UnlockSurface(surf);
+        if (SDL_MUSTLOCK(surf))
+            SDL_UnlockSurface(surf);
     }
     else if (surf->format->BytesPerPixel > 0 && surf->format->BytesPerPixel < 5) {
         _makeGreyscaleRGB(surf, darken);
-        SDL_UnlockSurface(surf);
+        if (SDL_MUSTLOCK(surf))
+            SDL_UnlockSurface(surf);
     }
     else {
-        SDL_UnlockSurface(surf);
+        if (SDL_MUSTLOCK(surf))
+            SDL_UnlockSurface(surf);
         fprintf(stderr, "makeGreyscale: Unsupported pixel format\n");
     }
     return surf;
@@ -164,14 +180,15 @@ static SDL_Surface *makeTransparent(SDL_Surface *surf, uint8_t r, uint8_t g, uin
 {
     // if any corner pixel is [r,g,b], make that color transparent
     bool doColorKey = false;
-    if (SDL_LockSurface(surf) == 0) {
+    if (!SDL_MUSTLOCK(surf) || SDL_LockSurface(surf) == 0) {
         for (uint8_t n=0; !doColorKey && n<4; n++) {
             uint8_t r1,g1,b1,a1;
             uint32_t px = getPixel(surf, (n&1) ? surf->w-1 : 0, (n&2) ? surf-> h-1 : 0);
             SDL_GetRGBA(px, surf->format, &r1, &g1, &b1, &a1);
             doColorKey = (r1==r && g1==g && b1==b && a1==0xff);
         }
-        SDL_UnlockSurface(surf);
+        if (SDL_MUSTLOCK(surf))
+            SDL_UnlockSurface(surf);
     } else {
         fprintf(stderr, "Could not lock surface to check corners: %s\n",
                 SDL_GetError());
@@ -196,7 +213,7 @@ static SDL_Surface *makeTransparent(SDL_Surface *surf, uint8_t r, uint8_t g, uin
                 surf = newSurf;
             }
             SDL_SetSurfaceBlendMode(surf, SDL_BLENDMODE_BLEND);
-            if (SDL_LockSurface(surf) == 0) {
+            if (!SDL_MUSTLOCK(surf) || SDL_LockSurface(surf) == 0) {
                 uint32_t key = SDL_MapRGB(surf->format, r, g, b);
                 for (int y=0; y<surf->h; y++) {
                     uint32_t* vals = (uint32_t*)((uint8_t*)surf->pixels + y*surf->pitch);
@@ -204,7 +221,8 @@ static SDL_Surface *makeTransparent(SDL_Surface *surf, uint8_t r, uint8_t g, uin
                         if (vals[x] == key) vals[x] = 0;
                     }
                 }
-                SDL_UnlockSurface(surf);
+                if (SDL_MUSTLOCK(surf))
+                    SDL_UnlockSurface(surf);
             } else {
                 fprintf(stderr, "Could not lock surface to make transparent: %s\n",
                         SDL_GetError());
diff --git a/test/core/test_jsonitem_provides.cpp b/test/core/test_jsonitem_provides.cpp
new file mode 100644
index 00000000..e9f43e9f
--- /dev/null
+++ b/test/core/test_jsonitem_provides.cpp
@@ -0,0 +1,235 @@
+#include <gtest/gtest.h>
+#include <nlohmann/json.hpp>
+#include "../../src/core/jsonitem.h"
+
+using namespace std;
+using nlohmann::json;
+
+
+static auto jStatic = R"(
+{
+    "name": "item",
+    "type": "static",
+    "codes": "Code"
+}
+)"_json;
+
+TEST(JsonItemProvidesTest, StaticCanProvideCode) {
+    auto item = JsonItem::FromJSON(jStatic);
+    EXPECT_TRUE(item.canProvideCode("Code"));
+    EXPECT_FALSE(item.canProvideCode("Not"));
+}
+
+#ifdef JSONITEM_CI_QUIRK
+TEST(JsonItemProvidesTest, StaticCanProvideCodeCI) {
+    auto item = JsonItem::FromJSON(jStatic);
+    EXPECT_TRUE(item.canProvideCode("codE"));
+    EXPECT_TRUE(item.canProvideCodeLower("code"));
+    EXPECT_FALSE(item.canProvideCodeLower("not"));
+}
+#endif
+
+TEST(JsonItemProvidesTest, StaticProvidesCode) {
+    auto item = JsonItem::FromJSON(jStatic);
+    EXPECT_EQ(item.providesCode("Code"), 1);
+    EXPECT_EQ(item.providesCode("Not"), 0);
+
+    #if 0  // FIXME: we CAN currently force static to off using setState
+    item.setState(0);
+    EXPECT_EQ(item.providesCode("Code"), 1);
+    EXPECT_EQ(item.providesCode("Not"), 0);
+    #endif
+
+    item.changeState(BaseItem::Action::Toggle);
+    EXPECT_EQ(item.providesCode("Code"), 1);
+    EXPECT_EQ(item.providesCode("Not"), 0);
+    item.changeState(BaseItem::Action::Toggle);
+    EXPECT_EQ(item.providesCode("Code"), 1);
+    EXPECT_EQ(item.providesCode("Not"), 0);
+}
+
+#ifdef JSONITEM_CI_QUIRK
+TEST(JsonItemProvidesTest, StaticProvidesCodeCI) {
+    auto item = JsonItem::FromJSON(jStatic);
+    EXPECT_EQ(item.providesCode("codE"), 1);
+    EXPECT_EQ(item.providesCodeLower("code"), 1);
+}
+#endif
+
+static auto jToggle = R"(
+{
+    "name": "item",
+    "type": "toggle",
+    "codes": "code1,CODE2"
+}
+)"_json;
+
+TEST(JsonItemProvidesTest, ToggleCanProvideCode) {
+    auto item = JsonItem::FromJSON(jToggle);
+    EXPECT_TRUE(item.canProvideCode("code1"));
+    EXPECT_TRUE(item.canProvideCode("CODE2"));
+    EXPECT_FALSE(item.canProvideCode("code3"));
+}
+
+#ifdef JSONITEM_CI_QUIRK
+TEST(JsonItemProvidesTest, ToggleCanProvideCodeCI) {
+    auto item = JsonItem::FromJSON(jToggle);
+    EXPECT_TRUE(item.canProvideCode("CODE1"));
+    EXPECT_TRUE(item.canProvideCode("code2"));
+    EXPECT_TRUE(item.canProvideCodeLower("code1"));
+    EXPECT_TRUE(item.canProvideCodeLower("code2"));
+}
+#endif
+
+TEST(JsonItemProvidesTest, ToggleProvidesCode) {
+    auto item = JsonItem::FromJSON(jToggle);
+    EXPECT_EQ(item.providesCode("code1"), 0);
+    EXPECT_EQ(item.providesCode("CODE2"), 0);
+    EXPECT_EQ(item.providesCode("code3"), 0);
+    item.setState(1);
+    EXPECT_EQ(item.providesCode("code1"), 1);
+    EXPECT_EQ(item.providesCode("CODE2"), 1);
+    EXPECT_EQ(item.providesCode("code3"), 0);
+}
+
+#ifdef JSONITEM_CI_QUIRK
+TEST(JsonItemProvidesTest, ToggleProvidesCodeCI) {
+    auto item = JsonItem::FromJSON(jToggle);
+    EXPECT_EQ(item.providesCode("CODE1"), 0);
+    EXPECT_EQ(item.providesCode("code2"), 0);
+    EXPECT_EQ(item.providesCodeLower("code2"), 0);
+    item.setState(1);
+    EXPECT_EQ(item.providesCode("CODE1"), 1);
+    EXPECT_EQ(item.providesCode("code2"), 1);
+    EXPECT_EQ(item.providesCodeLower("code2"), 1);
+}
+#endif
+
+static auto jStagedSeparate = R"(
+{
+    "name": "item",
+    "type": "staged",
+    "codes": "Base",
+    "stages": [
+        {
+            "inherit_codes": false,
+            "codes": "Stage1"
+        },
+        {
+            "inherit_codes": false,
+            "codes": "Stage2"
+        }
+    ]
+}
+)"_json;
+
+TEST(JsonItemProvidesTest, StagedCanProvideCode) {
+    // NOTE: currently Base works for canProvide so it can be used to FindObjectForCode; change this?
+    auto item = JsonItem::FromJSON(jStagedSeparate);
+    EXPECT_TRUE(item.canProvideCode("Base"));
+    EXPECT_TRUE(item.canProvideCode("Stage1"));
+    EXPECT_TRUE(item.canProvideCode("Stage2"));
+    EXPECT_FALSE(item.canProvideCode("Not"));
+}
+
+#ifdef JSONITEM_CI_QUIRK
+TEST(JsonItemProvidesTest, StagedCanProvideCodeCI) {
+    // NOTE: currently Base works for canProvide so it can be used to FindObjectForCode; change this?
+    auto item = JsonItem::FromJSON(jStagedSeparate);
+    EXPECT_TRUE(item.canProvideCode("BASE"));
+    EXPECT_TRUE(item.canProvideCode("STAGE1"));
+    EXPECT_TRUE(item.canProvideCodeLower("stage2"));
+    EXPECT_FALSE(item.canProvideCodeLower("not"));
+}
+#endif
+
+TEST(JsonItemProvidesTest, StagedProvidesCode) {
+    // NOTE: currently Base is never provided for staged because it's not really valid for staged; change this?
+    auto item = JsonItem::FromJSON(jStagedSeparate);
+    EXPECT_EQ(item.providesCode("Base"), 0);
+    EXPECT_EQ(item.providesCode("Stage1"), 0);
+    EXPECT_EQ(item.providesCode("Stage2"), 0);
+    item.setState(1, -1);
+    EXPECT_EQ(item.providesCode("Base"), 0);
+    EXPECT_EQ(item.providesCode("Stage1"), 1);
+    EXPECT_EQ(item.providesCode("Stage2"), 0);
+    item.setState(1, 1);
+    EXPECT_EQ(item.providesCode("Base"), 0);
+    EXPECT_EQ(item.providesCode("Stage1"), 0);
+    EXPECT_EQ(item.providesCode("Stage2"), 1);
+}
+
+#ifdef JSONITEM_CI_QUIRK
+TEST(JsonItemProvidesTest, StagedProvidesCodeCI) {
+    auto item = JsonItem::FromJSON(jStagedSeparate);
+    item.setState(1, 0);
+    EXPECT_EQ(item.providesCode("STAGE1"), 1);
+    EXPECT_EQ(item.providesCodeLower("stage1"), 1);
+    item.setState(1, 1);
+    EXPECT_EQ(item.providesCode("STAGE1"), 0);
+    EXPECT_EQ(item.providesCodeLower("stage1"), 0);
+}
+#endif
+
+static auto jStagedInherits = R"(
+{
+    "name": "item",
+    "type": "staged",
+    "codes": "Base",
+    "stages": [
+        {
+            "inherit_codes": true,
+            "codes": "Stage1"
+        },
+        {
+            "inherit_codes": true,
+            "codes": "Stage2"
+        }
+    ]
+}
+)"_json;
+
+TEST(JsonItemProvidesTest, StagedInheritsCanProvideCode) {
+    // NOTE: currently Base works for canProvide so it can be used to FindObjectForCode; change this?
+    auto item = JsonItem::FromJSON(jStagedInherits);
+    EXPECT_TRUE(item.canProvideCode("Base"));
+    EXPECT_TRUE(item.canProvideCode("Stage1"));
+    EXPECT_TRUE(item.canProvideCode("Stage2"));
+    EXPECT_FALSE(item.canProvideCode("Not"));
+}
+
+#ifdef JSONITEM_CI_QUIRK
+TEST(JsonItemProvidesTest, StagedInheritsCanProvideCodeCI) {
+    // NOTE: currently Base works for canProvide so it can be used to FindObjectForCode; change this?
+    auto item = JsonItem::FromJSON(jStagedInherits);
+    EXPECT_TRUE(item.canProvideCode("BASE"));
+    EXPECT_TRUE(item.canProvideCode("STAGE1"));
+    EXPECT_TRUE(item.canProvideCodeLower("stage2"));
+    EXPECT_FALSE(item.canProvideCodeLower("not"));
+}
+#endif
+
+TEST(JsonItemProvidesTest, StagedInheritsProvidesCode) {
+    // NOTE: currently Base is never provided for staged because it's not really valid for staged; change this?
+    auto item = JsonItem::FromJSON(jStagedInherits);
+    EXPECT_EQ(item.providesCode("Base"), 0);
+    EXPECT_EQ(item.providesCode("Stage1"), 0);
+    EXPECT_EQ(item.providesCode("Stage2"), 0);
+    item.setState(1, -1);
+    EXPECT_EQ(item.providesCode("Base"), 0);
+    EXPECT_EQ(item.providesCode("Stage1"), 1);
+    EXPECT_EQ(item.providesCode("Stage2"), 0);
+    item.setState(1, 1);
+    EXPECT_EQ(item.providesCode("Base"), 0);
+    EXPECT_EQ(item.providesCode("Stage1"), 1);
+    EXPECT_EQ(item.providesCode("Stage2"), 1);
+}
+
+#ifdef JSONITEM_CI_QUIRK
+TEST(JsonItemProvidesTest, StagedInheritsProvidesCodeCI) {
+    auto item = JsonItem::FromJSON(jStagedInherits);
+    item.setState(1, 0);
+    EXPECT_EQ(item.providesCode("STAGE1"), 1);
+    EXPECT_EQ(item.providesCodeLower("stage1"), 1);
+}
+#endif
diff --git a/test/jsonutil/test_commasplit.cpp b/test/jsonutil/test_commasplit.cpp
index 4b8392d1..3b49125f 100644
--- a/test/jsonutil/test_commasplit.cpp
+++ b/test/jsonutil/test_commasplit.cpp
@@ -11,30 +11,30 @@ using namespace std;
 // only trailing empty fields should be dropped
 
 TEST(CommaSplitTest, Empty) {
-    EXPECT_EQ(commasplit(""),
+    EXPECT_EQ(commasplit<list>(""),
               list<string>({}));
 }
 
 TEST(CommaSplitTest, TrailingComma) {
     // Trailing empty values should be dropped
-    EXPECT_EQ(commasplit("a,"),
+    EXPECT_EQ(commasplit<list>("a,"),
               list<string>({"a"}));
 }
 
 TEST(CommaSplitTest, LeadingEmpty) {
     // Leading empty values should be kept
-    EXPECT_EQ(commasplit(",b"),
+    EXPECT_EQ(commasplit<list>(",b"),
               list<string>({"", "b"}));
 }
 
 TEST(CommaSplitTest, MiddleEmpty) {
     // Empty values in the middle should be kept
-    EXPECT_EQ(commasplit("a,,b"),
+    EXPECT_EQ(commasplit<list>("a,,b"),
               list<string>({"a", "", "b"}));
 }
 
 TEST(CommaSplitTest, TrailingWhitespace) {
     // If trailing whitespace results in trailing comma, it should behave the same as TrailingComma
-    EXPECT_EQ(commasplit("a, "),
+    EXPECT_EQ(commasplit<list>("a, "),
               list<string>({"a"}));
 }