diff --git a/tools/editor/cli_arg_required.cpp b/tools/editor/cli_arg_required.cpp
index 31fd3d97..0a425725 100644
--- a/tools/editor/cli_arg_required.cpp
+++ b/tools/editor/cli_arg_required.cpp
@@ -361,6 +361,7 @@ const char* const kArgRequired[] = {
     "--export-wwfl-json", "--import-wwfl-json",
     "--gen-mar", "--gen-mar-world", "--gen-mar-party",
     "--info-wmar", "--validate-wmar",
+    "--export-wmar-json", "--import-wmar-json",
     "--gen-weather-temperate", "--gen-weather-arctic",
     "--gen-weather-desert", "--gen-weather-stormy",
     "--gen-zone-atmosphere",
diff --git a/tools/editor/cli_help.cpp b/tools/editor/cli_help.cpp
index 1be41146..976f406f 100644
--- a/tools/editor/cli_help.cpp
+++ b/tools/editor/cli_help.cpp
@@ -2401,6 +2401,10 @@ void printUsage(const char* argv0) {
     std::printf("                         Print WMAR entries (id / kind / priority / glyph / name)\n");
     std::printf("  --validate-wmar <wmar-base> [--json]\n");
     std::printf("                         Static checks: id+name required, markerKind 0..3, no duplicate markerIds, no two markers at same (kind, priority) slot (picker UI sort would be non-deterministic); warns on empty iconPath, empty/oversized displayChar, RaidTarget priority > 7 (exceeds canonical /raidicon dispatch range)\n");
+    std::printf("  --export-wmar-json <wmar-base> [out.json]\n");
+    std::printf("                         Export binary .wmar to a human-editable JSON sidecar (defaults to <base>.wmar.json; emits markerKind as both int AND name string; iconPath and displayChar as plain strings)\n");
+    std::printf("  --import-wmar-json <json-path> [out-base]\n");
+    std::printf("                         Import a .wmar.json sidecar back into binary .wmar (markerKind int OR \"raidtarget\"/\"worldmap\"/\"party\"/\"custom\")\n");
     std::printf("  --catalog-pluck <wXXX-file> <id> [--json]\n");
     std::printf("                         Extract one entry by id from any registered catalog format. Auto-detects magic, dispatches to the per-format --info-* handler internally, then prints just the matching entry. Primary-key field is auto-detected (first *Id field, or first numeric)\n");
     std::printf("  --catalog-find <directory> <id> [--magic <WXXX>] [--json]\n");
diff --git a/tools/editor/cli_raid_markers_catalog.cpp b/tools/editor/cli_raid_markers_catalog.cpp
index 08cf5433..f0d8c505 100644
--- a/tools/editor/cli_raid_markers_catalog.cpp
+++ b/tools/editor/cli_raid_markers_catalog.cpp
@@ -134,6 +134,142 @@ int handleInfo(int& i, int argc, char** argv) {
     return 0;
 }
 
+int parseMarkerKindToken(const std::string& s) {
+    using M = wowee::pipeline::WoweeRaidMarkers;
+    if (s == "raidtarget") return M::RaidTarget;
+    if (s == "worldmap")   return M::WorldMap;
+    if (s == "party")      return M::Party;
+    if (s == "custom")     return M::Custom;
+    return -1;
+}
+
+int handleExportJson(int& i, int argc, char** argv) {
+    std::string base = argv[++i];
+    std::string out;
+    if (parseOptArg(i, argc, argv)) out = argv[++i];
+    base = stripWmarExt(base);
+    if (out.empty()) out = base + ".wmar.json";
+    if (!wowee::pipeline::WoweeRaidMarkersLoader::exists(base)) {
+        std::fprintf(stderr,
+            "export-wmar-json: WMAR not found: %s.wmar\n",
+            base.c_str());
+        return 1;
+    }
+    auto c = wowee::pipeline::WoweeRaidMarkersLoader::load(base);
+    nlohmann::json j;
+    j["magic"] = "WMAR";
+    j["version"] = 1;
+    j["name"] = c.name;
+    nlohmann::json arr = nlohmann::json::array();
+    for (const auto& e : c.entries) {
+        arr.push_back({
+            {"markerId", e.markerId},
+            {"name", e.name},
+            {"description", e.description},
+            {"markerKind", e.markerKind},
+            {"markerKindName", markerKindName(e.markerKind)},
+            {"priority", e.priority},
+            {"iconPath", e.iconPath},
+            {"displayChar", e.displayChar},
+            {"iconColorRGBA", e.iconColorRGBA},
+        });
+    }
+    j["entries"] = arr;
+    std::ofstream os(out);
+    if (!os) {
+        std::fprintf(stderr,
+            "export-wmar-json: failed to open %s for write\n",
+            out.c_str());
+        return 1;
+    }
+    os << j.dump(2) << "\n";
+    std::printf("Wrote %s (%zu markers)\n",
+                out.c_str(), c.entries.size());
+    return 0;
+}
+
+int handleImportJson(int& i, int argc, char** argv) {
+    std::string in = argv[++i];
+    std::string outBase;
+    if (parseOptArg(i, argc, argv)) outBase = argv[++i];
+    if (outBase.empty()) {
+        outBase = in;
+        if (outBase.size() >= 10 &&
+            outBase.substr(outBase.size() - 10) == ".wmar.json") {
+            outBase.resize(outBase.size() - 10);
+        } else {
+            stripExt(outBase, ".json");
+            stripExt(outBase, ".wmar");
+        }
+    }
+    std::ifstream is(in);
+    if (!is) {
+        std::fprintf(stderr,
+            "import-wmar-json: cannot open %s\n", in.c_str());
+        return 1;
+    }
+    nlohmann::json j;
+    try {
+        is >> j;
+    } catch (const std::exception& ex) {
+        std::fprintf(stderr,
+            "import-wmar-json: JSON parse error: %s\n", ex.what());
+        return 1;
+    }
+    wowee::pipeline::WoweeRaidMarkers c;
+    c.name = j.value("name", std::string{});
+    if (!j.contains("entries") || !j["entries"].is_array()) {
+        std::fprintf(stderr,
+            "import-wmar-json: missing or non-array 'entries'\n");
+        return 1;
+    }
+    for (const auto& je : j["entries"]) {
+        wowee::pipeline::WoweeRaidMarkers::Entry e;
+        e.markerId = je.value("markerId", 0u);
+        e.name = je.value("name", std::string{});
+        e.description = je.value("description", std::string{});
+        if (je.contains("markerKind")) {
+            const auto& v = je["markerKind"];
+            if (v.is_string()) {
+                int parsed = parseMarkerKindToken(
+                    v.get<std::string>());
+                if (parsed < 0) {
+                    std::fprintf(stderr,
+                        "import-wmar-json: unknown "
+                        "markerKind token '%s' on entry "
+                        "id=%u\n",
+                        v.get<std::string>().c_str(),
+                        e.markerId);
+                    return 1;
+                }
+                e.markerKind = static_cast<uint8_t>(parsed);
+            } else if (v.is_number_integer()) {
+                e.markerKind = static_cast<uint8_t>(v.get<int>());
+            }
+        } else if (je.contains("markerKindName") &&
+                   je["markerKindName"].is_string()) {
+            int parsed = parseMarkerKindToken(
+                je["markerKindName"].get<std::string>());
+            if (parsed >= 0)
+                e.markerKind = static_cast<uint8_t>(parsed);
+        }
+        e.priority = static_cast<uint8_t>(je.value("priority", 0u));
+        e.iconPath = je.value("iconPath", std::string{});
+        e.displayChar = je.value("displayChar", std::string{});
+        e.iconColorRGBA = je.value("iconColorRGBA", 0xFFFFFFFFu);
+        c.entries.push_back(e);
+    }
+    if (!wowee::pipeline::WoweeRaidMarkersLoader::save(c, outBase)) {
+        std::fprintf(stderr,
+            "import-wmar-json: failed to save %s.wmar\n",
+            outBase.c_str());
+        return 1;
+    }
+    std::printf("Wrote %s.wmar (%zu markers)\n",
+                outBase.c_str(), c.entries.size());
+    return 0;
+}
+
 int handleValidate(int& i, int argc, char** argv) {
     std::string base = argv[++i];
     bool jsonOut = consumeJsonFlag(i, argc, argv);
@@ -272,6 +408,12 @@ bool handleRaidMarkersCatalog(int& i, int argc, char** argv,
     if (std::strcmp(argv[i], "--validate-wmar") == 0 && i + 1 < argc) {
         outRc = handleValidate(i, argc, argv); return true;
     }
+    if (std::strcmp(argv[i], "--export-wmar-json") == 0 && i + 1 < argc) {
+        outRc = handleExportJson(i, argc, argv); return true;
+    }
+    if (std::strcmp(argv[i], "--import-wmar-json") == 0 && i + 1 < argc) {
+        outRc = handleImportJson(i, argc, argv); return true;
+    }
     return false;
 }