reflex-dev/reflex

Reflex is a Python-based web framework that compiles reactive state management into React applications, supporting both development and production deployment via Docker. It provides a modular architecture with a core library for state, events, and compilation, alongside a comprehensive ecosystem of UI components, charting libraries, and integration plugins. The system includes tooling for automated documentation, release management, and cloud hosting, enabling developers to build full-stack web apps using pure Python.

55 changes.

The project migrated from the legacy Pynecone framework to a modular Reflex architecture, stripping out all old core modules, templates, and component implementations. This period focused on restructuring the codebase into separate packages with lazy loading, replacing the build system with Hatch and uv, and establishing comprehensive test coverage for the new structure.

77 changes.

The project underwent a major architectural reorganization, splitting the core library into a modular reflex-base package and introducing a new immutable Var system, state management, and plugin infrastructure. This period also saw the extensive expansion of the component library with new packages for charts, media, and UI primitives, alongside the introduction of automated documentation generation and OpenTelemetry observability.

Introduces a new DataTable component in the reflex-components-gridjs package that wraps the gridjs-react library. The component supports displaying data from lists or pandas DataFrames, automatically extracting columns and data when a DataFrame is provided. It includes validation to prevent passing both a DataFrame and explicit columns, and requires type annotations for computed variables to ensure proper rendering.

packages/reflex-components-gridjs · high confidence

The reflex-components-core package now includes a ReactRouterLink component that enables client-side navigation within React Router applications. This component wraps the React Router Link element, allowing users to navigate using a 'to' prop (which can be a string path or a structured object with pathname, search, and hash) instead of a traditional href. It supports advanced navigation features such as replacing history entries, triggering document navigation, preventing scroll resets, defining link discovery behavior, and enabling view transitions.

_packages/reflex-components-core/src/reflex\_components\_core, packages/reflex-components-core/src/reflex\_components\_core/react\router · high confidence

Users can now display toast notifications using the Sonner library (v2.0.8) via the new \Toaster\ component and \toast\ function. The component supports configurable positioning, rich colors, and custom actions, with event callbacks like \on\_dismiss\ and \on\_auto\_close\ properly queued for execution.

packages/reflex-components-sonner/src · high confidence

New shell scripts in the \scripts/sfw-shims\ directory now allow routing npm and bun registry operations through the Socket.dev Firewall (sfw). Sourcing \activate.sh\ adds these shims to the PATH, intercepting commands like \install\, \add\, \update\, and \publish\ to enforce security policies, while falling back to standard behavior for other commands or if sfw is not available.

scripts/sfw-shims · high confidence

The \reflex\_base.constants\ module has been introduced to consolidate framework-wide configuration values, including directory structures, compiler variables, default ports, color modes, and route definitions. This change centralizes these constants, ensuring consistent configuration across the Reflex base package and providing a single source of truth for build and runtime settings.

_packages/reflex-base/src/reflex\base/constants · high confidence

This change introduces the \packages/integrations-docs\ package, providing the foundational structure and content for Reflex integration guides. It includes Python modules to programmatically access documentation (\get\_doc\, \list\_docs\) and a comprehensive set of Markdown guides covering integrations such as Airtable, AWS, Azure Auth, Anthropic, Databricks, Descope, Google Auth, OpenAI, and others. This package serves as the central repository for integration setup instructions, credential configuration steps, and usage notes for these services.

packages/integrations-docs · high confidence

Added empty \.gitkeep\ files to the \news/\ directories within the \reflex-components-lucide\, \reflex-components-moment\, \reflex-docgen\, and \reflex-hosting-cli\ packages. This prepares these specific package locations to accept towncrier changelog fragments, enabling structured changelog management for these components in future releases.

(repo-wide) · high confidence

The DataEditor component is now available, wrapping the @glideapps/glide-data-grid library (v6.0.3) to provide a spreadsheet-like interface. Users can customize the grid's appearance using the new DataEditorTheme class, which exposes extensive styling options for colors, fonts, and borders. The component supports various cell types, including images and dropdowns, and integrates with the new reflex-base logging infrastructure.

packages/reflex-components-dataeditor/src · high confidence

A new Moment component is now available in the reflex-components-moment package, enabling users to display dates in human-readable formats (e.g., "5 minutes ago") or with custom formatting. The component supports features such as relative time display, duration calculation, timezone handling, and locale customization. It relies on react-moment 2.0.2 and moment 2.30.1, with optional imports for moment-timezone and moment-duration-format when specific features like timezones or durations are used.

packages/reflex-components-moment/src · high confidence

This change adds the \reflex-components-plotly\ package, exposing a suite of Plotly chart components (including \Plotly\, \PlotlyBasic\, \PlotlyCartesian\, \PlotlyFinance\, \PlotlyGeo\, \PlotlyGl2d\, \PlotlyGl3d\, \PlotlyMapbox\, and \PlotlyStrict\) accessible via a \plotly\ namespace. Users can now render interactive Plotly graphs in their Reflex applications, with support for various event handlers (click, hover, relayout, etc.) and a new \locale\ property that allows configuring formatting and modebar labels on a per-chart basis.

packages/reflex-components-plotly/src · high confidence

The reflex-components-react-player package now provides ReactPlayer components for embedding audio and video media. Users can use the Audio and Video classes, which inherit from a shared ReactPlayer base, to play media via the 'src' property and control playback using props like 'playing', 'loop', 'volume', and 'muted'. The component exposes several event handlers for tracking state changes, including 'on\_ready', 'on\_start', 'on\_play', 'on\_playing', 'on\_progress', 'on\_time\_update', 'on\_duration\_change', 'on\_rate\_change', 'on\_seeked', 'on\_waiting', 'on\_enter\_picture\_in\_picture', and 'on\_leave\_picture\_in\_picture'. Internal logging has been migrated to standard Python logging.

packages/reflex-components-react-player · high confidence

Adds a new set of Python components for Recharts (version 3.10.1), exposing chart types such as Area, Bar, Line, Pie, Radar, Sankey, and Treemap, along with axes, legends, tooltips, and responsive containers. The components are structured into cartesian, charts, general, and polar modules, with lazy loading and event handlers for interactivity.

packages/reflex-components-recharts/src · high confidence

The \reflex-components-core\ package now exposes a new \base\ module containing foundational React components such as \ErrorBoundary\, \Fragment\, \StrictMode\, \AppWrap\, and document/head management components (\Meta\, \Title\, \Script\, \Body\). \AppWrap\ serves as the entry point for the Python app-wrap chain, allowing components to inject providers or wrappers around the application. The \ErrorBoundary\ provides a default fallback UI with error details and a copy button, while \Script\ ensures head updates are flushed synchronously to prevent hydration mismatches.

_packages/reflex-components-core/src/reflex\_components\core/base · high confidence

A new \reflex.experimental\ namespace (accessible as \rx.\_x\) is introduced to host features under active development. This includes \ClientStateVar\, which enables client-side state management via React's \useState\ and allows state to be shared across components without global references, and a set of wrappers for standard React hooks (\useCallback\, \useContext\, \useRef\, \useState\) in \hooks.py\. Additionally, \memo\ and \run\_in\_thread\ are exposed here as deprecated aliases that warn users to migrate to their promoted counterparts in the main \rx\ namespace, while \hybrid\_property\ and \code\_block\ are also included in this experimental collection.

reflex/experimental · high confidence

The \reflex-base\ package now includes a new immutable Var system under \reflex\_base.vars\, providing a comprehensive set of typed variable classes for frontend state management. This release introduces specialized Var types including \StringVar\, \NumberVar\, \BooleanVar\, \ArrayVar\, \ObjectVar\, \ColorVar\, \DateTimeVar\, and \FunctionVar\, each supporting immutable operations and type-safe interactions. The system features a \HybridProperty\ decorator that allows properties to function as standard Python properties on the backend while exposing frontend-accessible vars, along with dependency tracking capabilities for efficient state updates. New utility functions \use\_hook\_var\ and \use\_id\ enable direct integration with React hooks, while the \VarData\ system manages imports and hooks for compiled components.

_packages/reflex-base/src/reflex\base/vars · high confidence

The \reflex-components-internal\ package is now available, providing a centralized set of internal UI components (such as Accordion, Avatar, Badge, Button, Dialog, Drawer, Input, Select, and others) alongside specialized integration blocks for Cal.com, Lemcal, and Plain chat. This release also adds a comprehensive telemetry suite, enabling developers to easily integrate tracking scripts for PostHog, Google Analytics, Ahrefs, Clearbit, Common Room, Koala, Leadpipe, RB2B, Unify, and Default.com, along with dedicated demo and intro form components that validate company emails and submit data to PostHog.

packages/reflex-components-internal · high confidence

The Reflex code component package now includes new \code\ and \shiki\_code\_block\ components. The \shiki\_code\_block\ provides syntax highlighting for a wide range of programming languages using the Shiki library, supports line numbers, and includes a copy-to-clipboard feature with visual feedback. The \code\ component offers a simpler code display option. These components replace previous implementations and integrate with the Reflex base styling and event systems.

packages/reflex-components-code/src · high confidence

The repository now enforces code quality and type safety through a new \.pre-commit-config.yaml\ that integrates \ruff\ for formatting and linting, \codespell\ for spelling, \pyright\ and \ty\ for type checking, and \biome\ for JavaScript formatting. This setup is supported by a \.python-version\ file specifying Python 3.14, an \AGENTS.md\ file detailing development workflows and commands, and a \pyi\_hashes.json\ file to track generated type stubs.

(repo-wide) · high confidence

The new \reflex\_components\_core.el\ package provides a comprehensive set of Python classes that map directly to standard HTML tags (such as \div\, \button\, \img\, and \form\), allowing users to render raw HTML elements within their Reflex applications. These components inherit common attributes like accessibility roles, content editing, and event handling from a shared base, and are organized into logical categories including forms, media, sectioning, and typography. The package also includes specialized handling for specific elements, such as replacing the standard anchor tag with React Router's Link component and ensuring correct memoization behavior for void and raw-text elements.

_packages/reflex-components-core/src/reflex\_components\core/el · high confidence

The new reflex-components-core package provides a set of core UI components and utilities, including auto-scrolling containers, connection status banners and toasters, clipboard paste handling, debounced input fields, conditional rendering (cond/match), list iteration (foreach), HTML rendering, responsive breakpoints, and file upload helpers. This module also includes lazy-loading infrastructure to optimize initial load performance by deferring component imports until they are actually used.

_packages/reflex-components-core/src/reflex\_components\core/core · high confidence

The new reflex-docgen package provides the core logic for generating documentation for Reflex components and Python classes. It introduces data classes to represent component props, event handlers, class fields, and methods, along with functions to extract this metadata from component classes and arbitrary Python types. The module includes utilities for parsing docstrings, resolving type annotations into concise human-readable strings, and merging inherited attribute descriptions, enabling automated, readable API documentation.

_packages/reflex-docgen/src/reflex\docgen · high confidence

The new reflex-release package replaces the previous scripts/release.py with a structured, changelog-driven release automation system. It introduces a CLI with subcommands to detect untagged versions, plan version bumps, materialize changelog updates, and validate build artifacts. The package enforces strict release hygiene by automatically lifting unshippable development-release dependency pins and verifying that built distributions match the expected version and package name. It also supports custom build workflows for platform-specific packages and integrates with GitHub Actions to handle post-release tasks and lockstep versioning for related packages.

_packages/reflex-release/src/reflex\release · high confidence

The new reflex-site-shared package centralizes shared site scaffolding used across Reflex's web properties, including pages, templates, views, gallery, and styles. It provides a Python API to discover Markdown content directories, derive routes and navigation, and render them using the Reflex documentation component map, supporting features like deferred heavy previews and centralized sidebar ordering. The package also includes reusable UI components such as a marketing footer, marketing navigation (navbar and mobile drawer), an announcement banner, and a keyword-only Algolia search component. Additionally, it offers backend utilities for fetching recent blogs, handling newsletter signups with PostHog telemetry, and monitoring service status via Checkly, along with styled documentation blocks for code, demos, headings, and typography.

packages/reflex-site-shared · high confidence

Reflex now exposes a structured plugin system in the \reflex\_base.plugins\ package, allowing developers to extend the framework via a standardized hook interface. This location provides the core plugin base class, compiler hook dispatching, and context objects for route registration and compilation stages. It ships with several built-in plugins: \TailwindV3Plugin\ and \TailwindV4Plugin\ for styling, an \EmbedPlugin\ that enables mounting Reflex apps into host-page DOM elements via a \mount\_target\, a \ScreenshotPlugin\ that adds internal endpoints for state cloning and connection tracking, and a \SitemapPlugin\ for generating XML sitemaps with configurable trailing slash behavior.

_packages/reflex-base/src/reflex\base/plugins · high confidence

The reflex-build-sdk package is now available as a Python client for the Reflex Cloud API, providing both synchronous (ReflexCloud) and asynchronous (AsyncReflexCloud) interfaces. It enables programmatic management of apps, projects, deployments, environments, and databases, along with authentication, custom domains, security reviews, and Google Cloud provider integration. The SDK uses typed models and errors, retries safe requests, and supports configurable HTTP transports.

packages/reflex-build-sdk · high confidence

The \reflex\_components\_radix\ package now exposes a comprehensive set of interactive UI components from the Radix UI theme system. This location introduces the component definitions and lazy-loading infrastructure for \AlertDialog\, \AspectRatio\, \Avatar\, \Badge\, \Button\, \Callout\, \Card\, \Checkbox\ (including a high-level variant with labels), \CheckboxCards\, \CheckboxGroup\, \ContextMenu\, \DataList\, \Dialog\, \DropdownMenu\, \HoverCard\, \IconButton\, \Inset\, and \Popover\. Users can now import and use these components directly in their Reflex applications to build richer, theme-consistent interfaces.

_packages/reflex-components-radix/src/reflex\_components\radix/themes/components · high confidence

This release introduces a new \primitives\ package under \reflex-components-radix\ that wraps Radix UI primitives (Accordion, Dialog, Drawer, Form, Progress, Slider) and provides base classes for the \@radix-ui/themes\ library. Users can now access low-level Radix components like \Dialog\, \Accordion\, and \Form\ with consistent styling and event handling, as well as theme-aware components like \ColorModeIconButton\ and \ColorModeSwitch\ for light/dark mode toggling. The \Form\ component includes server-side validation support via \server\_invalid\ and \force\_match\ props, while \Dialog\ and \Drawer\ components support portal mounting and animation controls.

_packages/reflex-components-radix/src/reflex\_components\radix/primitives · high confidence

The \reflex-base\ package now includes a new \event\ module containing the core \Event\ class and \EventContext\ for managing event lifecycle, state, and OpenTelemetry tracing. This introduces the foundational data structures and context management required for the backend event queue migration and built-in OpenTelemetry instrumentation.

_packages/reflex-base/src/reflex\base/event · high confidence

The web application templates have been restructured to support a modern React-based architecture. This includes a new entry point for embedding Reflex apps into host pages via a configurable mount target, a color mode provider that respects system preferences, and a code block component that uses lazy, viewport-aware syntax highlighting. The build process now supports pre-compressing static assets (gzip, Brotli, zstd) for faster delivery, and a Vite plugin ensures reliable hot reloading in Safari by handling ESM cache-busting. Additionally, the frontend now includes robust helpers for handling non-finite JSON floats, debouncing/throttling, and data editor cell formatting.

_packages/reflex-base/src/reflex\base/.templates · high confidence

The layout module in the Radix themes package now includes a comprehensive set of declarative layout components, including Box, Flex, Grid, Container, Section, Center, Spacer, Stack (with VStack and HStack), and List variants (Ordered, Unordered, and List Item). These components provide standardized spacing, alignment, and sizing props (such as flex-grow, flex-shrink, spacing, and responsive sizes) to help users construct flexible and grid-based page layouts more easily.

_packages/reflex-components-radix/src/reflex\_components\radix/themes/layout · high confidence

The documentation generation system now uses a dedicated markdown parser and transformer architecture. This change introduces a new module that parses markdown files into a structured AST (handling frontmatter, headings, code blocks, tables, and inline spans) and provides a generic transformer base class to convert that AST into different output formats. Specifically, it adds a transformer that renders documentation content as Reflex UI components, enabling the documentation site to dynamically generate component previews and styled content from markdown sources.

_packages/reflex-docgen/src/reflex\docgen/markdown · high confidence

Added two new deployment configurations for Reflex applications: a Docker Compose setup (\production-compose\) that uses Caddy for automatic TLS termination and reverse proxying, and a single-container Docker image (\production\) designed for platforms like Render or Heroku that handle TLS at the edge. Both examples utilize Python 3.13, \uv\ for dependency management, and export the frontend statically to be served by Caddy, ensuring the runtime image contains no build tooling.

docker-example/production-compose · high confidence

The new reflex-otel package provides built-in OpenTelemetry instrumentation for Reflex applications. On the backend, ReflexInstrumentor enables automatic tracing for event handlers (with parent-child relationships for chained events), app compilation steps, and ASGI HTTP/websocket requests, alongside metrics for event duration, state acquisition, and websocket activity; it also redacts client tokens from request URLs. On the frontend, the OtelPlugin compiles a browser-side tracing bundle that propagates W3C traceparents to link browser interactions with backend spans, and optionally exports web vitals, React render timings, and socket connection events to an OTLP/HTTP collector.

packages/reflex-otel · high confidence

The project adds a suite of new scripts to the \scripts/\ directory to improve build reliability and developer tooling. \check\_min\_deps.py\ and \check\_outdated\_deps.py\ validate that declared minimum dependency versions are compatible with the codebase and report outdated packages, respectively. \verify\_pyi.py\ ensures that built distributions include generated type stubs, while \make\_pyi.py\ and \hatch\_build.py\ handle the generation and integration of \.pyi\ files during the build process. Additionally, \bun\_install.sh\ and \install.ps1\ provide cross-platform installation scripts for the Bun runtime, and \wait\_for\_listening\_port.py\ replaces shell-based port-waiting logic with a Python implementation for better cross-platform compatibility in integration tests.

scripts · high confidence

The core Reflex library has been reorganized into a new \reflex-base\ package, introducing foundational utilities such as responsive breakpoint management, a new \RegistrationContext\ for state and event handler registration, and a \TelemetryContext\ for tracking compile-time usage. This update also adds built-in OpenTelemetry instrumentation for tracing and metrics, allowing developers to monitor event durations and WebSocket activity, alongside enhanced configuration options for database URLs, frontend compression, and color modes.

_packages/reflex-base/src/reflex\base · high confidence

The Accordion and Tabs components, along with their associated sub-components (AccordionButton, AccordionItem, AccordionPanel, AccordionIcon, Tab, TabList, TabPanels, TabPanel), have been removed from the pynecone.components.disclosure module. This deletion eliminates the ability to use these specific UI elements for creating expandable lists and tabbed interfaces within the application.

pynecone/components/disclosure · high confidence

The HydrateMiddleware and LoggingMiddleware classes have been removed from the application. This eliminates the automatic formatting of state dictionaries during the initial hydration phase and stops the printing of event and delta logs to the console, changing how the application handles initial state setup and request/response visibility.

pynecone/middleware · high confidence

The Plotly graphing component has been removed from the library. Users can no longer import or use the \Plotly\ class from \pynecone.components.graphing\ to display Plotly charts, as the underlying module and its exports have been deleted.

pynecone/components/graphing · high confidence

The base \Component\ class, which previously defined core properties like \children\, \style\, \event\_triggers\, and \key\, along with methods for initializing props and creating event chains, has been removed from the \pynecone/components/component.py\ file. This deletion eliminates the foundational class that all Pynecone components inherited from, fundamentally altering how component structure and event handling are defined in the library.

pynecone/components · high confidence

The \pynecone\ package has removed its core implementation files, including the main application class (\app.py\), state management (\state.py\), variable definitions (\var.py\), event handling (\event.py\), database models (\model.py\), and the CLI entry point (\pc.py\). This deletion eliminates the previous framework runtime, configuration constants, and component libraries (such as Chakra-UI wrappers), effectively stripping the package of its ability to run or compile Pynecone applications.

pynecone · high confidence

The legacy Pynecone template files have been removed from the project. This includes the Python tutorial application code, the Next.js configuration, the custom 404 page, the Chakra UI provider setup in \_app.js, and the frontend state management utilities (state.js). These changes indicate a shift away from the previous Pynecone-based template structure.

pynecone/.templates · high confidence

The \pynecone/components/base\ module has been removed, deleting the legacy wrapper components for standard HTML elements including \Body\, \Head\, \Title\, \Link\, and Next.js-specific document components (\Html\, \DocumentHead\, \Main\, \Script\). This cleanup eliminates the intermediate abstraction layer that previously mapped these elements to their underlying tags, simplifying the component structure.

pynecone/components/base · high confidence

The \pynecone/components/datadisplay\ and \pynecone/components/transitions\ modules have been removed. This deletes the legacy implementations for data display components (including \Badge\, \Code\, \CodeBlock\, \DataTable\, \Divider\, \List\, \Stat\, and \Table\ variants) and transition components (\Fade\, \ScaleFade\, \Slide\, \SlideFade\, \Observer\, \VisibilitySensor\). Users relying on these specific classes from these paths will need to update their imports or migrate to the new high-level API structure.

pynecone/components/datadisplay · high confidence

The \pynecone/components/feedback\ module has been removed, deleting the source files for \Alert\, \CircularProgress\, \Progress\, \Skeleton\, and \Spinner\ components. This change eliminates the previous Chakra-based implementations of these UI elements, indicating a structural shift in how feedback and loading states are provided to users.

pynecone/components/feedback, pynecone/components/media · high confidence

The \pynecone/components/forms\ directory has been removed, deleting the module-level exports and individual component implementations for core form elements including Button, Checkbox, Input, Select, Radio, Slider, and TextArea. This change eliminates the previous component definitions from the public API, indicating a structural shift in how these form controls are provided or organized within the library.

pynecone/components/forms · high confidence

The \pynecone.components.layout\ module and all its constituent files (including Box, Center, Cond, Container, Flex, Foreach, Grid, Spacer, Stack, and Wrap) have been deleted. This change removes the previous implementation of these layout components, indicating a structural shift in how layout functionality is provided within the framework.

pynecone/components/layout · high confidence

The navigation module has been completely removed, deleting the \Breadcrumb\, \Link\, \LinkOverlay\, \LinkBox\, and \NextLink\ components along with their public exports. This eliminates the previous Chakra-based link implementation and the Next.js-specific link wrapper, effectively removing these navigation primitives from the library.

pynecone/components/navigation · high confidence

The \CondTag\, \IterTag\, and \Tag\ classes in \pynecone/components/tags\ have been removed. This eliminates the internal components responsible for rendering conditional logic, iteration loops, and base React tags, indicating a shift in how the framework handles component serialization and DOM generation.

pynecone/components/tags · high confidence

The overlay component module has been removed, deleting the Python class definitions and exports for AlertDialog, Drawer, Menu, Modal, Popover, and Tooltip. Users can no longer import or use these specific UI components from the \pynecone.components.overlay\ package.

pynecone/components/overlay · high confidence

The \pynecone.compiler\ package has been completely removed from the codebase. This deletion eliminates the legacy logic responsible for compiling Pynecone applications, including the generation of document roots, themes, and React components, as well as the associated template definitions and utility functions for import and state compilation. Users relying on this specific compiler implementation will no longer have access to these internal compilation steps.

pynecone/compiler · high confidence

The \pynecone.components.typography\ module has been completely removed, deleting the \Heading\, \Markdown\, \Highlight\, and \Text\ components as well as the \span\ helper function. Users can no longer import these specific typography elements from this package location.

pynecone/components/typography · high confidence

The compiler package has been reorganized: the main logic is now consolidated in a new \reflex/compiler/compiler.py\ file, while \templates.py\ and \utils.py\ serve as thin wrappers that re-export their implementations from the \reflex\_base\ library. This shift centralizes the core compilation pipeline and template utilities in the shared \reflex\_base\ package, reducing duplication in the main Reflex codebase.

reflex/compiler · high confidence

The compiler's single-pass page compilation logic has been moved out of the App class and restructured into an extensible plugin system located in reflex/compiler/plugins. This change introduces built-in plugins for evaluating pages (DefaultPagePlugin), applying app-level styles (ApplyStylePlugin), and collecting imports (DefaultCollectorPlugin). Additionally, a new MemoizeStatefulPlugin automatically wraps stateful components with memo definitions to optimize rendering, replacing the previous StatefulComponent wrapping pass and ensuring that reactive data and hooks are properly isolated within memoized subtrees.

reflex/compiler/plugins · high confidence

The compiler's template generation logic (templates.py) and the main compiler package initialization (\_\init\\_.py) have been relocated to the reflex-base package. This change centralizes the code responsible for rendering React components, handling hooks, and generating the default rxconfig template within the base package, establishing the foundation for the compiler's output structure.

_packages/reflex-base/src/reflex\base/compiler · high confidence

The reflex.components package has been refactored to serve as a compatibility layer and import redirector rather than holding implementation code directly. Most submodules (component, dynamic, field, literals, memo, props) now simply re-export from reflex\base.components, while the main \\init\\_.py installs a sys.meta\_path hook to transparently redirect imports of specific subpackages (like radix, recharts, or datadisplay) to their respective standalone packages (e.g., reflex\_components\_radix). This change ensures that existing import paths continue to work while the underlying component logic is centralized in reflex\_base or split into separate distribution packages.

reflex/components · high confidence

The \reflex/constants\ module has been refactored to serve as a re-export layer for constants defined in the \reflex\_base\ package. Individual modules (such as \base\, \colors\, \compiler\, \config\, \event\, \installer\, \route\, \state\, and \utils\) now simply import and re-export their respective symbols from \reflex\_base\, centralizing the source of truth for these configuration values and reducing duplication within the main repository.

reflex/constants · high confidence

The core component definitions, field infrastructure, and memoization helpers have been moved into the new reflex-base package. This change introduces a shared field system (BaseField, FieldBasedMeta) for components and props, restructures the memoization logic into dedicated modules (memo.py, memoize\_helpers.py), and adds new app-wrap collection utilities (app\_wraps.py) to handle provider injection. It also includes a dynamic component loader (dynamic.py) with deprecation shims for moved globals and a state context provider (state\_context.py) for mounting React state providers.

_packages/reflex-base/src/reflex\base/components · high confidence

The internal state management system has been reorganized into a dedicated \reflex.istate\ package, introducing new modules for handling state proxies, shared/linked states, client-side storage (cookies, localStorage, sessionStorage), router data structures, and validation. This change provides a clearer separation of concerns for state mutability control, linked state synchronization, and client-side persistence, while exposing a \get\_state()\ utility to retrieve state instances by token.

reflex/istate · high confidence

The Reflex framework has been reorganized from a single monolithic package into a modular architecture using separate packages (e.g., \reflex\_base\, \reflex\_components\_core\, \reflex\_components\_radix\). The main \reflex\ package now uses \lazy\_loader\ to dynamically import components and utilities, significantly reducing startup and import times. This change introduces new top-level namespaces like \rx.radix\ and \rx.lucide\, while maintaining backward compatibility through re-exports and aliases. The \App\ class and core functionality have been moved to \reflex\_base\, with the main package serving as a unified entry point that exposes all necessary classes and functions through lazy-loaded modules.

reflex · high confidence

The \reflex/vars\ package has been refactored to serve as a thin re-export layer for the new \reflex\_base.vars\ module. All specific var types (base, color, datetime, dep\tracking, function, number, object, sequence) and the main \\\init\\_\ now simply import and expose the implementations from \reflex\_base\, effectively moving the core var system logic out of this package while maintaining the public API surface for consumers.

reflex/vars · high confidence

Code-copy buttons now have an accessible name and are prevented from submitting enclosing forms, improving usability for keyboard and screen-reader users.

packages/reflex-components-code/news · high confidence

This update introduces a new Recharts Sankey chart wrapper (rx.recharts.sankey\_chart) that supports custom node and link renderers, along with a new utility rx.recharts.use\_chart\_width() to read the rendered chart width as a Var. Additionally, it fixes a bug where Recharts component props (such as stroke\_dasharray on reference\_line or tick\_formatter on axes) were incorrectly being routed to wrapperStyle instead of reaching the underlying Recharts component.

packages/reflex-components-recharts/news · high confidence

Web sessions now automatically reconcile the runtime environment on startup by upgrading the \uv\ tool to the required version, installing a stable Python interpreter, and fetching git tags to ensure correct version resolution. Additionally, a new \prerelease-test\ skill has been added to support release QA campaigns, providing structured guidance and scripts for end-to-end testing of published packages, upgrade regressions, and packaging audits.

.claude · high confidence

The data editor now ensures that image previews within cells include the necessary carousel styles required by Glide Data Grid, improving the visual presentation of image data.

packages/reflex-components-dataeditor/news · medium confidence

Resolves an issue where the \action\ and \cancel\ buttons within \rx.toast\ notifications failed to trigger their \on\_click\ events when the toast was initiated from a frontend event. This ensures that user interactions with toast buttons now correctly execute their associated click handlers.

packages/reflex-components-sonner/news · high confidence

The \rx.form.message\ component no longer passes the \force\_match\ attribute to the DOM when the \match\ property is not set, preventing unintended attribute leakage. Additionally, internal \\_render\ method overrides are now annotated to return \CommonTag\, establishing it as the base type for all tag classes.

packages/reflex-components-radix/news · high confidence

The app's lifespan management and middleware handling have been moved from the main App class into separate \LifespanMixin\ and \MiddlewareMixin\ classes within the new \reflex.app\_mixins\ package. This refactoring isolates these concerns, making the core app structure cleaner and allowing these features to be composed more flexibly. The \LifespanMixin\ now handles task registration and cleanup, while \MiddlewareMixin\ manages the pre- and post-processing of events.

_reflex/app\mixins · high confidence

The Markdown component in reflex-components-markdown now inherits from MemoizationLeaf instead of the standard Component base. This behavioral change ensures that Var children are kept inlined rather than being re-evaluated or detached, which fixes issues where dynamic content within markdown was not rendering correctly or was losing its reactive binding.

packages/reflex-components-markdown/src · high confidence

This release addresses several issues and optimizes performance across the framework. Stability is improved by fixing route matching for \frontend\_path\ prefixes, ensuring \@rx.memo\ components correctly inherit app wraps, preventing state var shadowing of internal methods, and keeping the dev backend socket open during hot reloads. Performance gains include faster compilation by reading only necessary props, reduced dev-mode memory usage through deferred imports and optimized bundling, and deduplication of uncached computed var deltas to minimize network traffic. Compatibility and usability are enhanced by allowing State Vars in page metadata, fixing local package specifier parsing, cleaning up lockfiles when switching package managers, and providing clearer error messages for missing database extras or shadowed inherited vars.

news · high confidence

The event processing logic has been restructured into a new \reflex\_base.event.processor\ module, introducing a dedicated \EventProcessor\ class that manages a backend event queue, middleware execution, and graceful shutdown. This change enhances event chaining by tracking hierarchical futures, allowing callers to wait for entire chains of events to complete and preventing \RecursionError\ in deep self-chaining handlers. It also ensures that chained events correctly inherit the originating event's \router\_data\ and that superseding events are cancelled in the correct order based on their root generation. Additionally, the processor now includes compatibility shims for \asyncio.as\_completed\ and \QueueShutDown\ to ensure stable operation on Python 3.13 and later versions.

_packages/reflex-base/src/reflex\base/event/processor · high confidence

The Reflex Radix components package now uses an opt-in \RadixThemesPlugin\ to manage the Radix UI CSS bundle and app-level theme wrapper. Users must explicitly configure the plugin in \rxconfig.py\ to enable Radix Themes; previously, using Radix components implicitly loaded the full CSS bundle, which now triggers a deprecation warning. The plugin handles bundling the \@radix-ui/themes\ package and injecting the theme component into the app wrapper when enabled.

_packages/reflex-components-radix/src/reflex\_components\radix · high confidence

The Lucide icon component now emits deep, per-icon imports (e.g., from specific module paths like \/dist/esm/icons/wifi-off.mjs\) instead of importing the entire \lucide-react\ library. This change prevents the full library from being pulled into the module graph when static icons are used, significantly reducing the bundle size and avoiding unnecessary network requests for unused icon assets.

packages/reflex-components-lucide/src · high confidence

The reflex.plugins package now acts as a compatibility layer that re-exports core plugin types, contexts, and specific implementations (such as Tailwind V3/V4, Sitemap, Screenshot, and Embed plugins) from the newly separated reflex\_base.plugins module. This change centralizes the plugin API surface in reflex\_base while maintaining backward compatibility for existing imports, effectively decoupling the plugin definitions from the main reflex package structure.

reflex/plugins · high confidence

The middleware system has been refactored to use an asynchronous interface, with \preprocess\ and \postprocess\ methods now defined as \async\ and operating on \StateUpdate\ objects instead of raw \Delta\ types. A new \HydrateMiddleware\ has been added to handle initial app hydration, which resets client storage and explicitly sets the \is\_hydrated\ state variable to \False\ before resolving the initial state delta. Additionally, the middleware module has been renamed from \pynecone\ to \reflex\, and the \LoggingMiddleware\ has been removed from the public exports.

reflex/middleware · high confidence

The \reflex/utils\ module has been restructured to re-export core utilities (console, format, imports, decorator, exceptions) from the \reflex\_base\ package, centralizing shared logic. Additionally, the CLI now supports explicit \--loglevel\ and \--json\ options, allowing users to control log verbosity and output format directly from the command line.

reflex/utils · high confidence

The state management system has been restructured into a modular design with a unified abstract base class (StateManager) and distinct implementations for in-memory, disk, and Redis backends. This change introduces a new token-based identity system (StateToken) to replace legacy string tokens, enabling better type safety and support for state linking and sharing. Users benefit from improved reliability through isolated locking mechanisms, configurable token and lock expiration times, and background tasks for purging expired states. The refactoring also ensures that explicitly supplied states are persisted correctly in disk mode and that substates are properly refetched when missing, resolving previous race conditions and data consistency issues.

reflex/istate/manager · high confidence

The datadisplay module has been cleaned up to remove dead lazy exports, now only exposing the 'logo' submodule. Additionally, a new Reflex logo component has been added, providing an SVG-based logo that supports color mode conditions and can be used to display a 'Built with Reflex' badge linking to the official site.

_packages/reflex-components-core/src/reflex\_components\core/datadisplay · high confidence

The hosting CLI now blocks all v1 hosting commands (login, logout, deploy, and deployment management) with an error message stating the alpha hosting service was decommissioned on December 5, 2024, and requires upgrading to reflex\>=0.6.6.post1. A new v2 CLI structure has been introduced, including a new Config dataclass for managing deployment settings (regions, VM types, hostnames, environment variables), a comprehensive logging system that integrates with reflex-base when available or falls back to rich console output, and utility modules for dependency checking, archive uploads, and token validation. The CLI now supports machine-readable JSON output via the --json flag and non-interactive mode for agent usage.

packages/reflex-hosting-cli/src · high confidence

This release improves error visibility by re-raising AttributeErrors in cached var computations as ReflexRuntimeError, fixes silent data loss in var hashing, and resolves RecursionError in deep self-chaining event handlers. Performance is enhanced through lazy loading of optional integrations (pandas, Plotly, Pillow), native PEP 810 support on Python 3.15, and optimized compilation paths. Additional fixes include preserving rxconfig dependencies on reload, ensuring OpenTelemetry spans are flushed during dev compilation, and correcting client-side event routing for queued callbacks.

packages/reflex-base/news · high confidence

The reflex-base utilities package has been restructured into a comprehensive set of modules covering core functionality. This includes a new standard-library logging pipeline (log.py) that replaces legacy console helpers, a lazy loader supporting Python 3.15+ native lazy imports (PEP 810), and a deterministic hashing system for stable component and variable naming. Additional utilities now handle import merging and normalization, type serialization for optional dependencies (pandas, PIL, plotly, sqlmodel), compatibility shims for Python 3.14+ annotation handling, and various decorators for caching and execution control. The module also introduces a suite of custom exceptions for better error reporting and format helpers for string manipulation.

_packages/reflex-base/src/reflex\base/utils · high confidence

The tag-related component classes (including cond, iter, match, tag, and tagless) are now re-exported from the \reflex\_base\ package rather than being defined locally. This change centralizes the tag implementation in \reflex\_base\ and updates the \reflex/components/tags\ module to simply re-export those definitions, ensuring consistency and reducing duplication in the codebase.

reflex/components/tags · high confidence

The custom component creation and management commands have been migrated from the Typer library to Click, providing a more stable CLI foundation. Additionally, the system now dynamically resolves the current Reflex version when generating the pyproject.toml template for new custom components, ensuring that the generated package correctly depends on the installed Reflex version rather than a hardcoded or default value.

_reflex/custom\components · high confidence

The \_render method overrides in the Reflex components are now annotated to return CommonTag, which serves as the new base class for all tag classes. This change standardizes the return type for rendering logic across the component hierarchy.

packages/reflex-components-markdown/news · medium confidence

This release addresses several specific issues: \rx.el.svg\ and its children now render as a single memoized component to ensure that \defs\ (like gradients) and their ID references share the same render scope; the default error boundary fallback no longer logs invalid DOM property warnings for its SVG icon; the 'Built with Reflex' badge now has an accessible name when its visual text is hidden on small screens; and upload requests referencing unknown event handlers now return a controlled 400 response instead of potentially failing silently or incorrectly.

packages/reflex-components-core/news · high confidence

The \id\ prop passed to \rx.plotly\ is now correctly forwarded to the underlying react-plotly.js library as \divId\, ensuring the element's ID is present in the rendered DOM. This resolves the issue where the ID was previously ignored, allowing for proper DOM targeting and styling.

packages/reflex-components-plotly/news · high confidence

Add comprehensive benchmark suite for Reflex performance tracking; Add unit tests for cross-module memo collision handling; Added integration test infrastructure for Reflex init and export workflows; Added regression tests for the pyi\_generator; Added shared test utility for Reflex state; Added static type-checking tests for reflex.vars and field defaults; Added tests for Form on\_submit behavior and TypedDict validation; Added tests for Moment component locale isolation; Added tests for dynamic component bundling and event trigger memoization; Added tests for template JSON helper and Safari cache-busting plugin; Added unit tests for Lucide icon component behavior and imports; Added unit tests for Markdown component compilation and memoization; Added unit tests for Plotly and Recharts graphing components; Added unit tests for Radix UI components; Added unit tests for Recharts components and style handling; Added unit tests for SVG element components; Added unit tests for asset handling and shared asset concurrency; Added unit tests for base component rendering logic; Added unit tests for component rendering, memoization, and props; Added unit tests for custom component pyi generation; Added unit tests for data display components; Added unit tests for embed, sitemap, and Tailwind plugins; Added unit tests for internal Reflex components and utilities; Added unit tests for internal state management, proxying, and URL parsing; Added unit tests for reflex\_base constants and frontend toolchain version constraints; Added unit tests for reflex\_base.utils; Added unit tests for shared site components and plugins; Added unit tests for state field metadata preservation and hook-backed variable generation; Added unit tests for state mutation and file upload handling; Added unit tests for the LifespanMixin behavior; Added unit tests for the Markdown component; Added unit tests for the Sticky Badge and Data Display lazy exports; Added unit tests for the new iState manager subsystem; Added unit tests for the public\_url utility; Added unit tests for the reflex hosting CLI; Added unit tests for the reflex-build-sdk async client; Added unit tests for the reflex-docgen documentation generation system; Added unit tests for the reflex-release package; Added unit tests for the reflex\_base event processing subsystem; Added unit tests for vars module; Compiler test suite expansion; New Playwright integration tests for core Reflex features; New integration test suite for Reflex applications; Removed tests for legacy Tag and CondTag components; Reorganized test suite and added Node version integration test; Unit tests added for the hosting CLI v2 commands.

The Reflex project has replaced its Python packaging infrastructure, moving from Poetry to Hatchling with uv-dynamic-versioning for build and versioning, and adopting uv as the primary dependency resolver. This change updates the root pyproject.toml and all sub-package manifests (reflex-base, reflex-components-\*, reflex-hosting-cli, reflex-docgen, reflex-otel, reflex-release, etc.) to use the new \[project\] standard format, enforces a minimum Python 3.10 requirement, and introduces a hatch-reflex-pyi build hook to automatically generate .pyi stubs for component packages. The migration also updates dependency constraints across the ecosystem (e.g., httpx \>=0.25.1, starlette \>=0.47.0, rich \>=13,\<16) and removes the legacy pynecone template web dependencies.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 65.

• Code Health 64
• Architecture 98
• Maturity 64
• Readiness 61
• Security 73
• Accessibility 80

• 300 commits — 217 feature/other, 83 fixes

• packages/reflex-base — 86 commits
• docs/app — 24 commits
• tests/units — 19 commits
• packages/reflex-hosting-cli — 18 commits
• packages/reflex-site-shared — 13 commits
• packages/reflex-release — 12 commits
• (root) — 11 commits
• packages/reflex-sdk — 9 commits
• docs/library — 8 commits
• docs/enterprise — 7 commits
• packages/reflex-components-core — 7 commits
• packages/reflex-components-internal — 7 commits
• docs/ai_builder — 5 commits
• reflex/utils — 4 commits
• tests/integration — 4 commits
• packages/reflex-components-moment — 3 commits
• packages/reflex-components-radix — 3 commits
• packages/reflex-components-recharts — 3 commits
• docs/api-reference — 2 commits
• docs/database — 2 commits

• fix: Fix Python 3.14 event handler annotation resolution (#6896)
• fix: ENG-12228: Fix Safari cache-busting plugin to handle React Router 8 Uint8Array chunks (#7048)
• fix: ENG-9661 fix: cancel stale on_load chains via handler-declared supersession (#6713)
• fix: ENG-9676 fix: route memo RestProp CSS props into css instead of dropping them (#6605)
• fix: ENG-9859 fix(state): preserve source function dict and kwdefaults in _copy… (#6725)
• fix: ENG-9860 fix(vars): preserve custom Field attributes in state metaclass (#6726)
• fix: Event processor fix (#6801)
• fix: Fix Agent Toolkit sidebar alignment and spacing (#7195)
• fix: Fix IPv6 availability detection in process port tests (#7027)
• fix: Fix OpenTelemetry spans lost during dev compilation (#7155)
• fix: Fix RecursionError in event processor for deep self-chaining handlers (#7145)
• fix: Fix ReflexEvent argument order for client_handler_name in format_event (#7156)
• fix: Fix Var hashing to prevent silent data loss and enable hashability (#7015)
• fix: Fix Vite config plugin imports and add resolveId hook filter (#6959)
• fix: Fix _get_all_hooks_internal mutating the shared per-node hooks cache (#6741)
• fix: Fix backend-only compile marker cleanup (#7125)
• fix: Fix build config to exclude sibling packages from distributions (#6966)
• fix: Fix build failure when frontend_path is set without prerendering (#7044)
• fix: Fix demo_form_dialog to omit trigger when not provided (#6940)
• fix: Fix docs 'Edit this page' link to target the page's real source file (#7043)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

reflex-dev/reflex was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.