Deduplicate unchanged uncached computed var deltas

AGENTS.md

@@ -115,6 +115,17 @@ documentation — write it under `docs/` and let the fragment link there.
 CI requires a fragment for every package whose source the PR touches; the
 `skip-changelog` label waives it for changes that are genuinely not user-facing.
 
+Which `news/` directory a fragment lands in is decided purely by changed path:
+`reflex/**` -> repo-root `news/`; `packages/<name>/src/**` ->
+`packages/<name>/news/`. A PR spanning `reflex/` and `packages/reflex-base/src/`
+therefore needs a fragment in both. Paths outside those (tests, `docs/`, CI,
+`scripts/`) require none on their own. Check the way CI does, once per affected
+package:
+
+```
+uv run towncrier check --config pyproject.toml --dir <pkg-dir> --compare-with origin/main
+```
+
 ## Breaking changes and deprecation
 
 Reflex has downstream users — don't break them. Provide a fallback path during deprecation.

CONTRIBUTING.md

@@ -60,7 +60,27 @@ Within the 'test' directory of Reflex you can add to a test file already there o
 
 Each PR that changes the source of a published package must add a news fragment describing the change. Fragments are assembled into `CHANGELOG.md` at release time by [towncrier](https://towncrier.readthedocs.io/).
 
-**Where:** add the fragment under the affected package's `news/` directory. For the main `reflex` package, that's the repo-root `news/`. For sub-packages it's `packages/<name>/news/`.
+**Where: one fragment per affected package, not one per PR.** A PR that touches
+two packages needs two fragments, one in each package's own `news/` directory.
+CI decides which packages are affected purely from the changed paths:
+
+| Changed path | Fragment belongs in |
+| --- | --- |
+| `reflex/**` | repo-root `news/` |
+| `packages/<name>/src/**` | `packages/<name>/news/` |
+
+So a PR editing both `reflex/state.py` and `packages/reflex-base/src/reflex_base/vars/base.py`
+needs a fragment in `news/` **and** one in `packages/reflex-base/news/`. Changes
+that touch neither path (tests, `docs/`, CI, `scripts/`) need no fragment on
+their own. The `integrations-docs`, `reflex-components-internal` and
+`reflex-site-shared` packages are never published, so they are always exempt.
+
+Run the same check CI runs, once per affected package:
+
+```bash
+uv run towncrier check --config pyproject.toml --dir . --compare-with origin/main
+uv run towncrier check --config pyproject.toml --dir packages/reflex-base --compare-with origin/main
+```
 
 **Filename:** `<pr-or-issue-number>.<type>.md`, where `<type>` is one of:
 

docs/vars/computed_vars.md

@@ -46,6 +46,10 @@ expensive computations, but in some cases it may not update when you expect it t
 To create a computed var that recomputes on every state update regardless of
 dependencies, use `@rx.var(cache=False)`.
 
+An uncached var is recomputed for every state update, but the recomputed value is
+only sent to the frontend when it differs from the value that was last sent, so a
+recomputation that yields the same value does not trigger a re-render.
+
 Previous versions of Reflex had a `@rx.cached_var` decorator, which is now replaced
 by the `cache` argument of `@rx.var` (which defaults to `True`).
 

news/+uncached-computed-var-delta-dedupe.performance.md

@@ -0,0 +1 @@
+`@rx.var(cache=False)` vars now remember what they last sent to the frontend. They are still recomputed on every state update, but the value is only included in the delta when it actually changed, so an uncached var whose value stays the same no longer causes needless network traffic and re-renders.

packages/reflex-base/news/+uncached-computed-var-delta-dedupe.performance.md

@@ -0,0 +1 @@
+`ComputedVar` now records a key for the value an uncached (`cache=False`) var last sent to each client, so `BaseState.get_delta` can leave the var out of the delta when a recomputation produces the same value.

packages/reflex-base/src/reflex_base/vars/base.py

@@ -8,6 +8,7 @@
 import dataclasses
 import datetime
 import functools
+import hashlib
 import inspect
 import json
 import logging
@@ -25,6 +26,7 @@
     Annotated,
     Any,
     ClassVar,
+    Final,
     Generic,
     Literal,
     NoReturn,
@@ -53,7 +55,7 @@
     VarDependencyError,
     VarTypeError,
 )
-from reflex_base.utils.format import format_state_name
+from reflex_base.utils.format import format_state_name, json_dumps
 from reflex_base.utils.imports import (
     ImmutableImportDict,
     ImmutableParsedImportDict,
@@ -2249,6 +2251,47 @@ class FakeComputedVarBaseClass(property):
     __pydantic_run_validation__ = False
 
 
+# Marker for a value that has no delta key. Compared by identity and never stored
+# on a state instance, so it is safe from serialization round trips.
+_UNKEYABLE_VALUE: Final = object()
+
+# Types whose instances are immutable and cheap to compare directly. float is
+# deliberately absent: NaN is not equal to itself, so floats are keyed by their
+# serialized form instead of comparing equal to nothing forever.
+_ATOMIC_DELTA_VALUE_TYPES: Final = frozenset({str, int, bool, type(None)})
+
+# Size of the digest used to key non-atomic delta values.
+_DELTA_VALUE_DIGEST_SIZE: Final = 16
+
+
+def _delta_value_key(value: Any) -> Any:
+    """Get a comparable, alias-free key for a value going into a delta.
+
+    Immutable scalars are keyed by themselves, paired with their type so that
+    Python-equal but JSON-distinct values (``1`` and ``True``) do not collide.
+    Everything else is keyed by a digest of its serialized form: that is exactly
+    what the client receives, so a value without a registered serializer keys by
+    the ``null`` the client would get, it cannot be invalidated by a later
+    in-place mutation of the value, and it stays small no matter how big the
+    value is.
+
+    Args:
+        value: The value to key.
+
+    Returns:
+        The key, or ``_UNKEYABLE_VALUE`` if the value cannot be serialized.
+    """
+    value_type = type(value)
+    if value_type in _ATOMIC_DELTA_VALUE_TYPES:
+        return (value_type, value)
+    try:
+        return hashlib.blake2b(
+            json_dumps(value).encode(), digest_size=_DELTA_VALUE_DIGEST_SIZE
+        ).digest()
+    except Exception:
+        return _UNKEYABLE_VALUE
+
+
 def is_computed_var(obj: Any) -> TypeGuard[ComputedVar]:
     """Check if the object is a ComputedVar.
 
@@ -2483,6 +2526,51 @@ def _last_updated_attr(self) -> str:
         """
         return f"__last_updated_{self._js_expr}"
 
+    @property
+    def _last_delta_key_attr(self) -> str:
+        """The attribute used to store the key of the last value sent in a delta.
+
+        Returns:
+            An attribute name.
+        """
+        return f"__last_delta_{self._js_expr}"
+
+    def _record_delta_value(self, instance: BaseState, value: Any, token: str) -> bool:
+        """Record the value an uncached var contributes to the delta.
+
+        Uncached vars are recomputed for every delta, but recomputing does not
+        imply the value changed. Keeping a key for the last value that was sent
+        to the client allows an unchanged value to be omitted from the delta,
+        avoiding a needless re-render on the frontend.
+
+        The client token is recorded alongside the key because a single state
+        instance can serve several clients (linked shared states): a value that
+        was already sent to one client still has to be sent to the others.
+
+        Args:
+            instance: The state instance that the computed var is attached to.
+            value: The freshly computed value.
+            token: The client token the delta is being produced for.
+
+        Returns:
+            Whether the value differs from the last recorded value and should
+            therefore be included in the delta.
+        """
+        attr = self._last_delta_key_attr
+        key = _delta_value_key(value)
+        if key is _UNKEYABLE_VALUE:
+            # The value can never be compared, so it always has to be sent.
+            with contextlib.suppress(AttributeError):
+                delattr(instance, attr)
+            return True
+        recorded = (token, key)
+        if getattr(instance, attr, None) == recorded:
+            return False
+        setattr(instance, attr, recorded)
+        # Ensure the recorded value gets serialized to redis.
+        instance._was_touched = True
+        return True
+
     def needs_update(self, instance: BaseState) -> bool:
         """Check if the computed var needs to be updated.
 

reflex/istate/shared.py

@@ -112,7 +112,8 @@ async def _patch_state(
         root_state.dirty_vars.add("router")
         root_state.dirty_vars.add(ROUTER_DATA)
         root_state._mark_dirty()
-        await root_state._get_resolved_delta()
+        # The delta is discarded: it is only resolved to refresh computed vars.
+        await root_state._get_resolved_delta(record_values=False)
         yield
     finally:
         original_parent_state.substates[state_name] = original_state

reflex/state.py

@@ -14,7 +14,7 @@
 import re
 import sys
 import time
-from collections.abc import Callable, Iterator, Mapping, Sequence
+from collections.abc import Callable, Coroutine, Iterator, Mapping, Sequence
 from hashlib import md5
 from types import FunctionType
 from typing import (
@@ -309,6 +309,30 @@ async def _resolve_delta(delta: Delta) -> Delta:
     return delta
 
 
+async def _drop_unchanged_delta_value(
+    cvar: ComputedVar,
+    instance: BaseState,
+    value: Coroutine[None, None, Any],
+    token: str,
+) -> Any:
+    """Await an async uncached computed var, dropping it if the value did not change.
+
+    Args:
+        cvar: The computed var that produced the coroutine.
+        instance: The state instance the computed var is attached to.
+        value: The coroutine returned by the computed var.
+        token: The client token the delta is being produced for.
+
+    Returns:
+        The resolved value, or ``_DROP_FROM_DELTA`` when it matches the last
+        value that was sent to the client.
+    """
+    resolved = await value
+    if not cvar._record_delta_value(instance, resolved, token):
+        return _DROP_FROM_DELTA
+    return resolved
+
+
 RETURN = TypeVar("RETURN")
 PARAMS = ParamSpec("PARAMS")
 
@@ -1954,9 +1978,15 @@ def _dirty_computed_vars(
             if include_backend or not self.computed_vars[cvar]._backend
         }
 
-    def get_delta(self) -> Delta:
+    def get_delta(self, record_values: bool = True) -> Delta:
         """Get the delta for the state.
 
+        Args:
+            record_values: Whether the values of uncached computed vars should be
+                recorded as sent to the client. Pass False when the delta is
+                computed for its side effects and then discarded, otherwise the
+                unsent values would be omitted from the next delta.
+
         Returns:
             The delta for the state.
         """
@@ -1973,30 +2003,46 @@ def get_delta(self) -> Delta:
             self.dirty_vars.intersection(frontend_computed_vars)
         )
 
-        subdelta: dict[str, Any] = {
-            prop + FIELD_MARKER: self.get_value(prop)
-            for prop in delta_vars
-            if not types.is_backend_base_variable(prop, type(self))
-        }
+        always_dirty_computed_vars = self._always_dirty_computed_vars
+        # Token of the client this delta is for, used to know which values it has.
+        token = self.router.session.client_token if always_dirty_computed_vars else ""
+        subdelta: dict[str, Any] = {}
+        for prop in delta_vars:
+            if types.is_backend_base_variable(prop, type(self)):
+                continue
+            value = self.get_value(prop)
+            if record_values and prop in always_dirty_computed_vars:
+                # Uncached computed vars are recomputed for every delta; only
+                # send them when the recomputed value actually changed.
+                cvar = self.computed_vars[prop]
+                if inspect.iscoroutine(value):
+                    value = _drop_unchanged_delta_value(cvar, self, value, token)
+                elif not cvar._record_delta_value(self, value, token):
+                    continue
+            subdelta[prop + FIELD_MARKER] = value
 
         if len(subdelta) > 0:
             delta[self.get_full_name()] = subdelta
 
         # Recursively find the substate deltas.
         substates = self.substates
         for substate in self.dirty_substates.union(self._always_dirty_substates):
-            delta.update(substates[substate].get_delta())
+            delta.update(substates[substate].get_delta(record_values=record_values))
 
         # Return the delta.
         return delta
 
-    async def _get_resolved_delta(self) -> Delta:
+    async def _get_resolved_delta(self, record_values: bool = True) -> Delta:
         """Get the delta for the state after resolving all coroutines.
 
+        Args:
+            record_values: Whether the values of uncached computed vars should be
+                recorded as sent to the client. See `get_delta`.
+
         Returns:
             The resolved delta for the state.
         """
-        return await _resolve_delta(self.get_delta())
+        return await _resolve_delta(self.get_delta(record_values=record_values))
 
     def _mark_dirty(self):
         """Mark the substate and all parent states as dirty."""