diff --git a/.github/workflows/unittest.yml b/.github/workflows/unittest.yml
index 19e9a25..77880d6 100644
--- a/.github/workflows/unittest.yml
+++ b/.github/workflows/unittest.yml
@@ -22,7 +22,11 @@ jobs:
       fail-fast: false
       matrix:
         python-version: [3.7, 3.8, 3.9, "3.10", "3.11", "3.12", "3.13"]
+        # run the suite against both the default renderer and the opt-in fast
+        # one (REACTON_FAST=1), so both stay green
+        reacton-fast: ["0", "1"]
 
+    name: unit-test (py${{ matrix.python-version }}, REACTON_FAST=${{ matrix.reacton-fast }})
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
@@ -37,4 +41,6 @@ jobs:
         run: |
           pip install `echo dist/*.whl`[dev] "bqplot<0.13" "pandas<3" "ruff==0.8.3"
       - name: test
+        env:
+          REACTON_FAST: ${{ matrix.reacton-fast }}
         run: pytest --cov=reacton reacton
diff --git a/benchmarks/README.md b/benchmarks/README.md
new file mode 100644
index 0000000..30dc814
--- /dev/null
+++ b/benchmarks/README.md
@@ -0,0 +1,182 @@
+# Reacton render benchmarks & the opt-in fast reconciler
+
+This directory holds the performance harness for a faster reimplementation of
+the renderer (the tree-walking downstream of `render()`), plus its design notes.
+
+The fast renderer is **opt-in and off by default.** The default `_RenderContext`
+is the original, unchanged implementation; the rewrite lives in a
+`_RenderContextFast(_RenderContext)` subclass that overrides only the
+tree-walking methods. Set `REACTON_FAST=1` to select it. CI runs the full test
+suite against both (a `reacton-fast: ["0", "1"]` matrix dimension), so the two
+stay behavior-identical.
+
+## Running the benchmarks
+
+```bash
+# default renderer, then the fast one:
+python benchmarks/bench.py --label baseline
+REACTON_FAST=1 python benchmarks/bench.py --label fast
+python benchmarks/compare.py baseline fast
+```
+
+`bench.py` writes `benchmarks/results/<label>.json`. `--scenario <name>` runs a
+subset; `--profile` also writes a cProfile `.prof` per scenario. Scenarios cover
+initial render (wide/deep), single-leaf update, root update, memoized-subtree
+skip, keyed list reorder, burst updates, full `force_update`, and teardown — so
+a change can be checked against both the headline case (one leaf updating in a
+large tree) and the no-op/​full-walk cases.
+
+Use the cheapest widgets possible in scenarios (bare `Button`/`Label`): real
+ipywidget construction cost can dominate and mask reconciler cost, so confirm
+with a profile that you are measuring tree-walking, not traitlets.
+
+## What the fast renderer changes
+
+Goal: an update should cost work proportional to what actually changed, not a
+full tree walk. With the default renderer, a single-leaf state change, a
+memoized-subtree "skip", and a full `force_update` all cost the same (~14ms on a
+300-row tree), and stale-element removal is accidentally quadratic. The fast
+renderer (`_RenderContextFast`, `REACTON_FAST=1`) addresses both:
+
+- **Dirty-subtree skipping.** State setters mark `needs_render_descendant` up
+  the parent chain, so a render pass only descends into subtrees that can
+  contain work. A component subtree whose element is identical to the previous
+  render (`el is el_prev`), is fully reconciled, and has no dirty/excepted
+  contexts is skipped in *both* phases and keeps its previous widgets
+  (`clean_subtree`).
+- **Forced full walks** (`force_update()`, `update()`, the first render) set
+  `rc._walk_all`, disabling skipping for that pass — faithful to the old
+  behavior.
+- **Stale-element removal** runs once per component context (and once for the
+  root context in `render()`) instead of an O(elements) set-difference per
+  element.
+- **Widget updates** are skipped when an identical element reconciles to
+  identical child widget objects (`_values_identical`), avoiding pointless
+  traitlets assignments.
+- **Side-effect ("orphan") widgets** (Layout/Style created during construction)
+  are tracked via ipywidgets' `on_widget_constructed` hook instead of diffing
+  the global widgets dict per creation — the old diff was O(live widgets) per
+  widget, so it degraded as an app grew.
+
+## Renderer contract
+
+What both renderers must preserve (derived from `core.py` + the test suite).
+The fast renderer overrides only `_render`, `_reconsolidate`, `_remove_element`,
+`_visit_children`, `_visit_children_values`; everything else (Element widget
+create/update/close, hooks storage, `ComponentContext`, exception plumbing, the
+render loop) is shared with the default renderer.
+
+**Phases** (inside one `rc.render()` call, under `thread_lock`, with `local.rc` set):
+
+1. *Render phase*: execute component functions depth-first, build
+   `elements_next`/`children_next`. Repeat while `_rerender_needed` (max 50,
+   then `RuntimeError`) and no exception has bubbled up.
+2. *Reconsolidate phase*: create/update/close widgets, run effects, move
+   `*_next` → current. Loop back to phase 1 if state was set during reconcile
+   (e.g. in an effect). `render()` returns the root widget.
+
+**Keys.** `el._key` or a positional default. A context's root key is `"/"`.
+Children of an element with key `K`: list → `f"{K}{i}/"`, dict → `f"{K}{k}/"`.
+Component child contexts live in `context.children[key]`. A duplicate key in one
+context raises `KeyError`. `el._key_frozen` is set once an element is rendered.
+
+**Render phase, per element:**
+- `el._render_count += 1` (a shared element is visited once; a non-shared one
+  per use — see `test_render_count_element`).
+- Element arguments (args/kwargs) are walked only for `ComponentWidget`
+  elements or shared elements; a `ComponentFunction` element does not walk its
+  arguments.
+- `ComponentFunction`: reuse the `ComponentContext` when
+  `same_component(invoke_element.component, el.component)`, or when a context
+  exists with no `root_element` (pre-created by `state_set`). A different
+  component → fresh context, old one removed during reconcile.
+- `needs_render` = `context.needs_render` (set by setters/force) OR
+  `el._arguments_changed(el_prev)` OR `context.exceptions_children`. If false,
+  the body is *not* executed (component `render_count` stays put), the previous
+  `root_element` is reused, but it is still walked.
+- Body execution resets `state_index`/`effect_index`/`memo_index`,
+  `user_contexts={}`, `exception_handler=False`, `needs_render=False` before the
+  call; wraps in `context_managers` (the solara `ContextManager` hook) and the
+  `_default_container` handling (implicit containers via
+  `ContainerAdder`/`el.__enter__`).
+- Body exceptions → `context.exceptions_self`, set `_rerender_needed`; a
+  hook-count mismatch is itself an error (fewer calls only allowed if an
+  exception interrupted the body); a component returning `None` → `ValueError`.
+- After: `parent.children_next[key] = context`; prune `children_next`/
+  `elements_next` to `used_keys`; `user_contexts_prev = user_contexts`.
+  Exceptions bubble to `parent.exceptions_children` unless `exception_handler`
+  (set by `use_exception` during the body).
+
+**Reconsolidate phase, per element** (depth-first over the element tree,
+entering child contexts):
+- *Widget element*: visit children → new kwargs (Elements replaced by widgets;
+  `FragmentWidget` children flattened into lists); then create / update-in-place
+  (same component) / replace (remove old first). Created via `el._create_widget`
+  (orphan side-effect widgets tracked into `rc._orphans[widget.model_id]`);
+  updated via `el._update_widget` (dropped kwargs restored to trait defaults,
+  listeners removed) under `hold_sync` + `suppress_events`.
+- *Component element*: recurse into the child context root, then process
+  effects: an `effect.next` with equal deps drops `next`; otherwise clean up the
+  old effect and run the next; never-executed effects run now; all are skipped
+  (cleanups still run) if the context has exceptions.
+- `el.meta` / root-widget meta merge → `widget._react_meta`.
+- Bookkeeping: `elements_next[key]` → `elements[key]`; `children_next[key]` →
+  `children[key]`; shared elements move `_shared_elements_next` →
+  `_shared_elements` with the widget in `rc._shared_widgets` (one widget per rc);
+  non-shared widget in `context.widgets[key]`; `context.element_to_widget[el]`
+  set (used by `get_widget`).
+- Stale keys (old elements whose key is not in `used_keys`) → `_remove_element`,
+  in sorted order for reproducibility.
+- After reconciling a context, `elements_next` must be empty (shared leftovers
+  are moved), else `RuntimeError`. `root_element = root_element_next`;
+  `root_element_next = None` (asserted by `test_internals`).
+
+**Removal.**
+- *Component element*: clean up all effects, recurse into `root_element`, assert
+  the context is fully empty, `del parent.children[key]`; cleanup exceptions
+  bubble (`close()` raises the first).
+- *Widget element*: recurse children first, close orphans,
+  `el._cleanup_callbacks(widget)`, `el._close_widget(widget)`. Shared widgets are
+  removed only on the last reference.
+- Removing an already-removed key is a no-op (`test_remove_element_twice`).
+
+`close()`: `_remove_element(root)`, container closed (+layout), asserts
+`_shared_elements`/`_orphans` empty, raises any pending exception.
+
+**Other pinned behavior:** `rc.render_count` increments per `render()` call;
+root widget type change without a container → `ValueError`; container gets
+`.children = [widget]` (`[]` on error). `handle_error=True` renders an HTML
+traceback widget instead of raising. Batching: `with rc:` defers re-render, and
+`hold_trait_notifications` is wrapped so frontend-triggered trait updates batch
+into a single render. Setters use `eq`/`utils.equals`, warn on mutated
+list/dict/DataFrame state, are ignored while `_closing`, and trigger a render
+unless already rendering or batching. `use_context`/`provide` walk parent
+contexts; `provide` notifies listeners only when the value changed.
+
+## Deliberate behavior deltas (not observable by the test suite)
+
+- Stale elements are now closed *after* the parent widget gets its new children
+  assigned (the old code closed them mid-walk, so a closed widget could briefly
+  remain in a container's `children`).
+- Per-element debug logging in the hot paths was dropped.
+
+## Known issues worth revisiting (found during the rewrite, not fixed here)
+
+- **Effect/cleanup exceptions** are recorded on the *parent* context's
+  `exceptions_self`, while render exceptions go to the component's own context.
+  So an effect exception is caught by `use_exception` one level higher than a
+  render exception would be. Behavior preserved from the old code; looks
+  unintentional.
+- **pandas 3.0**: setting state to an equal DataFrame triggers a re-render and
+  leaks widgets (`test_set_state_with_dataframe`). The reacton equality logic
+  likely needs a pandas-3 fix; the test environment pins `pandas<3` for now.
+- `ComponentContext.owns` is dead — never written, only asserted empty in
+  `_remove_element`.
+
+## Where initial-render time goes
+
+After the rewrite, initial render is dominated by ipywidget *construction*, not
+reconciler tree-walking — most of it is traitlets default materialization and
+`get_state` during `Widget.open()`. Reacton-side reconciliation of a large tree
+is now a small fraction of that. Future initial-render wins are mostly in
+ipywidgets/traitlets, not here.
diff --git a/benchmarks/bench.py b/benchmarks/bench.py
new file mode 100644
index 0000000..8d39ba5
--- /dev/null
+++ b/benchmarks/bench.py
@@ -0,0 +1,371 @@
+"""Benchmark harness for the reacton renderer/reconciler.
+
+Run with the project venv:
+
+    .venv/bin/python benchmarks/bench.py --label baseline
+    .venv/bin/python benchmarks/bench.py --label after --scenario leaf_update
+    .venv/bin/python benchmarks/compare.py baseline after
+
+Results are written to benchmarks/results/<label>.json. Use --profile to
+additionally write a cProfile .prof file per scenario.
+"""
+
+import argparse
+import cProfile
+import gc
+import json
+import statistics
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import reacton as react
+import reacton.core
+import reacton.ipywidgets as w
+
+# the current implementation renders recursively; keep deep trees from
+# hitting the interpreter limit so we measure speed, not stack depth
+sys.setrecursionlimit(100_000)
+
+RESULTS_DIR = Path(__file__).parent / "results"
+
+SCENARIOS = {}
+
+
+def scenario(cls):
+    SCENARIOS[cls.name] = cls
+    return cls
+
+
+class Scenario:
+    inner = 1  # operations per timed run(); reported times are per operation
+
+    def setup(self):  # once per scenario
+        pass
+
+    def setup_iteration(self):  # before each timed run, untimed
+        pass
+
+    def run(self):  # the timed part
+        raise NotImplementedError
+
+    def cleanup_iteration(self):  # after each timed run, untimed
+        pass
+
+    def teardown(self):  # once per scenario
+        pass
+
+
+@react.component
+def Row(i):
+    return w.HBox(children=[w.Button(description=f"button-{i}"), w.Label(value=f"label-{i}")])
+
+
+@react.component
+def WideApp(n):
+    return w.VBox(children=[Row(i) for i in range(n)])
+
+
+@react.component
+def Nest(depth):
+    if depth == 0:
+        return w.Button(description="leaf")
+    return w.VBox(children=[Nest(depth - 1)])
+
+
+# handles to reach use_state setters from outside the component
+_handle: dict = {}
+
+
+@react.component
+def StatefulLeaf():
+    value, set_value = react.use_state(0)
+    _handle["set"] = set_value
+    return w.Button(description=f"leaf-{value}")
+
+
+@react.component
+def AppWithStatefulLeaf(n):
+    rows = [Row(i) for i in range(n)]
+    rows.append(StatefulLeaf())
+    return w.VBox(children=rows)
+
+
+@react.component
+def RootCounterApp(n):
+    value, set_value = react.use_state(0)
+    _handle["set"] = set_value
+    rows = [Row(i) for i in range(n)]
+    return w.VBox(children=[w.Label(value=f"count: {value}"), *rows])
+
+
+@react.component
+def MemoApp(n):
+    value, set_value = react.use_state(0)
+    _handle["set"] = set_value
+    rows = react.use_memo(lambda: [Row(i) for i in range(n)], [n])
+    return w.VBox(children=[w.Label(value=f"count: {value}"), w.VBox(children=rows)])
+
+
+@react.component
+def ReorderApp(n):
+    order, set_order = react.use_state(list(range(n)))
+    _handle["set"] = set_order
+    rows = [Row(i).key(f"row-{i}") for i in order]
+    return w.VBox(children=rows)
+
+
+@react.component
+def BurstApp(n):
+    value, set_value = react.use_state(0)
+    _handle["set"] = set_value
+    rows = [Row(i) for i in range(n)]
+    return w.VBox(children=[w.IntSlider(value=value), *rows])
+
+
+@scenario
+class InitialRenderWide(Scenario):
+    """Initial render of a wide tree: N component rows, ~3N widgets."""
+
+    name = "initial_render_wide"
+    N = 300
+
+    def run(self):
+        self.widget, self.rc = react.render(WideApp(self.N))
+
+    def cleanup_iteration(self):
+        self.rc.close()
+
+
+@scenario
+class InitialRenderDeep(Scenario):
+    """Initial render of a deeply nested tree (component per level)."""
+
+    name = "initial_render_deep"
+    DEPTH = 100
+
+    def run(self):
+        self.widget, self.rc = react.render(Nest(self.DEPTH))
+
+    def cleanup_iteration(self):
+        self.rc.close()
+
+
+@scenario
+class LeafUpdate(Scenario):
+    """State change in a single leaf component of a large tree."""
+
+    name = "leaf_update"
+    N = 300
+    inner = 10
+
+    def setup(self):
+        self.widget, self.rc = react.render(AppWithStatefulLeaf(self.N))
+        self.set = _handle["set"]
+        self.counter = 0
+
+    def run(self):
+        for _ in range(self.inner):
+            self.counter += 1
+            self.set(self.counter)
+
+    def teardown(self):
+        self.rc.close()
+
+
+@scenario
+class RootUpdate(Scenario):
+    """State change at the root: children re-render but reconcile to no widget changes."""
+
+    name = "root_update"
+    N = 300
+    inner = 5
+
+    def setup(self):
+        self.widget, self.rc = react.render(RootCounterApp(self.N))
+        self.set = _handle["set"]
+        self.counter = 0
+
+    def run(self):
+        for _ in range(self.inner):
+            self.counter += 1
+            self.set(self.counter)
+
+    def teardown(self):
+        self.rc.close()
+
+
+@scenario
+class MemoSubtreeSkip(Scenario):
+    """Root state change where the heavy subtree is memoized (identical elements)."""
+
+    name = "memo_subtree_skip"
+    N = 300
+    inner = 10
+
+    def setup(self):
+        self.widget, self.rc = react.render(MemoApp(self.N))
+        self.set = _handle["set"]
+        self.counter = 0
+
+    def run(self):
+        for _ in range(self.inner):
+            self.counter += 1
+            self.set(self.counter)
+
+    def teardown(self):
+        self.rc.close()
+
+
+@scenario
+class ListReorder(Scenario):
+    """Keyed children list reversed on every update."""
+
+    name = "list_reorder"
+    N = 300
+    inner = 2
+
+    def setup(self):
+        self.widget, self.rc = react.render(ReorderApp(self.N))
+        self.set = _handle["set"]
+        self.order = list(range(self.N))
+
+    def run(self):
+        for _ in range(self.inner):
+            self.order = self.order[::-1]
+            self.set(self.order)
+
+    def teardown(self):
+        self.rc.close()
+
+
+@scenario
+class BurstUpdates(Scenario):
+    """Many small sequential updates in a modest tree: per-update fixed overhead."""
+
+    name = "burst_updates"
+    N = 20
+    inner = 50
+
+    def setup(self):
+        self.widget, self.rc = react.render(BurstApp(self.N))
+        self.set = _handle["set"]
+        self.counter = 0
+
+    def run(self):
+        for _ in range(self.inner):
+            self.counter += 1
+            self.set(self.counter)
+
+    def teardown(self):
+        self.rc.close()
+
+
+@scenario
+class ForceUpdateWide(Scenario):
+    """rc.force_update() on a large unchanged tree: full re-render + reconcile no-op."""
+
+    name = "force_update_wide"
+    N = 300
+    inner = 3
+
+    def setup(self):
+        self.widget, self.rc = react.render(WideApp(self.N))
+
+    def run(self):
+        for _ in range(self.inner):
+            self.rc.force_update()
+
+    def teardown(self):
+        self.rc.close()
+
+
+@scenario
+class TeardownWide(Scenario):
+    """Closing a large tree."""
+
+    name = "teardown_wide"
+    N = 300
+
+    def setup_iteration(self):
+        self.widget, self.rc = react.render(WideApp(self.N))
+
+    def run(self):
+        self.rc.close()
+
+
+def run_scenario(cls, repeats, warmup=1):
+    s = cls()
+    s.setup()
+    times = []
+    for i in range(warmup + repeats):
+        s.setup_iteration()
+        gc.collect()
+        gc.disable()
+        t0 = time.perf_counter()
+        s.run()
+        t1 = time.perf_counter()
+        gc.enable()
+        s.cleanup_iteration()
+        if i >= warmup:
+            times.append((t1 - t0) / cls.inner)
+    s.teardown()
+    return times
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--label", required=True, help="name for the results file")
+    parser.add_argument("--scenario", action="append", help="run only these scenarios (repeatable)")
+    parser.add_argument("--repeats", type=int, default=10)
+    parser.add_argument("--profile", action="store_true", help="also write cProfile output per scenario")
+    args = parser.parse_args()
+
+    names = args.scenario or list(SCENARIOS)
+    RESULTS_DIR.mkdir(exist_ok=True)
+    out_path = RESULTS_DIR / f"{args.label}.json"
+    results = {}
+    if out_path.exists():
+        results = json.loads(out_path.read_text()).get("results", {})
+
+    git_rev = subprocess.run(["git", "rev-parse", "--short", "HEAD"], capture_output=True, text=True).stdout.strip()
+
+    for name in names:
+        cls = SCENARIOS[name]
+        widgets_before = len(reacton.core._get_widgets_dict())
+        if args.profile:
+            prof = cProfile.Profile()
+            prof.enable()
+        times = run_scenario(cls, args.repeats)
+        if args.profile:
+            prof.disable()
+            prof_path = RESULTS_DIR / f"{args.label}-{name}.prof"
+            prof.dump_stats(prof_path)
+        widgets_after = len(reacton.core._get_widgets_dict())
+        if widgets_after > widgets_before:
+            print(f"  WARNING: {name} leaked {widgets_after - widgets_before} widgets")
+        results[name] = {
+            "inner": cls.inner,
+            "repeats": args.repeats,
+            "times": times,
+            "min": min(times),
+            "median": statistics.median(times),
+            "mean": statistics.mean(times),
+        }
+        print(f"{name:25s} min={min(times) * 1000:8.3f}ms median={statistics.median(times) * 1000:8.3f}ms")
+
+    out_path.write_text(
+        json.dumps(
+            {
+                "meta": {"git_rev": git_rev, "python": sys.version.split()[0], "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")},
+                "results": results,
+            },
+            indent=2,
+        )
+    )
+    print(f"wrote {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/compare.py b/benchmarks/compare.py
new file mode 100644
index 0000000..30bcae6
--- /dev/null
+++ b/benchmarks/compare.py
@@ -0,0 +1,24 @@
+"""Compare two benchmark result files: benchmarks/compare.py <baseline-label> <other-label>"""
+
+import json
+import sys
+from pathlib import Path
+
+RESULTS_DIR = Path(__file__).parent / "results"
+
+
+def main():
+    base_label, other_label = sys.argv[1], sys.argv[2]
+    base = json.loads((RESULTS_DIR / f"{base_label}.json").read_text())["results"]
+    other = json.loads((RESULTS_DIR / f"{other_label}.json").read_text())["results"]
+
+    print(f"{'scenario':25s} {base_label + ' (ms)':>15s} {other_label + ' (ms)':>15s} {'speedup':>9s}")
+    for name in base:
+        if name not in other:
+            continue
+        b, o = base[name]["min"], other[name]["min"]
+        print(f"{name:25s} {b * 1000:15.3f} {o * 1000:15.3f} {b / o:8.2f}x")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/results/baseline.json b/benchmarks/results/baseline.json
new file mode 100644
index 0000000..f741835
--- /dev/null
+++ b/benchmarks/results/baseline.json
@@ -0,0 +1,180 @@
+{
+  "meta": {
+    "git_rev": "51e6eda",
+    "python": "3.12.12",
+    "timestamp": "2026-06-12T11:16:58"
+  },
+  "results": {
+    "initial_render_wide": {
+      "inner": 1,
+      "repeats": 10,
+      "times": [
+        0.23066174995619804,
+        0.2229511250043288,
+        0.23814095801208168,
+        0.3301374160218984,
+        0.2510304580209777,
+        0.24094420892652124,
+        0.31956458394415677,
+        0.2731753340922296,
+        0.22426333301700652,
+        0.24640166701283306
+      ],
+      "min": 0.2229511250043288,
+      "median": 0.24367293796967715,
+      "mean": 0.2577270834008232
+    },
+    "initial_render_deep": {
+      "inner": 1,
+      "repeats": 10,
+      "times": [
+        0.030452166916802526,
+        0.02862891706172377,
+        0.0333507910836488,
+        0.0270249160239473,
+        0.03320666600484401,
+        0.019297457998618484,
+        0.02882358292117715,
+        0.03225370903965086,
+        0.01854583399835974,
+        0.019194458960555494
+      ],
+      "min": 0.01854583399835974,
+      "median": 0.02872624999145046,
+      "mean": 0.027077850000932813
+    },
+    "leaf_update": {
+      "inner": 10,
+      "repeats": 10,
+      "times": [
+        0.015494420810136944,
+        0.014060587494168431,
+        0.014436191704589874,
+        0.01429853750159964,
+        0.015158804098609835,
+        0.013711391703691334,
+        0.014806087501347065,
+        0.014974074997007846,
+        0.014965824992395937,
+        0.014798099990002811
+      ],
+      "min": 0.013711391703691334,
+      "median": 0.014802093745674937,
+      "mean": 0.014670402079354971
+    },
+    "root_update": {
+      "inner": 5,
+      "repeats": 10,
+      "times": [
+        0.015482741803862155,
+        0.014879783405922354,
+        0.014942825003527106,
+        0.014931241609156131,
+        0.01512322500348091,
+        0.015350033389404416,
+        0.0151999750174582,
+        0.015496516600251198,
+        0.015037558390758932,
+        0.015678075002506377
+      ],
+      "min": 0.014879783405922354,
+      "median": 0.015161600010469557,
+      "mean": 0.015212197522632778
+    },
+    "memo_subtree_skip": {
+      "inner": 10,
+      "repeats": 10,
+      "times": [
+        0.017278562509454788,
+        0.016307137499097735,
+        0.014772579201962798,
+        0.01527914999751374,
+        0.014424924994818867,
+        0.014807312504854054,
+        0.01564709999365732,
+        0.018269433302339166,
+        0.016703291703015564,
+        0.0172665833029896
+      ],
+      "min": 0.014424924994818867,
+      "median": 0.015977118746377528,
+      "mean": 0.016075607500970365
+    },
+    "list_reorder": {
+      "inner": 2,
+      "repeats": 10,
+      "times": [
+        0.01760525000281632,
+        0.020027416467200965,
+        0.016039874986745417,
+        0.016111333505250514,
+        0.016103937465231866,
+        0.015417291491758078,
+        0.015166437486186624,
+        0.015276812482625246,
+        0.015222146001178771,
+        0.015633792034350336
+      ],
+      "min": 0.015166437486186624,
+      "median": 0.015836833510547876,
+      "mean": 0.016260429192334412
+    },
+    "burst_updates": {
+      "inner": 50,
+      "repeats": 10,
+      "times": [
+        0.0010565624991431832,
+        0.0009308541798964142,
+        0.0009003591584041715,
+        0.0009772566589526831,
+        0.0009459341596812009,
+        0.0009503699978813529,
+        0.0010052133398130536,
+        0.0009212183183990418,
+        0.000943806660361588,
+        0.0008711291593499482
+      ],
+      "min": 0.0008711291593499482,
+      "median": 0.0009448704100213944,
+      "mean": 0.0009502704131882638
+    },
+    "force_update_wide": {
+      "inner": 3,
+      "repeats": 10,
+      "times": [
+        0.01322981936391443,
+        0.01367387497642388,
+        0.014573221987423798,
+        0.014558930648490787,
+        0.014210000013311705,
+        0.01423843065276742,
+        0.01534793033109357,
+        0.014027194663261374,
+        0.014674083329737186,
+        0.013558611002129814
+      ],
+      "min": 0.01322981936391443,
+      "median": 0.014224215333039563,
+      "mean": 0.014209209696855397
+    },
+    "teardown_wide": {
+      "inner": 1,
+      "repeats": 10,
+      "times": [
+        0.013614999945275486,
+        0.015679750009439886,
+        0.01320549997035414,
+        0.013918375014327466,
+        0.01228120899759233,
+        0.015673333080485463,
+        0.013319417019374669,
+        0.013939082971774042,
+        0.012780957971699536,
+        0.012985332985408604
+      ],
+      "min": 0.01228120899759233,
+      "median": 0.013467208482325077,
+      "mean": 0.013739795796573162
+    }
+  }
+}
diff --git a/benchmarks/results/cleanroom.json b/benchmarks/results/cleanroom.json
new file mode 100644
index 0000000..0655b45
--- /dev/null
+++ b/benchmarks/results/cleanroom.json
@@ -0,0 +1,180 @@
+{
+  "meta": {
+    "git_rev": "2722898",
+    "python": "3.12.12",
+    "timestamp": "2026-06-12T11:38:15"
+  },
+  "results": {
+    "initial_render_wide": {
+      "inner": 1,
+      "repeats": 10,
+      "times": [
+        0.19347274990286678,
+        0.19373712502419949,
+        0.1976718750083819,
+        0.19139725004788488,
+        0.19096625002566725,
+        0.1940465000225231,
+        0.19406091701239347,
+        0.20125320798251778,
+        0.19182295899372548,
+        0.19263199996203184
+      ],
+      "min": 0.19096625002566725,
+      "median": 0.19360493746353313,
+      "mean": 0.1941060833982192
+    },
+    "initial_render_deep": {
+      "inner": 1,
+      "repeats": 10,
+      "times": [
+        0.016087417025119066,
+        0.015859167091548443,
+        0.015675000031478703,
+        0.016239666030742228,
+        0.01588545902632177,
+        0.015850082971155643,
+        0.016438042046502233,
+        0.015637417091056705,
+        0.01589766691904515,
+        0.015449333004653454
+      ],
+      "min": 0.015449333004653454,
+      "median": 0.015872313058935106,
+      "mean": 0.015901925123762338
+    },
+    "leaf_update": {
+      "inner": 10,
+      "repeats": 10,
+      "times": [
+        0.0006243415991775692,
+        0.000684187503065914,
+        0.0007000250043347478,
+        0.0006291792029514909,
+        0.0007047667051665485,
+        0.0006811624974943697,
+        0.0007049791980534792,
+        0.0006596207967959344,
+        0.0007065083016641438,
+        0.0006788500002585351
+      ],
+      "min": 0.0006243415991775692,
+      "median": 0.0006826750002801418,
+      "mean": 0.0006773620808962732
+    },
+    "root_update": {
+      "inner": 5,
+      "repeats": 10,
+      "times": [
+        0.012096841796301305,
+        0.007931491592898965,
+        0.008305716793984175,
+        0.0076856916071847085,
+        0.007186225010082125,
+        0.007231783401221037,
+        0.007334250002168119,
+        0.007351474999450147,
+        0.0072177166119217874,
+        0.007220600009895861
+      ],
+      "min": 0.007186225010082125,
+      "median": 0.007342862500809132,
+      "mean": 0.007956179182510823
+    },
+    "memo_subtree_skip": {
+      "inner": 10,
+      "repeats": 10,
+      "times": [
+        0.0010647415998391806,
+        0.0010534500004723668,
+        0.0010711375041864812,
+        0.001035875000525266,
+        0.001058658305555582,
+        0.0010654916055500506,
+        0.001080041704699397,
+        0.0010764250066131354,
+        0.0010346333030611277,
+        0.0010573833948001265
+      ],
+      "min": 0.0010346333030611277,
+      "median": 0.0010616999526973812,
+      "mean": 0.0010597837425302713
+    },
+    "list_reorder": {
+      "inner": 2,
+      "repeats": 10,
+      "times": [
+        0.007312562491279095,
+        0.007310937508009374,
+        0.007908208470325917,
+        0.007593104033730924,
+        0.007406124961562455,
+        0.007432270504068583,
+        0.007562521030195057,
+        0.007555854506790638,
+        0.007610416505485773,
+        0.007751395984087139
+      ],
+      "min": 0.007310937508009374,
+      "median": 0.007559187768492848,
+      "mean": 0.007544339599553496
+    },
+    "burst_updates": {
+      "inner": 50,
+      "repeats": 10,
+      "times": [
+        0.0005163283203728497,
+        0.0005055775004439056,
+        0.0005126833403483034,
+        0.0005058775003999471,
+        0.0005001283204182982,
+        0.0004969966784119606,
+        0.0005054949992336333,
+        0.000495665839407593,
+        0.0005176850012503564,
+        0.0005084858392365276
+      ],
+      "min": 0.000495665839407593,
+      "median": 0.0005057275004219264,
+      "mean": 0.0005064923339523375
+    },
+    "force_update_wide": {
+      "inner": 3,
+      "repeats": 10,
+      "times": [
+        0.006288416644868751,
+        0.006416722006785373,
+        0.006311861332505941,
+        0.006343069680345555,
+        0.006681402679532766,
+        0.006335861010787387,
+        0.006432763688887159,
+        0.006651041641210516,
+        0.006588194364060958,
+        0.006504069315269589
+      ],
+      "min": 0.006288416644868751,
+      "median": 0.006424742847836266,
+      "mean": 0.0064553402364254
+    },
+    "teardown_wide": {
+      "inner": 1,
+      "repeats": 10,
+      "times": [
+        0.013195000006817281,
+        0.01193504105322063,
+        0.011443333001807332,
+        0.011870082933455706,
+        0.011752458056434989,
+        0.011444458039477468,
+        0.011670749983750284,
+        0.012636250001378357,
+        0.012250167084857821,
+        0.012457750039175153
+      ],
+      "min": 0.011443333001807332,
+      "median": 0.011902561993338168,
+      "mean": 0.012065529020037501
+    }
+  }
+}
diff --git a/benchmarks/results/reacton-orphan-hook.json b/benchmarks/results/reacton-orphan-hook.json
new file mode 100644
index 0000000..e898308
--- /dev/null
+++ b/benchmarks/results/reacton-orphan-hook.json
@@ -0,0 +1,66 @@
+{
+  "meta": {
+    "git_rev": "b23927a",
+    "python": "3.12.12",
+    "timestamp": "2026-06-12T12:09:24"
+  },
+  "results": {
+    "initial_render_wide": {
+      "inner": 1,
+      "repeats": 10,
+      "times": [
+        0.16581695806235075,
+        0.15514691697899252,
+        0.15857724996749312,
+        0.2585207079537213,
+        0.16281079198233783,
+        0.1583621249301359,
+        0.15629070799332112,
+        0.159947625012137,
+        0.16289833292830735,
+        0.1921248339349404
+      ],
+      "min": 0.15514691697899252,
+      "median": 0.16137920849723741,
+      "mean": 0.17304962497437373
+    },
+    "teardown_wide": {
+      "inner": 1,
+      "repeats": 10,
+      "times": [
+        0.013377250055782497,
+        0.013801792054437101,
+        0.012641833047382534,
+        0.01367874990683049,
+        0.014215542003512383,
+        0.014204374980181456,
+        0.01272583391983062,
+        0.01497374998871237,
+        0.012800749973393977,
+        0.012755332980304956
+      ],
+      "min": 0.012641833047382534,
+      "median": 0.013527999981306493,
+      "mean": 0.013517520891036838
+    },
+    "leaf_update": {
+      "inner": 10,
+      "repeats": 10,
+      "times": [
+        0.0006789457984268665,
+        0.0006692250026389956,
+        0.0007123082992620766,
+        0.000673416699282825,
+        0.0006961541948840022,
+        0.0007728417054750025,
+        0.0008166874991729856,
+        0.000751437502913177,
+        0.000726241699885577,
+        0.0007066291058436036
+      ],
+      "min": 0.0006692250026389956,
+      "median": 0.0007094687025528401,
+      "mean": 0.0007203887507785112
+    }
+  }
+}
diff --git a/reacton/core.py b/reacton/core.py
index 228f487..87af5d6 100644
--- a/reacton/core.py
+++ b/reacton/core.py
@@ -80,6 +80,37 @@ def get():
 
 _get_widgets_dict = _widgets_dict_getter()
 
+
+# Tracking widgets created as a side effect (like Layout and Style) is done
+# via the widget constructed hook: diffing the global widgets dict per widget
+# creation is O(total widgets), and solara replaces that dict with a context
+# aware mapping we should not depend on.
+_construction_recording: Optional[List["widgets.Widget"]] = None
+_chained_construction_callback: Optional[Callable] = None
+
+
+def _record_constructed_widget(widget: "widgets.Widget"):
+    if _construction_recording is not None:
+        _construction_recording.append(widget)
+    if _chained_construction_callback is not None:
+        _chained_construction_callback(widget)
+
+
+def _start_recording_constructed(recording: List["widgets.Widget"]):
+    global _construction_recording, _chained_construction_callback
+    current = getattr(widgets.Widget, "_widget_construction_callback", None)
+    if current is not _record_constructed_widget:
+        # first time, or someone else registered a callback after us: chain it
+        _chained_construction_callback = current
+        widgets.Widget.on_widget_constructed(_record_constructed_widget)
+    _construction_recording = recording
+
+
+def _stop_recording_constructed():
+    global _construction_recording
+    _construction_recording = None
+
+
 _last_rc = None  # used for testing
 local = threading.local()
 T = TypeVar("T")
@@ -178,6 +209,32 @@ def same_component(c1, c2):
     return c1 == c2
 
 
+def _mark_needs_render_ancestors(context: "ComponentContext"):
+    """Let the render phase find its way down to a context that needs work, without walking subtrees that do not."""
+    parent = context.parent
+    while parent is not None and not parent.needs_render_descendant:
+        parent.needs_render_descendant = True
+        parent = parent.parent
+
+
+def _values_identical(a, b):
+    """Are two (possibly nested in containers) values the same objects?
+
+    Used to detect that reconciliation of an identical element resolved to the
+    same widgets, meaning the widget cannot need an update.
+    """
+    if a is b:
+        return True
+    type_a = type(a)
+    if type_a is not type(b):
+        return False
+    if type_a is list or type_a is tuple:
+        return len(a) == len(b) and all(x is y or _values_identical(x, y) for x, y in zip(a, b))
+    if type_a is dict:
+        return len(a) == len(b) and all(k in b and (v is b[k] or _values_identical(v, b[k])) for k, v in a.items())
+    return False
+
+
 def _with_tracebacks(e, tracebacks):
     # copy it, and we need with_traceback for unknown reasons not to cause
     # an infinite loop
@@ -383,31 +440,34 @@ def _create_widget(self, kwargs):
         # we can't use our own kwarg, since that contains elements, not widgets
         kwargs, listeners = self._split_kwargs(kwargs)
         assert isinstance(self.component, ComponentWidget)
-        # Because we look before and after, we need a lock.
-        # A different implementation might avoid this.
+        # The recording is global state, so we need a lock.
         with self.create_lock:
             rc = get_render_context(required=True)
-            before = set(_get_widgets_dict())
+            recorded: List[widgets.Widget] = []
+            _start_recording_constructed(recorded)
             try:
-                widget = self.component.widget(**kwargs)
-                hold_trait_notifications = widget.hold_trait_notifications
+                try:
+                    widget = self.component.widget(**kwargs)
+                    hold_trait_notifications = widget.hold_trait_notifications
 
-                @contextlib.contextmanager
-                def hold_trait_notifications_extra(*args, **kwargs):
-                    with rc, hold_trait_notifications(*args, **kwargs):
-                        yield
+                    @contextlib.contextmanager
+                    def hold_trait_notifications_extra(*args, **kwargs):
+                        with rc, hold_trait_notifications(*args, **kwargs):
+                            yield
 
-                widget.hold_trait_notifications = hold_trait_notifications_extra
+                    widget.hold_trait_notifications = hold_trait_notifications_extra
 
-                if self._meta:
-                    widget._react_meta = dict(self._meta)
-            except Exception as e:
-                raise RuntimeError(f"Could not create widget {self.component.widget} with {kwargs}") from e
-            for name, callback in listeners.items():
-                if callback is not None:
-                    self._add_widget_event_listener(widget, name, callback)
-            after = set(_get_widgets_dict())
-        orphans = (after - before) - {widget.model_id}
+                    if self._meta:
+                        widget._react_meta = dict(self._meta)
+                except Exception as e:
+                    raise RuntimeError(f"Could not create widget {self.component.widget} with {kwargs}") from e
+                for name, callback in listeners.items():
+                    if callback is not None:
+                        self._add_widget_event_listener(widget, name, callback)
+            finally:
+                _stop_recording_constructed()
+        widgets_dict = _get_widgets_dict()
+        orphans = {w.model_id for w in recorded if w is not widget and w.comm is not None and w.model_id in widgets_dict}
         return widget, orphans
 
     def _update_widget(self, widget: widgets.Widget, el_prev: "Element", kwargs):
@@ -632,7 +692,7 @@ def __init__(self, **kwargs):
                 for name in normal_kwargs:
                     self.observe(self._rerender, name)
                 el = self._create_el()
-                self.rc = _RenderContext(el, self)
+                self.rc = _render_context_class()(el, self)
                 self.rc.render(el, self)
 
             def _create_el(self):
@@ -1080,6 +1140,12 @@ class ComponentContext:
     used_keys: Set[str] = field(default_factory=set)
     # if a child component's state if changed, it needs a rerender
     needs_render: bool = True
+    # some context in this subtree may need a render (set by setters walking up,
+    # cleared when the render phase walks this context)
+    needs_render_descendant: bool = True
+    # the render phase skipped this whole subtree (nothing changed), so the
+    # reconciliation phase can reuse the previous result without walking
+    clean_subtree: bool = False
 
     # elements created in this context go there
     owns: Set[Element] = field(default_factory=set)
@@ -1155,6 +1221,9 @@ def __init__(self, element: Element, container: widgets.Widget = None, children_
         self.handle_error = handle_error
         self.reconsolidating = False
         self._batch_counter = utils.ThreadSafeCounter()
+        # when set, the next render phase walks the whole tree instead of
+        # skipping subtrees in which no state changed (see _render)
+        self._walk_all = True
         if initial_state:
             self.state_set(self.context_root, initial_state)
 
@@ -1330,6 +1399,7 @@ def set_(value):
                 context.state_metadata[key] = new_metadata
                 # TODO: enable
                 context.needs_render = True
+                _mark_needs_render_ancestors(context)
                 if self._rerender_needed is False:
                     if DEBUG:
                         trigger_stack = traceback.format_stack()
@@ -1351,6 +1421,8 @@ def set_(value):
         return set_
 
     def force_update(self):
+        # a forced update re-walks the whole tree, no subtree skipping
+        self._walk_all = True
         if not self._is_rendering:
             self.render(self.element, self.container)
 
@@ -1374,6 +1446,7 @@ def use_effect(self, effect: EffectCallable, dependencies=None):
             self.context.effect_index += 1
 
     def update(self, element: Element):
+        self._walk_all = True
         if self._is_rendering:
             self.element = element
             self._rerender_needed_reasons.append(RerenderReason(reason="root element changed"))
@@ -1430,6 +1503,7 @@ def render(self, element: Element, container: widgets.Widget = None):
                     self._shared_elements_next = set()
                     self._render(self.element, "/", parent_key=ROOT_KEY)
                     self.first_render = False
+                    self._walk_all = False
                 except BaseException:
                     self._is_rendering = False
                     raise
@@ -1464,6 +1538,7 @@ def format(reason: RerenderReason):
                             self.context.exceptions_self = []
 
                             self._render(self.element, "/", parent_key=ROOT_KEY)
+                            self._walk_all = False
                             logger.info("Render done: %r %r", self._rerender_needed, self._rerender_needed_reasons[-1])
                             assert self.context is self.context_root
                             render_counts += 1
@@ -1488,6 +1563,10 @@ def format(reason: RerenderReason):
                         self.context.root_element = self.context.root_element_next
                         self.context.root_element_next = None
 
+                        # remove stale elements of the root context itself
+                        # (child contexts are swept during their reconciliation)
+                        self._remove_stale_root_elements(ROOT_KEY)
+
                         if self._shared_elements_next:
                             raise RuntimeError(f"Element not reconsolidated: {self._shared_elements_next}")
                         logger.debug("Reconsolidate phase resulted in elements:")
@@ -2194,6 +2273,600 @@ def _visit_children_values(self, value: Any, key: str, parent_key: str, f: Calla
         else:
             return value
 
+    def _remove_stale_root_elements(self, parent_key):
+        # The original _reconsolidate already removes stale elements itself,
+        # so for the base (original) render context this is a no-op.
+        pass
+
+
+class _RenderContextFast(_RenderContext):
+    # Opt-in fast reimplementation of the tree-walking, selectable via the
+    # REACTON_FAST=1 environment variable.
+    #
+    # ------------------------------------------------------------------
+    # The tree walking: one render() call alternates two kinds of phases.
+    #
+    #  * render phase (_render): execute component functions depth first
+    #    and build the next element tree (elements_next/children_next).
+    #  * reconciliation phase (_reconsolidate): walk the new element tree,
+    #    create/update/close widgets, run effects, and move the *_next
+    #    bookkeeping to current.
+    #
+    # A component subtree in which no state changed, no exception is
+    # pending, and whose element is identical to the previous render is
+    # skipped in both phases: setters mark the path from their context up
+    # to the root (ComponentContext.needs_render_descendant), so the walk
+    # only descends where work can exist. _render marks skipped contexts
+    # (clean_subtree) so _reconsolidate can reuse the previous widget
+    # without walking either.
+    # ------------------------------------------------------------------
+
+    def _set_rerender_needed(self, reason: str):
+        self._rerender_needed_reasons.append(RerenderReason(reason=reason))
+        self._rerender_needed = True
+
+    def _render(self, element: Element, default_key: str, parent_key: str):
+        if not isinstance(element, Element):
+            raise TypeError(f"Expected element, not {element}")
+        # for tracking stale elements when using get_widget
+        self._old_element_ids.add(id(element))
+        context = self.context
+        assert context is not None
+
+        if default_key == "/":
+            # the root element of a component determines which keys are in use,
+            # everything else is stale and gets removed during reconciliation
+            context.used_keys.clear()
+
+        el = element
+        key = el._key
+        if key is None:
+            key = default_key
+        el._key_frozen = True
+
+        if key in context.used_keys:
+            if DEBUG:
+                self.tracebacks.append(el.traceback)
+            raise KeyError(f"Duplicate key {key!r}")
+        context.used_keys.add(key)
+
+        if el.is_shared:
+            # a shared element renders a single widget, process it once per phase
+            if el in self._shared_elements_next:
+                return
+            self._shared_elements_next.add(el)
+
+        el_prev = context.elements_next.get(key)
+        if el_prev is None:
+            el_prev = context.elements.get(key)
+        context.elements_next[key] = el
+        el._render_count += 1  # for testing only
+
+        if isinstance(el.component, ComponentWidget):
+            assert not el.args, "no positional args supported for widgets"
+            if key in context.children_next:
+                # a function component lived at this key before
+                del context.children_next[key]
+            # the element arguments are part of this component's element tree
+            if el.kwargs:
+                self._visit_children(el, key, parent_key, self._render)
+            return
+
+        assert isinstance(el.component, ComponentFunction)
+        if el.is_shared and (el.args or el.kwargs):
+            # arguments of a shared element belong to the context it is rendered in;
+            # for non-shared component elements the component function decides
+            # what ends up in the tree
+            self._visit_children(el, key, parent_key, self._render)
+
+        context_previous = context.children_next.get(key)
+        if context_previous is None:
+            context_previous = context.children.get(key)
+
+        if (
+            not self._walk_all
+            and el is el_prev
+            and not el.is_shared
+            and context_previous is not None
+            and context.children.get(key) is context_previous
+            and not context_previous.needs_render
+            and not context_previous.needs_render_descendant
+            and not context_previous.exceptions_self
+            and not context_previous.exceptions_children
+            and context_previous.root_element is not None
+            and context_previous.root_element_next is None
+        ):
+            # fast path: same element, no state changes or pending exceptions
+            # anywhere in this subtree, and fully reconciled: the previous
+            # result stands, skip the subtree in both phases
+            context_previous.clean_subtree = True
+            context.children_next[key] = context_previous
+            return
+
+        parent_context = context
+        del context
+        if context_previous is None:
+            context = ComponentContext(parent=parent_context, context_managers=[cm(el) for cm in _component_context_manager_classes])
+            el_prev = None  # do not compare against an element of a different component
+        elif context_previous.root_element is None and context_previous.root_element_next is None:
+            # pre-created, carrying initial state (state_set), but never rendered
+            context = context_previous
+            context.context_managers = [cm(el) for cm in _component_context_manager_classes]
+        else:
+            assert context_previous.invoke_element is not None
+            if not same_component(context_previous.invoke_element.component, el.component):
+                # a different component took this key, start fresh
+                # (the old context is cleaned up during reconciliation)
+                context = ComponentContext(parent=parent_context, context_managers=[cm(el) for cm in _component_context_manager_classes])
+                el_prev = None
+            else:
+                context = context_previous
+                context.parent = parent_context
+        context.clean_subtree = False
+        context.invoke_element = el
+
+        needs_render = context.needs_render
+        if not needs_render and el_prev is not None and context_previous is context:
+            assert not isinstance(el_prev.component, ComponentWidget)
+            needs_render = el._arguments_changed(el_prev)
+        if not needs_render and context.exceptions_children:
+            # we have exceptions, so we need to render
+            needs_render = True
+        if not needs_render:
+            assert el_prev is not None
+
+        self.container_adders = []
+        self.context = context
+        render_count_check = self.render_count
+        try:
+            context.exceptions_self = []
+            root_element: Optional[Element] = None
+            if needs_render:
+                context.state_index = 0
+                context.effect_index = 0
+                context.memo_index = 0
+                context.user_contexts = {}
+                context.exception_handler = False
+                # we reset it before calling the component function,
+                # which might set it to true again
+                context.needs_render = False
+                try:
+                    with contextlib.ExitStack() as stack:
+                        for cm in context.context_managers:
+                            stack.enter_context(cm)
+                        if _default_container is not None:
+                            with _default_container() as container:
+                                el.component.render_count += 1
+                                root_element = el.component.f(*el.args, **el.kwargs)
+                            if root_element is None:
+                                if len(container.kwargs["children"]) == 1:
+                                    root_element = container.kwargs["children"][0]
+                                else:
+                                    root_element = container
+                        else:
+                            el.component.render_count += 1
+                            root_element = el.component.f(*el.args, **el.kwargs)
+                        assert root_element is not None
+                except BaseException as e:
+                    if DEBUG:
+                        # we might be interested in the traceback inside the call...
+                        if len(self.tracebacks) == 0:
+                            assert e.__traceback__ is not None
+                            traceback = cast(TracebackType, e.__traceback__)
+                            if traceback.tb_next:  # is there an error inside the call
+                                self.tracebacks.append(traceback.tb_next)
+                        self.tracebacks.append(el.traceback)
+                    logger.exception("Component %r raised exception %r", el.component, e)
+                    context.exceptions_self.append(e)
+                    self._set_rerender_needed("Exception ocurred during render")
+                    context.needs_render = True
+                if root_element is None and not context.exceptions_self:
+                    raise ValueError(f"Component {el.component} returned None")
+            else:
+                root_element = context.root_element_next or context.root_element
+
+            if self.render_count != render_count_check:
+                raise RuntimeError("Recursive render detected, possible a bug in react")
+
+            # the subtree walk below will mark this again when state changes
+            context.needs_render_descendant = False
+            if root_element is not None:
+                self._render(root_element, "/", parent_key=join_key(parent_key, key))  # depth first
+                context.root_element_next = root_element
+            elif el.is_shared:
+                self._shared_elements_next.remove(el)
+
+            try:
+                # when an exception interrupted the component function, fewer hook calls are allowed
+                if not ((context.effect_index == len(context.effects)) or (context.exceptions_self and context.effect_index <= len(context.effects))):
+                    raise RuntimeError(
+                        f"Previously render had {len(context.effects)} effects, this run {context.effect_index} "
+                        f"(in element/component: {el}/{el.component}). "
+                        "Are you using conditional hooks?"
+                    )
+                if not ((context.memo_index == len(context.memo)) or (context.exceptions_self and context.memo_index <= len(context.memo))):
+                    raise RuntimeError(
+                        f"Previously render had {len(context.memo)} calls to use_memo, this run {context.memo_index} "
+                        f"(in element/component: {el}/{el.component}). "
+                        "Are you using conditional hooks?"
+                    )
+            except RuntimeError as e:
+                logger.exception("Exception in hook count check")
+                context.exceptions_self.append(e)
+                self._set_rerender_needed("Exception ocurred during render (hook count check)")
+                context.needs_render = True
+
+            # only expose to the parent when we get this far
+            parent_context.children_next[key] = context
+            # drop children/elements from a previous render pass that are no longer used
+            used_keys = context.used_keys
+            for unused in [k for k in context.children_next if k not in used_keys]:
+                del context.children_next[unused]
+            for unused in [k for k in context.elements_next if k not in used_keys]:
+                del context.elements_next[unused]
+            context.user_contexts_prev = context.user_contexts
+        finally:
+            assert context.parent is parent_context
+            self.context = parent_context
+            if context.exceptions_self or context.exceptions_children and not context.exception_handler:
+                # this component does not handle the exceptions, bubble up
+                parent_context.exceptions_children.extend(context.exceptions_self)
+                parent_context.exceptions_children.extend(context.exceptions_children)
+            if context.exceptions_self or context.exceptions_children:
+                # make sure the next render pass walks down to this context
+                # (e.g. so a parent with use_exception gets a chance to handle it)
+                _mark_needs_render_ancestors(context)
+            if parent_context.exceptions_self or parent_context.exceptions_children:
+                if not self._rerender_needed:
+                    # this happens when an exception was added from an event handler:
+                    # no exception was raised during this render phase, but we still
+                    # need to rerender until a component catches the exception
+                    self._set_rerender_needed("Exception ocurred during render")
+                    parent_context.needs_render = True
+
+    def _reconsolidate(self, el: Element, default_key: str, parent_key: str):
+        key = el._key
+        if key is None:
+            key = default_key
+        assert key is not None
+        context = self.context
+        assert context is not None
+
+        if el.is_shared and el in self._shared_elements and el is not self.element:
+            # shared elements reconcile once, all other uses share the widget
+            return self._shared_widgets[el]
+
+        el_prev = context.elements.get(key)
+        try:
+            if isinstance(el.component, ComponentFunction):
+                child_context_next = context.children_next.get(key)
+                if child_context_next is not None and child_context_next.clean_subtree:
+                    # subtree was skipped during the render phase: the previous
+                    # reconciliation result stands
+                    child_context_next.clean_subtree = False
+                    context.children[key] = context.children_next.pop(key)
+                    return context.widgets[key]
+
+                if el_prev and isinstance(el_prev.component, ComponentWidget):
+                    # a widget element was replaced by a component element at this key
+                    self._remove_element(el_prev, default_key=key, parent_key=parent_key)
+                new_parent_key = join_key(parent_key, key)
+                try:
+                    if el.is_shared and (el.args or el.kwargs):
+                        self._visit_children(el, key, parent_key, self._reconsolidate)
+                        assert self.context is context
+
+                    child_context_prev = context.children.get(key)
+                    child_context = context.children_next[key]
+                    if child_context_prev is not None and child_context_prev is not child_context:
+                        # the component type changed, remove the old subtree
+                        assert el_prev is not None, "prev child is not None, but element is"
+                        self._remove_element(el_prev, default_key=key, parent_key=parent_key)
+
+                    self.context = child_context
+                    assert child_context.root_element_next
+                    widget = self._reconsolidate(child_context.root_element_next, "/", new_parent_key)
+                    child_context.root_element = child_context.root_element_next
+                    child_context.root_element_next = None
+                    # merge the meta of the component element onto the root widget,
+                    # e.g. SomeComponent().meta(name="a") should appear on the widget
+                    if el._meta or getattr(widget, "_react_meta", {}):
+                        widget._react_meta = {**getattr(widget, "_react_meta", {}), **el._meta}
+
+                    if el.is_shared:
+                        self._shared_widgets[el] = widget
+                    else:
+                        context.widgets[key] = widget
+
+                    # remove elements that are no longer part of this component's tree
+                    # NOTE: sorted for reproducibility
+                    stale_keys = sorted(set(child_context.elements) - child_context.used_keys)
+                    if stale_keys:
+                        logger.info("elements to be removed: %r", stale_keys)
+                        for stale_key in stale_keys:
+                            if stale_key in child_context.elements:
+                                self._remove_element(child_context.elements[stale_key], stale_key, new_parent_key)
+
+                    self._process_effects(child_context, context)
+
+                    if child_context.children_next:
+                        # if we had two render phases, we can have old contexts left over
+                        child_context.children_next.clear()
+                    if child_context.elements_next:
+                        # we can still have elements that are not used as a 'widget' in this
+                        # context, but are passed down as an element (when shared)
+                        unreferenced = []
+                        for child_key, child_el in list(child_context.elements_next.items()):
+                            if child_el not in self._shared_elements:
+                                unreferenced.append(child_el)
+                            else:
+                                child_context.elements[child_key] = child_context.elements_next.pop(child_key)
+                        if unreferenced:
+                            raise RuntimeError(f"Unused elements and unreferenced elements {unreferenced}")
+                    if child_context.exceptions_self or child_context.exceptions_children and not child_context.exception_handler:
+                        # child does not handle exceptions, so bubble up
+                        context.exceptions_children.extend(child_context.exceptions_self)
+                        context.exceptions_children.extend(child_context.exceptions_children)
+                finally:
+                    # restore context
+                    self.context = context
+                context.children[key] = context.children_next.pop(key)
+            else:
+                assert isinstance(el.component, ComponentWidget)
+                if el.args:
+                    raise TypeError("Widget element only take keyword arguments")
+
+                widget_previous = None
+                if el_prev is not None:
+                    if el_prev.is_shared:
+                        widget_previous = self._shared_widgets[el_prev]
+                    else:
+                        widget_previous = context.widgets[key]
+
+                orphan_ids: Set[str] = set()
+                if widget_previous is None:
+                    # initial create
+                    kwargs = self._visit_children_values(el.kwargs, key, parent_key, self._reconsolidate)
+                    if el.is_shared and el in self._shared_widgets:
+                        raise RuntimeError(f"Element ({el}) was already in self._shared_widgets")
+                    widget = None
+                    if not context.exceptions_children:
+                        try:
+                            widget, orphan_ids = el._create_widget(kwargs)
+                        except BaseException as e:
+                            context.exceptions_self.append(e)
+                            self._set_rerender_needed("Exception ocurred during reconciliation (creating widget)")
+                            _mark_needs_render_ancestors(context)
+                    self._store_widget(context, el, key, widget)
+                elif el_prev is not None and el_prev.component == el.component:
+                    # update the existing widget in place
+                    kwargs = self._visit_children_values(el.kwargs, key, parent_key, self._reconsolidate)
+                    if not context.exceptions_children:
+                        if el is not el_prev or not _values_identical(kwargs, el.kwargs):
+                            try:
+                                el._update_widget(widget_previous, el_prev, kwargs)
+                            except BaseException as e:
+                                context.exceptions_self.append(e)
+                                self._set_rerender_needed("Exception ocurred during reconciliation (updating widget)")
+                                _mark_needs_render_ancestors(context)
+                        # else: identical element and all children reconciled to the
+                        # same widgets, nothing can have changed
+                    self._store_widget(context, el, key, widget_previous)
+                else:
+                    assert el_prev is not None, "widget_previous is not None, but el_prev is"
+                    # a different widget type at the same key: replace
+                    self._remove_element(el_prev, key, parent_key=parent_key)
+                    kwargs = self._visit_children_values(el.kwargs, key, parent_key, self._reconsolidate)
+                    widget = None
+                    if not context.exceptions_children:
+                        try:
+                            widget, orphan_ids = el._create_widget(kwargs)
+                        except BaseException as e:
+                            context.exceptions_self.append(e)
+                            self._set_rerender_needed("Exception ocurred during reconciliation (updating widget)")
+                            _mark_needs_render_ancestors(context)
+                    self._store_widget(context, el, key, widget)
+                if orphan_ids:
+                    # widgets created as a side effect (like Layout and Style); we track
+                    # them by model id (not all widgets are hashable) for cleanup
+                    orphan_widgets = set([_get_widgets_dict()[k] for k in orphan_ids])
+                    for orphan_widget in orphan_widgets:
+                        # these are shared between widgets
+                        if orphan_widget.__class__.__name__ == "Template" and orphan_widget.__class__.__module__ == "ipyvue.Template":
+                            orphan_ids -= {orphan_widget.model_id}
+                    widget = self._shared_widgets[el] if el.is_shared else context.widgets[key]
+                    if widget.model_id not in self._orphans:
+                        self._orphans[widget.model_id] = set()
+                    self._orphans[widget.model_id].update(orphan_ids)
+
+            if el.is_shared:
+                widget = self._shared_widgets[el]
+            else:
+                widget = context.widgets[key]
+            # used in get_widget
+            if el_prev in context.element_to_widget:
+                del context.element_to_widget[el_prev]
+            context.element_to_widget[el] = widget
+            return widget
+        except Exception as e:
+            if DEBUG:
+                # we don't care about the traceback of the root element
+                if self.element is not el:
+                    # we might be interested in the traceback inside the call...
+                    if len(self.tracebacks) == 0:
+                        assert e.__traceback__ is not None
+                        traceback = cast(TracebackType, e.__traceback__)
+                        if traceback.tb_next:  # is there an error inside the call
+                            self.tracebacks.append(traceback.tb_next)
+                    self.tracebacks.append(el.traceback)
+            raise
+        finally:
+            # this marks the work as 'done'
+            context.elements[key] = context.elements_next.pop(key)
+            if el_prev in self._shared_elements:
+                self._shared_elements.remove(el_prev)
+            if el.is_shared:
+                assert el not in self._shared_elements
+                self._shared_elements.add(el)
+                assert el in self._shared_elements_next
+                self._shared_elements_next.remove(el)
+
+    def _process_effects(self, child_context: "ComponentContext", context: "ComponentContext"):
+        # NOTE: effect/cleanup exceptions are recorded on the context of the
+        # component's *parent* (`context`), unlike render exceptions: this is
+        # historical behavior (see notes.md)
+        for effect_index, effect in enumerate(child_context.effects):
+            if effect.next:
+                # if we have a next, the effect itself already executed
+                # TODO: custom equals
+                if effect.next.dependencies is not None and utils.equals(effect.dependencies, effect.next.dependencies):
+                    # dependencies are the same, just remove the reference
+                    effect.next = None
+                    continue
+                # dependencies changed: cleanup and execute next
+                if not effect._cleaned_up:
+                    try:
+                        effect.cleanup()
+                    except BaseException as e:
+                        context.exceptions_self.append(e)
+                        self._set_rerender_needed("Exception ocurred during effect")
+                        _mark_needs_render_ancestors(context)
+                        context.needs_render = True
+                effect = child_context.effects[effect_index] = effect.next
+            if child_context.exceptions_self or child_context.exceptions_children:
+                # we had an exception, so we skip the effect (not the cleanup)
+                continue
+            try:
+                effect()
+            except BaseException as e:
+                context.exceptions_self.append(e)
+                self._set_rerender_needed("Exception ocurred during effect")
+                _mark_needs_render_ancestors(context)
+                context.needs_render = True
+
+    def _store_widget(self, context: "ComponentContext", el: Element, key: str, widget: Optional[widgets.Widget]):
+        if el.is_shared:
+            self._shared_widgets[el] = widget
+        else:
+            context.widgets[key] = widget
+
+    def _remove_element(self, el: Element, default_key: str, parent_key):
+        key = el._key
+        if key is None:
+            key = default_key
+        assert key is not None
+        context = self.context
+        assert context is not None
+
+        if el.is_shared:
+            if el not in self._shared_elements:
+                # another use of this element keeps it alive, or it was already removed
+                return
+            self._shared_elements.remove(el)
+
+        if key not in context.elements:
+            # already removed, e.g. as part of the removal of a parent element
+            return
+
+        if isinstance(el.component, ComponentFunction):
+            if el.is_shared:
+                self._visit_children(el, key, parent_key, self._remove_element)
+            child_context = context.children[key]
+            try:
+                self.context = child_context
+                # the element is going away, pending exceptions only matter if cleanup fails
+                child_context.exceptions_self = []
+                child_context.exceptions_children = []
+                for effect in child_context.effects:
+                    try:
+                        if not effect._cleaned_up:
+                            effect.cleanup()
+                    except BaseException as e:
+                        child_context.exceptions_self.append(e)
+                        self._set_rerender_needed("Exception ocurred during effect")
+                        _mark_needs_render_ancestors(child_context)
+                assert child_context.root_element is not None
+                self._remove_element(child_context.root_element, "/", parent_key=join_key(parent_key, key))
+            finally:
+                try:
+                    assert not child_context.elements, f"left over elements {child_context.elements}"
+                    assert not child_context.element_to_widget, f"left over element_to_widget {child_context.element_to_widget}"
+                    assert not child_context.widgets, f"left over widgets {child_context.widgets}"
+                    assert not child_context.children, f"left over children {child_context.children}"
+                    assert not child_context.owns, f"left over owns {child_context.owns}"
+                except Exception as e:
+                    child_context.exceptions_self.append(e)
+                # restore context
+                self.context = context
+            if child_context.exceptions_self or child_context.exceptions_children and not child_context.exception_handler:
+                # child does not handle exceptions, so bubble up
+                context.exceptions_children.extend(child_context.exceptions_self)
+                context.exceptions_children.extend(child_context.exceptions_children)
+            del context.children[key]
+        else:
+            self._visit_children(el, key, parent_key, self._remove_element)
+            widget = self._shared_widgets[el] if el.is_shared else context.widgets[key]
+            if widget is not None:
+                assert widget.comm is not None
+                assert widget.model_id in _get_widgets_dict()
+                for orphan in self._orphans.get(widget.model_id, set()):
+                    orphan_widget = _get_widgets_dict().get(orphan)
+                    if orphan_widget:
+                        close_widget(orphan_widget)
+                self._orphans.pop(widget.model_id, None)
+                el._cleanup_callbacks(widget)
+                el._close_widget(widget)
+        if el.is_shared:
+            del self._shared_widgets[el]
+        else:
+            del context.widgets[key]
+        # elements can be removed multiple times, since they can be added multiple times
+        # (even non-shared elements can)
+        if el in context.element_to_widget:
+            del context.element_to_widget[el]
+        del context.elements[key]
+
+    def _visit_children(self, el: Element, default_key: str, parent_key: str, f: Callable):
+        key = el._key
+        if key is None:
+            key = default_key
+        assert key is not None
+        self._visit_children_values(el.kwargs, key, parent_key, f)
+        self._visit_children_values(el.args, key, parent_key, f)
+
+    def _visit_children_values(self, value: Any, key: str, parent_key: str, f: Callable):
+        if isinstance(value, Element):
+            return f(value, key, parent_key)
+        elif isinstance(value, (list, tuple)):
+            values = []
+            for index, v in enumerate(value):
+                new_value = self._visit_children_values(v, f"{key}{index}/", parent_key, f)
+                if isinstance(new_value, FragmentWidget):
+                    values.extend(new_value.children)
+                else:
+                    values.append(new_value)
+            if isinstance(value, tuple):
+                return tuple(values)
+            return values
+        elif isinstance(value, dict):
+            return {k: self._visit_children_values(v, f"{key}{k}/", parent_key, f) for k, v in value.items()}
+        else:
+            return value
+
+    def _remove_stale_root_elements(self, parent_key):
+        # remove stale elements of the root context itself
+        # (child contexts are swept during their reconciliation)
+        stale_keys = sorted(set(self.context_root.elements) - self.context_root.used_keys)
+        for stale_key in stale_keys:
+            if stale_key in self.context_root.elements:
+                self._remove_element(self.context_root.elements[stale_key], stale_key, parent_key)
+
+
+def _render_context_class():
+    import os
+
+    return _RenderContextFast if os.environ.get("REACTON_FAST") == "1" else _RenderContext
+
 
 @overload
 def render(
@@ -2209,14 +2882,14 @@ def render(
 
 def render(element: Element[T], container: widgets.Widget = None, children_trait="children", handle_error: bool = True, initial_state=None):
     container = container or widgets.VBox()
-    _rc = _RenderContext(element, container, children_trait=children_trait, handle_error=handle_error, initial_state=initial_state)
+    _rc = _render_context_class()(element, container, children_trait=children_trait, handle_error=handle_error, initial_state=initial_state)
     _rc.render(element, _rc.container)
     local.last_rc = weakref.ref(_rc)
     return container, _rc
 
 
 def render_fixed(element: Element[T], handle_error: bool = True) -> Tuple[T, _RenderContext]:
-    _rc = _RenderContext(element, handle_error=handle_error)
+    _rc = _render_context_class()(element, handle_error=handle_error)
     widget = _rc.render(element)
     local.last_rc = weakref.ref(_rc)
     return widget, _rc