demangle 0.5.2__tar.gz → 0.6.0__tar.gz

{demangle-0.5.2 → demangle-0.6.0}/.gitignore

@@ -19,3 +19,6 @@ tools/swift-demangle-reference/swift/
 tools/swift-demangle-reference/build/
 tools/cplus-dem-reference/gcc/
 tools/cplus-dem-reference/build/
+.agents/
+docs/assets/demangle.zip
+playground/assets/

{demangle-0.5.2 → demangle-0.6.0}/CHANGELOG.md

@@ -8,6 +8,32 @@ the reference demanglers, and a **Performance** section.
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-10-11
+
+### Fixed
+
+- Preserve playground input and selected settings while its runtime loads. Scheme
+  selectors and output controls stay inside their columns on narrow screens and with
+  enlarged text. AST references reveal collapsed ancestors and support keyboard use.
+
+### Added
+
+- MSVC C++20 three-way comparison (`operator<=>`) and ARM64e pointer authentication
+  qualifiers, including their structured AST representation.
+- Swift inverse conformance to `~Deinitable`, with module-name display options respected.
+- A standalone browser playground with theme switching and keyboard shortcuts.
+- Shareable playground links and the loaded library version, runtime retry controls,
+  and browser regression tests including a real Pyodide smoke test in CI.
+- Bounded Swift and cross-scheme signature benchmarks with successful-work checks.
+
+### Performance
+
+- Run playground parsing in a worker and derive signature and AST data from one parse.
+  Output view changes reuse the result; AST expansion is lazy and paged with a display
+  budget while raw JSON remains complete.
+- Deliver a deterministic, zipimportable source archive instead of a synthetic wheel
+  and duplicate base64 bundle.
+
 ## [0.5.2] - 2026-10-10
 
 ### Fixed
@@ -4037,7 +4063,8 @@ substitution table contents, pinned by name.
   faster by doing less work.
 - API reference published from docstrings at <https://r0ny123.github.io/demangle/>.
 
-[Unreleased]: https://github.com/r0ny123/demangle/compare/v0.5.2...HEAD
+[Unreleased]: https://github.com/r0ny123/demangle/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/r0ny123/demangle/compare/v0.5.2...v0.6.0
 [0.5.2]: https://github.com/r0ny123/demangle/compare/v0.5.1...v0.5.2
 [0.5.1]: https://github.com/r0ny123/demangle/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/r0ny123/demangle/compare/v0.4.0...v0.5.0

{demangle-0.5.2 → demangle-0.6.0}/CITATION.cff

@@ -5,4 +5,4 @@ authors:
   - name: demangle contributors
 license: MIT
 repository-code: "https://github.com/r0ny123/demangle"
-version: "0.5.2"
+version: "0.6.0"

{demangle-0.5.2 → demangle-0.6.0}/CONTRIBUTING.md

@@ -40,7 +40,22 @@ Development requirements are [dependency groups](https://peps.python.org/pep-073
 not extras. An extra is a *published* feature of the distribution -- `pip install
 demangle[dev]` would appear on PyPI as something users are invited to install -- and a
 linter is not a feature of a demangler. The groups are `test`, `format`, `lint`, `docs`,
-and `dev`, which includes the first three.
+`browser`, and `dev`, which includes the first three.
+
+The browser suite is opt-in: it needs the browser dependency group, a built docs site,
+and Chromium. It uses a deterministic fake worker for UI regressions; the real Pyodide
+CDN smoke test is separately opt-in.
+
+```console
+uv pip install -e . --group browser --group docs --group test
+python -m playwright install chromium
+mkdocs build --strict
+DEMANGLE_BROWSER_TESTS=1 python -m pytest -q tests/browser/test_playground_browser.py
+
+# Also exercise Pyodide from its CDN, as the browser CI job does.
+DEMANGLE_BROWSER_TESTS=1 DEMANGLE_PYODIDE_SMOKE=1 \
+  python -m pytest -q tests/browser/test_playground_browser.py
+```
 
 The toolchain is deliberately the fast one: **ruff** for linting and formatting (it
 replaces black, isort, flake8 and pyupgrade), **ty** for type checking (it replaces

{demangle-0.5.2 → demangle-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: demangle
-Version: 0.5.2
+Version: 0.6.0
 Summary: Read mangled symbol names -- Itanium C++, MSVC, Rust, Swift, Objective-C, Go, D, Nim, Free Pascal, Delphi, Ada/GNAT, JNI and pre-Itanium C++ (g++ 2.x, cfront/ARM, Lucid, HP aCC, CodeWarrior) -- in pure Python, with no dependencies.
 Project-URL: Homepage, https://github.com/r0ny123/demangle
 Project-URL: Documentation, https://r0ny123.github.io/demangle/
@@ -37,6 +37,7 @@ Description-Content-Type: text/markdown
 [![Python](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
 [![Licence](https://img.shields.io/badge/licence-MIT-green)](https://github.com/r0ny123/demangle/blob/main/LICENSE)
 [![Docs](https://img.shields.io/badge/docs-r0ny123.github.io-blue)](https://r0ny123.github.io/demangle/)
+[![Open Playground](https://img.shields.io/badge/Open%20Playground-r0ny123.github.io-2ea44f?logo=googlechrome&logoColor=white)](https://r0ny123.github.io/demangle/playground/)
 
 **Read mangled symbol names in pure Python** — Itanium C++ (GCC/Clang), MSVC, Rust,
 Swift, Objective-C, Go, D, Nim, Free Pascal, Delphi, Ada/GNAT, JNI, and the pre-Itanium
@@ -89,7 +90,8 @@ pip install demangle
 Python 3.11 or newer, on CPython or PyPy. That is the whole dependency list.
 
 The documentation, API reference included, is published at
-<https://r0ny123.github.io/demangle/>.
+<https://r0ny123.github.io/demangle/>. An interactive in-browser playground is available
+at <https://r0ny123.github.io/demangle/playground/>.
 
 ## Use
 
@@ -320,6 +322,9 @@ Swift's own 217 vectors:
 ```console
 $ nm -a libfoo.so | demangle
 $ demangle _ZNSt6vectorIiSaIiEE9push_backERKi
+$ demangle -b _ZN3foo3barEv                         # `mangled ==> demangled`
+$ demangle -m _ZN3foo3barEv                         # only print successfully demangled symbols
+$ demangle -s gnu _ZNSt6vectorIiSaIiEE9push_backERKi # choose output style (llvm, gnu)
 $ demangle --tree _Z1fPKc
 $ demangle --detect _RNvC6_123foo3bar
 $ demangle --detect --strict _ZN3Foo               # the scheme that reads it, or an error
@@ -338,6 +343,7 @@ $ demangle --json _Z1fPi                           # the parse tree as JSON
 $ nm -a libfoo.so | demangle --json-lines          # a JSON object per symbol
 $ demangle --json-lines --signature _Z1fPi         # ... with the parts of the name
 $ printf '%s\0' "$name" | demangle -0              # whole names ended by NUL, in and out
+$ demangle --list-languages                        # list supported schemes and aliases
 ```
 
 `--json-lines` writes one object per name, `{"mangled": ..., "demangled": ...,

{demangle-0.5.2 → demangle-0.6.0}/README.md

@@ -4,6 +4,7 @@
 [![Python](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
 [![Licence](https://img.shields.io/badge/licence-MIT-green)](https://github.com/r0ny123/demangle/blob/main/LICENSE)
 [![Docs](https://img.shields.io/badge/docs-r0ny123.github.io-blue)](https://r0ny123.github.io/demangle/)
+[![Open Playground](https://img.shields.io/badge/Open%20Playground-r0ny123.github.io-2ea44f?logo=googlechrome&logoColor=white)](https://r0ny123.github.io/demangle/playground/)
 
 **Read mangled symbol names in pure Python** — Itanium C++ (GCC/Clang), MSVC, Rust,
 Swift, Objective-C, Go, D, Nim, Free Pascal, Delphi, Ada/GNAT, JNI, and the pre-Itanium
@@ -56,7 +57,8 @@ pip install demangle
 Python 3.11 or newer, on CPython or PyPy. That is the whole dependency list.
 
 The documentation, API reference included, is published at
-<https://r0ny123.github.io/demangle/>.
+<https://r0ny123.github.io/demangle/>. An interactive in-browser playground is available
+at <https://r0ny123.github.io/demangle/playground/>.
 
 ## Use
 
@@ -287,6 +289,9 @@ Swift's own 217 vectors:
 ```console
 $ nm -a libfoo.so | demangle
 $ demangle _ZNSt6vectorIiSaIiEE9push_backERKi
+$ demangle -b _ZN3foo3barEv                         # `mangled ==> demangled`
+$ demangle -m _ZN3foo3barEv                         # only print successfully demangled symbols
+$ demangle -s gnu _ZNSt6vectorIiSaIiEE9push_backERKi # choose output style (llvm, gnu)
 $ demangle --tree _Z1fPKc
 $ demangle --detect _RNvC6_123foo3bar
 $ demangle --detect --strict _ZN3Foo               # the scheme that reads it, or an error
@@ -305,6 +310,7 @@ $ demangle --json _Z1fPi                           # the parse tree as JSON
 $ nm -a libfoo.so | demangle --json-lines          # a JSON object per symbol
 $ demangle --json-lines --signature _Z1fPi         # ... with the parts of the name
 $ printf '%s\0' "$name" | demangle -0              # whole names ended by NUL, in and out
+$ demangle --list-languages                        # list supported schemes and aliases
 ```
 
 `--json-lines` writes one object per name, `{"mangled": ..., "demangled": ...,

{demangle-0.5.2 → demangle-0.6.0}/SECURITY.md

@@ -91,8 +91,8 @@ name that caused it rather than being killed.
 
 | Version | Supported |
 | --- | --- |
-| 0.3.x | yes |
-| < 0.3 | no |
+| 0.5.x | yes |
+| < 0.5 | no |
 
 Until 1.0, security fixes land on the latest released minor version only. There is no
 long-term support branch and no backporting; upgrading to the current minor version is

demangle-0.6.0/benchmarks/baseline.json

@@ -0,0 +1,68 @@
+{
+  "cold": {
+    "names": 14101,
+    "seconds": 0.648513,
+    "per_second": 21744,
+    "microseconds_each": 45.991,
+    "normalised": 1329.407,
+    "relative_to_pivot": 123.19
+  },
+  "warm": {
+    "names": 42303,
+    "seconds": 0.015793,
+    "per_second": 2678592,
+    "microseconds_each": 0.373,
+    "normalised": 10.792
+  },
+  "negative": {
+    "names": 14101,
+    "seconds": 0.011647,
+    "per_second": 1210698,
+    "microseconds_each": 0.826,
+    "normalised": 23.876,
+    "relative_to_pivot": 2.2124
+  },
+  "structured": {
+    "names": 636,
+    "seconds": 0.035171,
+    "per_second": 18083,
+    "microseconds_each": 55.3,
+    "parsed": 636,
+    "normalised": 1598.062,
+    "relative_to_pivot": 148.0849
+  },
+  "calibration": {
+    "seconds": 0.034605,
+    "rounds": 200000
+  },
+  "swift": {
+    "names": 256,
+    "seconds": 0.0181,
+    "per_second": 14174,
+    "microseconds_each": 70.55,
+    "succeeded": 256,
+    "normalised": 2303.46,
+    "relative_to_pivot": 336.776,
+    "recorded_on": "GitHub Actions ubuntu-24.04, CPython 3.13.16; run 38108232827"
+  },
+  "swift_parse": {
+    "names": 256,
+    "seconds": 0.0213,
+    "per_second": 12046,
+    "microseconds_each": 83.02,
+    "succeeded": 256,
+    "normalised": 2710.43,
+    "relative_to_pivot": 396.277,
+    "recorded_on": "GitHub Actions ubuntu-24.04, CPython 3.13.16; run 38108232827"
+  },
+  "signature": {
+    "names": 1280,
+    "seconds": 0.0963,
+    "per_second": 13289,
+    "microseconds_each": 75.25,
+    "succeeded": 1280,
+    "normalised": 2456.81,
+    "relative_to_pivot": 359.197,
+    "recorded_on": "GitHub Actions ubuntu-24.04, CPython 3.13.16; run 38108232827"
+  }
+}

{demangle-0.5.2 → demangle-0.6.0}/benchmarks/bench.py

@@ -22,6 +22,10 @@ reproducible on a given interpreter, and fewer calls for the same output is stri
 less work, so it reports what the clock cannot. It is a report and not a gate: the count
 moves with the interpreter version as well as with this package, and a gate that fails
 on someone else's Python would be worse than none.
+
+The Swift phases use a bounded prefix of the real-world corpus, so the additional AST
+work stays quick. `signature` exercises extraction across several schemes without
+making the main corpus-sized workloads larger.
 """
 
 import argparse
@@ -58,6 +62,7 @@ TOLERANCE = 1.25
 PIVOT = "warm"
 
 CALIBRATION_ROUNDS = 200_000
+SPECIALIZED_SAMPLE_SIZE = 256
 
 
 def calibrate():
@@ -135,6 +140,11 @@ def corpus_names(*files):
     return names
 
 
+def corpus_sample(filename, limit):
+    """Read at most `limit` manglings from one conformance corpus."""
+    return corpus_names(filename)[:limit]
+
+
 def time_it(function, repeats=5):
     """Best-of-N wall time. Best, not mean: the minimum is the least noisy estimator."""
     timings = []
@@ -163,6 +173,16 @@ def benchmarks():
     )
     negatives = [f"not_a_mangled_symbol_{index}" for index in range(len(sampled))]
 
+    # Keep these focused paths representative without making the benchmark unbounded.
+    swift = corpus_sample("swift-real-world.txt", SPECIALIZED_SAMPLE_SIZE)
+    signature_inputs = [
+        ("itanium", corpus_sample("itanium-real-world.txt", SPECIALIZED_SAMPLE_SIZE)),
+        ("msvc", corpus_sample("msvc-llvm-corpus.txt", SPECIALIZED_SAMPLE_SIZE)),
+        ("rust", corpus_sample("rust-real-world.txt", SPECIALIZED_SAMPLE_SIZE)),
+        ("go", corpus_sample("go-real-world.txt", SPECIALIZED_SAMPLE_SIZE)),
+        ("swift", swift),
+    ]
+
     def cold():
         demangle.cache_clear()
         for name in sampled:
@@ -193,17 +213,59 @@ def benchmarks():
                     count += 1
         parsed.append(count)
 
-    return parsed, [
-        ("cold", cold, len(sampled)),
-        ("warm", warm, len(sampled) * 3),
-        ("negative", negative, len(negatives)),
-        ("structured", structured, len(itanium) * structured_passes),
-    ]
+    swift_demangled = []
+
+    def swift_demangle():
+        # Keep this parse-oriented measurement independent of the cache left by
+        # `time_it`'s earlier repeats.
+        demangle.cache_clear()
+        count = 0
+        for name in swift:
+            # `demangle` intentionally returns unsupported input unchanged. Counting
+            # changed spellings prevents a fast refusal from looking successful.
+            count += demangle.demangle(name, language="swift") != name
+        swift_demangled.append(count)
+
+    swift_parsed = []
+
+    def swift_parse():
+        count = 0
+        for name in swift:
+            with contextlib.suppress(Exception):
+                demangle.parse(name, language="swift")
+                count += 1
+        swift_parsed.append(count)
+
+    signatures = []
+
+    def signature():
+        count = 0
+        for language, names in signature_inputs:
+            for name in names:
+                with contextlib.suppress(Exception):
+                    demangle.signature(name, language=language)
+                    count += 1
+        signatures.append(count)
+
+    successes = {"swift": swift_demangled, "swift_parse": swift_parsed, "signature": signatures}
+    return (
+        parsed,
+        successes,
+        [
+            ("cold", cold, len(sampled)),
+            ("warm", warm, len(sampled) * 3),
+            ("negative", negative, len(negatives)),
+            ("structured", structured, len(itanium) * structured_passes),
+            ("swift", swift_demangle, len(swift)),
+            ("swift_parse", swift_parse, len(swift)),
+            ("signature", signature, sum(len(names) for _, names in signature_inputs)),
+        ],
+    )
 
 
 def run():
     results = {}
-    parsed, cases = benchmarks()
+    parsed, successes, cases = benchmarks()
     reference = calibrate()
     for name, function, count in cases:
         if not count:
@@ -218,6 +280,9 @@ def run():
         }
     if "structured" in results:
         results["structured"]["parsed"] = parsed[-1] if parsed else 0
+    for name, counts in successes.items():
+        if name in results:
+            results[name]["succeeded"] = counts[-1] if counts else 0
     for data in results.values():
         data["normalised"] = round(data["seconds"] / data["names"] / reference * 1e6, 3)
 
@@ -258,7 +323,7 @@ def calls():
     import pstats
 
     counted = {}
-    _, cases = benchmarks()
+    _, _, cases = benchmarks()
     for name, function, count in cases:
         if not count:
             continue
@@ -315,6 +380,12 @@ def main():
             print(f"\nstructured benchmark parsed {structured.get('parsed')} of {structured.get('names')} names")
             print("a timing that improved because the work stopped happening is not an improvement")
             return 1
+        for name in ("swift", "swift_parse", "signature"):
+            phase = results.get(name, {})
+            if phase.get("succeeded") != phase.get("names"):
+                print(f"\n{name} benchmark succeeded on {phase.get('succeeded', 0)} of {phase.get('names', 0)} names")
+                print("a timing that improved because the work stopped happening is not an improvement")
+                return 1
         # A shrunken corpus would also time as an improvement.
         shrunk = [
             (name, results[name]["names"], baseline[name]["names"])

demangle-0.6.0/docs/hooks.py

@@ -0,0 +1,80 @@
+"""MkDocs hook: package the pure-Python source for the browser playground and merge standalone app."""
+
+from __future__ import annotations
+
+import io
+import shutil
+import stat
+import zipfile
+from pathlib import Path
+from typing import Any
+
+_ZIP_EPOCH = (1980, 1, 1, 0, 0, 0)
+
+
+def build_assets(root_dir: Path | None = None) -> Path:
+    """Build a deterministic zipimportable archive of ``src/demangle``."""
+    if root_dir is None:
+        root_dir = Path(__file__).resolve().parent.parent
+
+    src = root_dir / "src" / "demangle"
+    if not (src / "__init__.py").is_file():
+        raise FileNotFoundError(f"demangle source package missing: {src}")
+
+    buf = io.BytesIO()
+    notices = [root_dir / name for name in ("LICENSE", "NOTICE")]
+    with zipfile.ZipFile(buf, "w") as archive:
+        for path in [*sorted(src.rglob("*")), *notices]:
+            if not path.is_file() or path.suffix == ".pyc" or "__pycache__" in path.parts:
+                continue
+            name = path.name if path in notices else path.relative_to(src.parent).as_posix()
+            info = zipfile.ZipInfo(name, _ZIP_EPOCH)
+            info.compress_type = zipfile.ZIP_DEFLATED
+            info.create_system = 3
+            info.external_attr = (stat.S_IFREG | 0o644) << 16
+            archive.writestr(info, path.read_bytes(), compress_type=zipfile.ZIP_DEFLATED, compresslevel=9)
+
+    archive_bytes = buf.getvalue()
+
+    # Emit to playground/assets/ (for standalone playground)
+    playground_assets = root_dir / "playground" / "assets"
+    playground_assets.mkdir(parents=True, exist_ok=True)
+    playground_zip = playground_assets / "demangle.zip"
+    playground_zip.write_bytes(archive_bytes)
+
+    # Also emit to docs/assets/ for backwards compatibility
+    docs_assets = root_dir / "docs" / "assets"
+    docs_assets.mkdir(parents=True, exist_ok=True)
+    docs_zip = docs_assets / "demangle.zip"
+    docs_zip.write_bytes(archive_bytes)
+
+    (docs_assets / "demangle.whl").unlink(missing_ok=True)
+    (docs_assets / "demangle_bundle.js").unlink(missing_ok=True)
+    (playground_assets / "demangle.whl").unlink(missing_ok=True)
+    (playground_assets / "demangle_bundle.js").unlink(missing_ok=True)
+
+    return playground_zip
+
+
+def on_pre_build(config: Any) -> None:
+    """MkDocs pre-build event hook."""
+    build_assets()
+
+
+def on_post_build(config: Any) -> None:
+    """MkDocs post-build event hook: merge standalone playground into site output."""
+    site_dir = Path(config["site_dir"])
+    playground_src = Path(__file__).resolve().parent.parent / "playground"
+    playground_dest = site_dir / "playground"
+    if playground_src.exists():
+        shutil.copytree(
+            playground_src,
+            playground_dest,
+            dirs_exist_ok=True,
+            ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
+        )
+
+
+if __name__ == "__main__":
+    path = build_assets()
+    print(f"Generated archive: {path} ({path.stat().st_size} bytes)")

demangle-0.6.0/docs/playground.md

@@ -0,0 +1,34 @@
+# Interactive Demangling Playground
+
+Explore mangled symbols interactively in your browser. All demangling, scheme detection, structured signature extraction, and AST graph parsing run entirely client-side using **WebAssembly** via [Pyodide](https://pyodide.org/). Symbols stay in your browser. The runtime is downloaded from a CDN on first load; demangling needs no server requests after initialization.
+
+<div style="margin: 2rem 0; text-align: center;">
+  <a href="https://r0ny123.github.io/demangle/playground/" class="md-button md-button--primary" style="font-size: 1.1rem; padding: 0.75rem 2.25rem;">
+    🚀 Launch Fullscreen Playground
+  </a>
+</div>
+
+## Key Features
+
+- **100% Client-Side Privacy**: Runs locally in your browser via [Pyodide](https://pyodide.org/) WebAssembly. No symbols or code leave your machine.
+- **Dedicated Web Worker**: Parsing executes in a dedicated Web Worker off the main thread, keeping the user interface completely non-blocking during large syntax graph rendering.
+- **14 Scheme Coverage**: Auto-detects or manually targets all 14 supported ABI schemes:
+  - Itanium C++ (GCC, Clang)
+  - Microsoft Visual C++ (MSVC)
+  - Swift (including Swift 6 invertible protocol constraints)
+  - Rust (legacy and v0)
+  - D
+  - Go
+  - Nim
+  - Free Pascal
+  - Delphi / C++Builder
+  - Ada / GNAT
+  - Java Native Interface (JNI)
+  - Objective-C
+  - CodeWarrior C++
+  - GNU v2 (pre-Itanium g++ 2.x, cfront/ARM, Lucid, HP aCC)
+- **Formatting Styles**: Switch between standard LLVM style and GNU style (spacing, template formatting).
+- **Output Formats**: Full demangled signature, both (input and demangled), base name only, or signature without parameters.
+- **Structured Signature Decomposition**: Unpacks symbols into qualified name, base name, namespace scope, parameter list, return type, calling convention, and qualifiers via `demangle.signature()`.
+- **Interactive AST Inspector**: Explore the abstract syntax tree hierarchically with collapsible nodes, lazy pagination for large graphs, jump navigation for shared references (`$ref`), or copy complete JSON syntax graphs.
+- **Permalinks & Sharing**: State is automatically encoded into URL hash fragments for one-click sharing.

{demangle-0.5.2 → demangle-0.6.0}/docs/reference/core.md

@@ -58,6 +58,7 @@ A scheme's own node kinds are under its section on the [schemes page](schemes.md
         - Decorated
         - Special
         - AstBuilder
+        - AST_BUILDER
         - builder_for
 
 ## Reading

{demangle-0.5.2 → demangle-0.6.0}/docs/reference/schemes.md

@@ -63,6 +63,7 @@ once, with the module that says most about it -- an options class with its optio
         - Indirection
         - FunctionType
         - Declaration
+        - PointerAuth
         - render
         - spelled_after
         - prefixed

{demangle-0.5.2 → demangle-0.6.0}/mkdocs.yml

@@ -5,8 +5,12 @@ repo_url: https://github.com/r0ny123/demangle
 repo_name: r0ny123/demangle
 edit_uri: edit/main/
 
+hooks:
+  - docs/hooks.py
+
 nav:
   - Home: index.md
+  - Playground: playground.md
   - Working with the tree: analysing-a-binary.md
   - Labelling a symbol table: labelling-a-symbol-table.md
   - API reference:

demangle-0.6.0/playground/README.md

@@ -0,0 +1,48 @@
+# demangle Playground
+
+[![Open Playground](https://img.shields.io/badge/Open%20Playground-r0ny123.github.io-2ea44f?logo=googlechrome&logoColor=white)](https://r0ny123.github.io/demangle/playground/)
+
+Read, decompose and explore mangled symbol names interactively in your browser. Everything runs locally on **WebAssembly** via [Pyodide](https://pyodide.org/). Nothing to install, no backend servers, and zero network data transmission.
+
+## Features
+
+- **Zero-Network Privacy**: Demangling, signature extraction, and AST parsing execute 100% client-side in WebAssembly. Your symbol names and binary details never leave your machine.
+- **Real-Time Evaluation**: Instant debounced demangling as you type or paste symbols.
+- **Full Scheme Coverage**: Auto-detects or explicitly overrides all 14 supported ABI schemes:
+  - Itanium C++ (GCC, Clang)
+  - Microsoft Visual C++ (MSVC)
+  - Swift (including Swift 6 invertible protocol constraints)
+  - Rust (legacy and v0)
+  - D
+  - Go
+  - Nim
+  - Free Pascal
+  - Delphi / C++Builder
+  - Ada / GNAT
+  - Java Native Interface (JNI)
+  - Objective-C
+  - CodeWarrior C++
+  - GNU v2 (pre-Itanium g++ 2.x, cfront/ARM, Lucid, HP aCC)
+- **Signature Decomposition**: Deconstructs symbols into qualified name, base name, namespace/scope, parameters list, return type, calling convention, and qualifiers.
+- **Interactive AST Visualizer**: Collapsible syntax graph tree view with shared reference (`$ref`) jump navigation and formatted JSON export.
+- **URL Permalinks**: Automatically syncs symbol and option state into URL hash fragments (`#symbol=...&language=...`) for one-click sharing.
+- **Light & Dark Themes**: Synchronized with system preferences and persistent across reloads.
+
+## Keyboard Shortcuts
+
+| Shortcut | Action |
+|---|---|
+| `Ctrl / Cmd + K` | Focus mangled symbol input |
+| `Esc` | Clear symbol input |
+| `Ctrl / Cmd + Enter` | Force re-evaluation |
+
+## Running Locally
+
+To run the standalone playground locally:
+
+```bash
+# From repository root:
+python -m http.server 8000
+```
+
+Then open `http://localhost:8000/playground/` in your browser.