Skip to content
CAI
Software that uses CAICheck a score

getredash/redash

42.7

Weak · 16 November 2026

64.3k

lines of production code

JavaScript

with Python, TypeScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add request and database query metrics collection

The application now collects performance metrics for HTTP requests and database queries, sending timing data to StatsD. For requests, it tracks the total duration, the number of queries executed, and the cumulative duration of those queries, reporting them per endpoint and HTTP method. For the database layer, it instruments SQLAlchemy to measure the duration of individual SELECT, INSERT, UPDATE, and DELETE operations, identifying the target table name where possible. These metrics are logged and exposed via StatsD for monitoring.

redash/metrics · high confidence

Added flash toggle icon support

The application now includes font assets and styles for 'flash' and 'flash-off' icons, enabling UI components to visually indicate the state of flash settings. This change adds the necessary SVG glyphs, Less variables, and CSS classes to support this specific icon set.

client/app/redash-font · high confidence

Added support for multi-select actions in item lists

Introduced the useItemsListExtraActions hook, which enables users to select multiple items within a list via a new checkbox column. This hook manages the selection state, provides utilities to toggle individual or all items, and conditionally renders an extra actions component when actions are available, allowing for batch operations on the selected items.

client/app/components/items-list/hooks · high confidence

Dashboards and Dashboard List pages migrated to React

The Dashboards list and individual Dashboard view pages have been rewritten in React. The Dashboard List now features a sidebar with filters for All, My, and Favorites dashboards, supports tag filtering, and includes a 'New Dashboard' action button. The Dashboard Page supports global parameters, dashboard-level filters, and an interactive grid for widgets, with layout editing capabilities. Public dashboards are also rendered via a new React component, maintaining parameter and filter support while displaying a branded footer.

client/app/pages/dashboards · high confidence

Introduce Databricks Schema Browser for query editing

Adds a new Databricks-specific schema browser component to the query editor, allowing users to browse databases and tables, filter schema items, and select tables for their queries. The feature includes a custom hook to manage data fetching from the Databricks data source, handles database selection with local storage persistence, and provides UI controls for refreshing schema data and expanding table details.

client/app/components/queries/editor-components/databricks · high confidence

Introduce EmptyState component with onboarding steps

The application now includes a new EmptyState component that displays contextual guidance and onboarding steps when content is missing. Users will see a structured list of actions—such as connecting a data source, creating queries, setting up alerts, dashboards, or inviting team members—tailored to their role (e.g., admins see direct links, while non-admins see instructions to ask an admin). The component supports customization via props for icons, illustrations, and help messages, and includes a closable interface with accessibility improvements.

client/app/components/empty-state · high confidence

Introduce dynamic date and date range parameter options

Users can now select predefined dynamic time ranges (such as 'Last 7 days', 'This month', 'Last 12 months', and 'Last 10 years') directly within Date and Date Range parameters via a new DynamicButton dropdown. This change adds new components (DateParameter, DateRangeParameter, DynamicButton, DynamicDatePicker, DynamicDateRangePicker) and associated styles to support these dynamic selections alongside static values, enhancing the flexibility of time-based filtering.

client/app/components/dynamic-parameters · high confidence

Introduce modular authentication system with SAML, LDAP, and JWT support

The authentication logic in the \redash/authentication\ package has been restructured into distinct modules, introducing dedicated handlers for SAML (\saml\_auth.py\), LDAP (\ldap\_auth.py\), Google OAuth (\google\_oauth.py\), JWT (\jwt\_auth.py\), and remote user authentication (\remote\_user\auth.py\). This change adds support for SAML-based single sign-on (including static configuration and encryption), LDAP directory integration, and JWT token validation (allowing public keys to be loaded from file paths or URLs). It also centralizes account management features like email verification, password resets, and user invitations in \account.py\, while providing a unified entry point in \\\init\\_.py\ to route requests to the appropriate authentication backend based on configuration.

redash/authentication · high confidence

Introduce new alert destinations: Asana, ChatWork, Datadog, Discord, Hangouts Chat, and Webex

This change adds support for six new alert destinations, allowing users to route Redash alert notifications to Asana, ChatWork, Datadog, Discord, Google Hangouts Chat, and Webex. Each destination is implemented as a new module in the \redash/destinations\ package, registering with the central \BaseDestination\ framework to handle configuration, icon display, and notification dispatch via their respective APIs.

redash/destinations · high confidence

Introduce new query runners and refactor base runner configuration

This change adds several new data source integrations including ArangoDB, Axibase TSD, Azure Data Explorer (Kusto), Cassandra/ScyllaDB, ClickHouse, CloudWatch, and CloudWatch Logs Insights, alongside updates to existing runners like Amazon Elasticsearch Service and BigQuery. It also refactors the base query runner infrastructure by introducing a new \BaseSQLQueryRunner\ class, standardizing column type definitions, and updating the configuration schema handling to support more flexible and secure data source setups.

_redash/query\runner · high confidence

Introduce reusable PageHeader component

A new PageHeader component has been added to the application, providing a consistent layout for page titles and action buttons. This component renders a title heading alongside an optional actions area, allowing list pages to display new Dashboard, Query, or Alert buttons in a standardized manner.

client/app/components/PageHeader · high confidence

Introduction of a default policy service for client-side permissions

A new DefaultPolicy class has been added to the client application to centralize permission checks for creating data sources, destinations, dashboards, alerts, users, and query snippets. This service exposes methods such as canCreateDataSource, canCreateDashboard, and canEdit, which enforce rules based on user roles (e.g., admin status) or specific permissions like 'create\_dashboard'. The policy module also provides configuration access for dashboard and query refresh intervals and includes a mechanism to swap the active policy implementation via a setPolicy function, allowing for flexible policy management within the client.

client/app/services/policy · high confidence

Migrate Alert Destinations management to React

The Alert Destinations pages (list, create, and edit) have been rewritten in React, replacing the previous implementation. Users can now view, create, and manage alert destinations using the new \DestinationsList\ and \EditDestination\ components, which integrate with the dynamic form system and the new routing infrastructure.

client/app/pages/destinations · high confidence

Migrate Query Snippets list to React

The Query Snippets management interface has been rewritten in React, replacing the previous implementation. This change introduces a new list view featuring a sortable table with columns for trigger, description, snippet content, author, and creation date, along with pagination controls. Users can now create, edit, and delete snippets via a modal dialog, with access control enforced to allow only admins or the snippet's creator to modify entries. The UI also includes a 'New Query Snippet' button and a 'Click here' link for empty states, both utilizing a shared PlainButton component for consistent styling and accessibility.

client/app/pages/query-snippets · high confidence

Migrate Users pages to React

The Users list and User Profile pages have been rewritten in React, replacing the previous implementation. The Users List now uses the new ItemsList component architecture with Ant Design UI elements, introducing separate navigation tabs for Active Users, Pending Invitations, and Disabled Users. The User Profile page is now a React component that dynamically renders either an editable or read-only view based on permissions, and includes a warning banner for email settings. Supporting changes include a new \useUserGroups\ hook for managing group data and dedicated LESS styles for the profile layout.

client/app/pages/users · high confidence

New Paginator utility for client-side data sorting and paging

A new \Paginator\ class has been added to \client/app/lib/pagination\ to handle client-side row slicing and column-based sorting. This utility allows consumers to manage pagination state (current page, items per page) and sort data by specific fields, leveraging lodash for the sorting logic.

client/app/lib/pagination · high confidence

New React component library for client-side UI

The client/app/components directory now contains a comprehensive set of new React components, including AceEditorInput, BeaconConsent, BigMessage, CodeBlock, Collapse, CreateSourceDialog, DateInput, DateRangeInput, DateTimeInput, DateTimeRangeInput, DialogWrapper, DynamicComponent, EditInPlace, EditParameterSettingsDialog, EmailSettingsWarning, FavoritesControl, Filters, HelpTrigger, and InputWithCopy. These components replace previous implementations or introduce new UI capabilities, such as a standardized dialog wrapper, dynamic component registration, and specific input controls for dates and code editing, all built using the Ant Design library.

client/app/components · high confidence

New React-based list UI components

The items-list components have been migrated to React, introducing new sub-components for rendering list states: EmptyState displays a 'Sorry, we couldn't find anything' message, LoadingState shows a spinner, ItemsTable provides a sortable, filterable table with support for custom columns (favorites, avatars, dates, time-ago) and row-click handling, and Sidebar includes search input, menu navigation, and tag filtering capabilities.

client/app/components/items-list/components · high confidence

New authentication settings components for password, Google, and SAML login

The AuthSettings area now includes dedicated UI components for configuring password login, Google login domains, and SAML authentication (both static and dynamic modes). These components are integrated into the main AuthSettings entry point, allowing administrators to manage these specific authentication methods through a unified settings interface.

client/app/pages/settings/components/AuthSettings · high confidence

New dashboard header and sharing controls

This change introduces a new DashboardHeader component that consolidates the dashboard title, tags, and action buttons (including refresh, edit, fork, archive, and permissions) into a sticky header bar. It also adds a ShareDashboardDialog component that allows users to enable or disable public access for dashboards, displaying a secret URL when active and preventing sharing for dashboards containing unsafe text parameters. Additionally, a DashboardListEmptyState component is added to handle empty states for different dashboard list views (favorites, my dashboards, etc.).

client/app/pages/dashboards/components · high confidence

New dashboard management hooks introduced

This change introduces a set of new React hooks in the client/app/pages/dashboards/hooks directory to centralize dashboard logic. useDashboard handles core state, parameter persistence, widget loading, and permission checks. useEditModeHandler manages layout editing, debounced saving of widget positions, and save status. useRefreshRateHandler controls automatic dashboard refreshing based on URL parameters and policy limits. useDuplicateDashboard enables forking dashboards in new tabs while preserving URL context. useDataSources provides a list of available data sources. These hooks replace inline logic with reusable, testable components for dashboard interaction.

client/app/pages/dashboards/hooks · high confidence

New email templates for alerts, failures, and account management

This change introduces a new set of HTML and text email templates for Redash, including layouts for alerts, query failure reports, user invitations, password resets (including disabled account notifications), and email verification. Users will now receive these newly formatted emails for system notifications and account actions.

redash/templates/emails · high confidence

New password management UI components for user profiles

Added a new PasswordForm component and its sub-components (ChangePasswordDialog, PasswordResetForm, ResendInvitationForm, PasswordLinkAlert) to the user profile page. This introduces a modal dialog for users to change their own passwords, and administrative controls to either send password reset emails or resend invitations for other users, including a fallback alert for when the mail server is not configured.

client/app/pages/users/components/PasswordForm · high confidence

New reusable React hooks for common UI patterns

Added five new custom hooks to the client library to standardize and simplify common React patterns: useFullscreenHandler manages fullscreen state and URL parameters; useImmutableCallback ensures stable callback references for dependency arrays; useLazyRef defers initial value computation; useSearchResults handles debounced search fetching with loading states and cleanup; and useUniqueId generates unique IDs with a prefix using lazy initialization.

client/app/lib/hooks · high confidence

New utility libraries for accessibility, formatting, and state management

This change introduces several new helper modules in the client library to improve code organization and functionality. It adds \accessibility.ts\ for screen-reader notifications, \calculateTextWidth.ts\ for precise text measurement, and \localOptions.js\ for structured local storage access. It also includes \queryFormat.ts\ (with tests) to format SQL and JSON queries, \useQueryResultData.js\ to memoize query result extraction, and an expanded \utils.js\ with helpers for time formatting, duration humanization, and number/size formatting.

client/app/lib · high confidence

Redash 26.10.0-dev application initialization and monitoring infrastructure

This change introduces the core application bootstrap and monitoring capabilities for Redash version 26.10.0-dev. The application now initializes with explicit support for remote debugging via debugpy, configurable logging (including stdout output and suppression of noisy libraries), and specific sqlparse grouping limits to prevent performance issues. Security is enforced through Flask-Talisman (handling HTTPS, HSTS, CSP, and frame options) and CSRF protection, with configurable cookie settings. The system integrates RQ for task queuing, exposing detailed worker and queue status metrics via the monitor module, which reports Redis usage, database sizes, and object counts. Additionally, a version check mechanism is implemented to notify users of new releases and optionally report aggregated usage statistics to Redash.

redash · high confidence

Redash utility library initialization and configuration

This change introduces the \redash/utils\ package, establishing the foundational utility layer for the application. It adds a custom JSON encoder and serializer that safely handles Python-specific types (such as \datetime\, \UUID\, and \Decimal\) and sanitizes invalid JSON values like \NaN\ and \Infinity\. The package also provides a \ConfigurationContainer\ for managing and validating data source settings with support for secret masking, a \UnicodeWriter\ for CSV exports with configurable encoding, and a \ConfiguredSession\ for HTTP requests that enforces security settings like redirect blocking. Additionally, it initializes Sentry error tracking with specific integrations and filters, and includes helpers for query hashing and human-readable time parsing.

redash/utils · high confidence

Release of @redash/viz as a standalone visualization library

The visualization components previously embedded in the main application are now distributed as a standalone npm package (@redash/viz). This change allows external projects to install and render Redash visualizations (such as Charts, Tables, and Maps) independently using React and Antd. The library is built with TypeScript and Webpack v5, exposing both a bundled UMD build and transpiled source files for specific imports, enabling developers to integrate Redash's visualization engine into their own applications.

viz-lib · high confidence

Visualization editor components migrated to TypeScript

The visualization editor UI components in viz-lib/src have been rewritten in TypeScript, introducing a new ColorPicker, TextAlignmentSelect, JsonViewInteractive, and Sortable components alongside updated editor controls (Switch, TextArea, Section, ContextHelp). This migration provides stricter type safety and improved developer experience for building and customizing chart configurations.

viz-lib/src/visualizations · high confidence

Removals

Removal of legacy AngularJS UI templates

The legacy AngularJS view templates for the admin status page, dashboard management, query editing (QueryFiddle), and query listing have been removed from the application. This deletion indicates that these user-facing interfaces have been fully migrated to a different frontend implementation, and the old AngularJS-based rendering logic is no longer served or used.

_rd\ui/app/views · high confidence

Removal of legacy AngularJS application shell and assets

The legacy \rd\_ui/app\ directory, which served as the root for the previous AngularJS-based web interface, has been completely removed. This deletion eliminates the old HTML templates (including \index.html\ and \404.html\), the CoffeeScript build ignore rules, and the associated frontend dependencies such as Highcharts, jQuery, and AngularJS libraries that were previously loaded via Bower. Users will no longer interact with this deprecated frontend layer.

_rd\ui/app · high confidence

Removal of legacy Redash CSS styles

The \rd\_ui/app/styles/redash.css\ file has been deleted, removing global styles for the navbar, avatar, edit-in-place components, growl notifications, Gridster widgets, and the CodeMirror editor. This cleanup eliminates styling for components that have been migrated or replaced in the frontend, ensuring the UI no longer relies on these obsolete CSS rules.

_rd\ui/app/styles · high confidence

Removal of legacy UI components and dependencies

The application removes several legacy frontend components and libraries, including the admin status controller, the 'Query Fiddle' interface, the smart-table grid directive, and the Highcharts charting library. This change eliminates the corresponding JavaScript files and their associated routes, effectively deprecating the old admin status view, the query editing interface, the tabbed table grid, and the Highcharts-based charting capabilities.

_rd\ui/app/scripts · high confidence

Removal of legacy dashboard and notification services

The legacy \Dashboard\ and \notifications\ services in the UI scripts have been removed. This cleanup eliminates the old client-side logic for dashboard edit permissions and HTML5 desktop notifications, which has been migrated to the frontend or is no longer required, reducing technical debt in the application's service layer.

_rd\ui/app/scripts/services · high confidence

Removal of legacy data management and worker components

The \rd\_service/data\ module has been completely removed, deleting the legacy \Manager\, \Worker\, and \Job\ classes, the Django-based \models.py\, the \query\_runner.py\ implementation, and the \tables.sql\ schema definitions. This change eliminates the previous threading-based connection pooling and synchronous job execution architecture from this location.

_rd\service/data · high confidence

Removal of legacy query fiddle renderers

The \renderers.js\ file containing the \chartRenderer\, \gridRenderer\, and \pivotTableRenderer\ directives has been deleted from the \query\_fiddle\ module. This removes the legacy AngularJS-based visualization components that previously handled chart, grid, and pivot table rendering within the query fiddle interface.

_rd\_ui/app/scripts/query\fiddle · high confidence

Removal of legacy rd\_service Python backend

The \rd\_service\ directory, which contained the original Python/Tornado-based web server, CLI worker, and configuration examples, has been completely removed. This eliminates the legacy backend implementation, including its authentication handlers, query execution logic, and dashboard management endpoints, from the product.

_rd\service · high confidence

Architecture

Refactor handlers into a modular package structure

The application's request handling logic has been reorganized from a monolithic structure into a dedicated \redash.handlers\ package. This change introduces a new \routes\ blueprint and a centralized \api\ registry in \\_\init\\_.py\, while splitting specific resource logic into distinct modules for alerts, authentication, dashboards, data sources, Databricks, destinations, embeds, events, favorites, groups, and more. This modularization improves code maintainability and separation of concerns without altering the external API surface or user-facing behavior.

redash/handlers · high confidence

Behavioural changes

1 commit (0 fixes) modifying website

A change to existing behaviour in website — 1 commit, 395 files: “Move redash.io (marketing site and docs) into this repo, hosted on Cloudflare (\#7892)” (refs \#7892).

client/cypress, website · medium confidence · unverified

7 commits (0 fixes) modifying viz-lib/src/components/visualizations

A change to existing behaviour in viz-lib/src/components/visualizations — 7 commits, 14 files: “Allow the X and Y tick format to be customized using a D3 format string (\#6370)”; “Update frontend stack (\#7651)”; “Replace ESLint and Prettier with Biome (\#7854)”; and 4 more (refs \#6370, \#7651, \#7854, \#5436, \#5310, …).

(repo-wide) · medium confidence · unverified

8 commits (1 fix) modifying client/visual-tests

A change to existing behaviour in client/visual-tests — 8 commits (1 fix), 139 files: “Replace the Cypress end-to-end tests with Playwright (\#7885)”; “Upgrade React to 18 (\#7862)”; “Upgrade antd from 4.4.3 to 4.24.16 (\#7861)”; and 5 more (refs \#7885, \#7862, \#7861, \#7857, \#7858, …).

client/e2e, client/visual-tests · medium confidence · unverified

Admin interface migrated to React components

The admin section's user interface has been rewritten in React, introducing new components for layout, status display, and job monitoring. The new Layout.jsx provides a horizontal navigation menu for System Status, RQ Status, and Outdated Queries. RQStatus.jsx implements tables for viewing workers, queues, and query jobs with pagination and status badges. StatusBlock.jsx renders cards for general system info, database metrics, and manager details. This change replaces the previous implementation with a modern React-based structure using Ant Design components.

client/app/components/admin · high confidence

Admin pages migrated to React with RQ job status and system status views

The Admin section now uses React components for the Jobs, Outdated Queries, and System Status pages. The Jobs page displays real-time RQ (Redis Queue) status, including counters for started and queued jobs, and tabs for Queues, Workers, Queries, and Other Jobs, with data auto-refreshing every 60 seconds. The Outdated Queries page lists queries that need updating, supporting auto-refresh and pagination. The System Status page aggregates general system info, manager metrics, queue details, and database metrics, also refreshing periodically. All pages use the new admin Layout and register their own routes.

client/app/pages/admin · high confidence

Alert management interface migrated to React

The alert creation, editing, viewing, and management interface has been rewritten in React, replacing the previous implementation. This change introduces a redesigned user experience for the alert page, including new components for configuring alert criteria, notification templates, and query selection, as well as improved state management for alert status and permissions.

client/app/pages/alert · high confidence

Alert page migrated to React with redesigned components

The alert configuration interface has been rewritten in React, replacing the previous implementation with a suite of new components including AlertDestinations for managing notification channels, Criteria for defining threshold logic (with support for min/max/first selectors), NotificationTemplate for custom alert messaging, and MenuButton for actions like muting and evaluation. This migration introduces a redesigned user experience with improved accessibility, consistent styling via Ant Design v4, and new capabilities such as alert muting and manual evaluation.

client/app/pages/alert/components · high confidence

Alerts list page migrated to React

The Alerts list page has been rewritten in React, replacing the previous implementation. This change introduces a modern UI with sortable columns for alert status, name, creator, state, and timestamps, along with pagination and an empty state help message. The page now uses the new Link component for navigation and integrates with the ItemsList framework for data fetching and state management, while respecting user permissions to show the 'New Alert' button.

client/app/pages/alerts · high confidence

Application shell, offline detection, and unsupported browser handling

The client application now initializes via a new React entry point that renders the main application area and immediately starts an offline listener to detect network status. The HTML shell includes a loading indicator and an async script that redirects users to a dedicated unsupported browser page if they are using Internet Explorer. Additionally, a version.json file is introduced to expose the current application version.

client/app · high confidence

CardsList component migrated to TypeScript with visual card styling

The CardsList component has been rewritten in TypeScript and updated to use a new 'visual-card' layout. This change introduces a styled card interface with hover and focus effects, responsive sizing for various screen widths, and an optional search filter. The component now handles items with either an href or an onClick handler, rendering them as links or buttons respectively.

client/app/components/cards-list · high confidence

Centralized app configuration and initialization logic

The application's initialization process has been consolidated into a new \client/app/config/index.js\ entry point. This change introduces a standardized setup flow that registers visualizations, loads page routes, configures internationalization time strings via Moment.js, and dynamically loads frontend extensions. Additionally, it establishes a global Ant Design spinner indicator for consistent loading states and ensures all image assets are properly bundled and available.

client/app/config · high confidence

Data Sources management pages migrated to React

The Data Sources list and edit pages have been rewritten in React, replacing the previous implementation. Users can now view, create, edit, and delete data sources through the new React-based components, which utilize the DynamicForm for configuration and integrate with the updated routing system.

client/app/pages/data-sources · high confidence

Database schema modernization and structural updates

This update applies a series of database migrations to improve data integrity and performance. Key changes include migrating JSON columns to the more efficient JSONB type across tables like queries, dashboards, and widgets, and re-indexing the full-text search vector for queries. The schema also introduces a 12-column grid layout for dashboards (scaling existing widget positions), adds a default alert selector, and consolidates user profile image URLs into a JSON details column. Additionally, query hash generation is updated to be case-insensitive and aware of query parameters, and data source options are encrypted for security.

migrations/versions · high confidence

Extract query page logic into reusable React hooks

The query editing interface now uses a collection of dedicated React hooks (located in \client/app/pages/queries/hooks\) to manage specific behaviors, replacing previous inline implementations. These hooks encapsulate logic for query execution and state (\useQueryExecute\, \useQuery\), parameter management (\useQueryParameters\, \useAddNewParameterDialog\), visualization handling (\useAddVisualizationDialog\, \useEditVisualizationDialog\, \useDeleteVisualization\), and query lifecycle actions like saving, archiving, forking, and scheduling. This change centralizes the complex state and side-effect management required for the query editor into modular, reusable components.

client/app/pages/queries/hooks · high confidence

Favorites list now sorts by most recently starred

The FavoritesList component on the Home page now fetches and displays favorite dashboards and queries sorted by the 'starred\_at' timestamp in descending order. This ensures that the most recently added favorites appear at the top of the list, improving discoverability for users who frequently update their starred items.

client/app/pages/home/components · high confidence

Home page migrated to React

The Home page has been rewritten as a React component, replacing the previous implementation. This change introduces a new layout that displays alerts for deprecated embed features and unverified email addresses, utilizes a DynamicComponent system for the main empty state and extra content, and includes a favorites list for dashboards and queries. The page is now registered via a dedicated route definition within the React application structure.

client/app/pages/home · high confidence

Introduce structured serialization for queries, dashboards, and query results

The application now uses a dedicated serializers module to handle data conversion for API responses, replacing ad-hoc \to\_dict\ methods. This change centralizes how queries, visualizations, widgets, and dashboards are serialized, ensuring consistent field inclusion (such as favorite state and user details) and improving separation of concerns. It also introduces robust serialization for query results, including correct handling of boolean and date/time values in CSV/TSV exports and proper formatting for XLSX downloads, while restricting sensitive query information in public dashboard views.

redash/serializers · high confidence

Introduces a structured Parameter inheritance model with new dynamic date range presets

The parameter service layer has been refactored to use a class-based inheritance structure, introducing a base Parameter class and specific subclasses (DateParameter, DateRangeParameter, EnumParameter, NumberParameter, TextParameter, TextPatternParameter, and QueryBasedDropdownParameter) to handle type-specific normalization, URL serialization, and execution value generation. This change adds a new TextPattern parameter type that validates input against a regular expression, and significantly expands the DateRangeParameter with a comprehensive set of dynamic presets including 'Last 12 months', 'Last 2 years', 'Last 3 years', and 'Last 10 years' (in addition to existing options like 'Today', 'Yesterday', and 'Last 7 days'). The refactoring also ensures consistent handling of multi-value options for Enum and Query-based dropdowns and standardizes how parameters persist and apply saved values across the dashboard.

client/app/services/parameters · high confidence

Introduces data-source-specific query editor components

The query editor now supports distinct UI components for different data sources. A new registry system allows registering specific implementations (such as a Databricks Schema Browser) that override the default components for targeted data source types like 'databricks' and 'databricks\_internal', while falling back to the standard SchemaBrowser and QueryEditor for other sources.

client/app/components/queries/editor-components · high confidence

Items list component now debounces search to prevent concurrent requests

The ItemsList component in the client app now wraps the search update function with a debounce mechanism (200ms) and a concurrency guard. This ensures that rapid search inputs do not trigger multiple simultaneous API requests; instead, only the most recent search term is processed, improving performance and reducing server load during fast typing.

client/app/components/items-list · high confidence

Migrate DynamicForm component to React

The DynamicForm component and its supporting field types (Input, Select, Checkbox, File, AceEditor, etc.) have been rewritten in React, replacing the previous Angular implementation. This migration introduces new behaviors for handling form data, including normalizing empty values to null on submission, correctly applying default values to checkboxes, and managing the visibility of extra fields via a prop. The component now leverages Ant Design's Form API for validation and state management, ensuring consistent styling and interaction patterns across the application.

client/app/components/dynamic-form · high confidence

Migrate Group List and Details pages to React

The Groups List, Group Members, and Group Data Sources pages have been rewritten in React, replacing the previous implementation. This change introduces a consistent UI using Ant Design components (such as Buttons, Dropdowns, and Menus) and leverages the shared ItemsList, Paginator, and PreviewCard components for table rendering and pagination. Administrators can now manage group members and data sources through these new React-based interfaces, which include features like adding/removing members and data sources, setting data source permissions (Full Access vs. View Only), and deleting groups, all integrated with the new routing and settings tab system.

client/app/pages/groups · high confidence

Migrate Group management UI to React

The Group List and Details pages have been migrated from the previous framework to React. This change introduces new React components for managing groups, including CreateGroupDialog for adding new groups, DeleteGroupButton for safe deletion with confirmation, DetailsPageSidebar for group actions (adding members/data sources, deleting), GroupName for inline editing of group names, and ListItemAddon for visual indicators in list items. The migration also updates the underlying service layer to use axios instead of $http and improves accessibility for input fields and icons.

client/app/components/groups · high confidence

Migrate Organization Settings to React

The Organization Settings page has been rewritten in React, replacing the previous implementation. This change introduces a new \OrganizationSettings\ component that uses the \useOrganizationSettings\ hook to manage state, fetch data via \OrgSettings.get()\, and save changes via \OrgSettings.save()\. The UI now utilizes Ant Design components (Form, Button, Skeleton) for a consistent look and feel, including loading states. The settings are registered as a new route at \/settings/general\ with admin permissions, and saving updates the client configuration for date and time formats.

client/app/pages/settings · high confidence

Migrate Queries List page to React

The Queries List page has been rewritten in React, introducing a new layout with a left sidebar containing search, navigation filters (All, My, Favorites, Archived), and tag filtering. The list now displays query details including name, tags, creator, creation date, last execution time, and schedule, with support for server-side pagination and sorting. A dedicated empty state component provides context-specific messages for different views (e.g., prompting to create a query in 'My Queries' or explaining favorites).

client/app/pages/queries-list · high confidence

Migrate Query Pages to React

The Query Source and Query View pages have been rewritten in React, replacing the previous implementation. This change introduces a new component structure with dedicated hooks for managing query execution, data sources, parameters, and visualizations, along with updated styling for the query editor and results layout.

client/app/pages/queries · high confidence

Migrate Redash models to SQLAlchemy with Redis-backed user activity tracking

The application models have been rewritten to use SQLAlchemy, introducing a new database layer in \redash/models\ that includes custom types for encrypted configuration, mutable JSON/JSONB fields, and generic foreign keys. A key behavioral change is the shift in tracking user activity: the \active\_at\ timestamp is now updated via Redis hashes and synced to the database, rather than being written directly on every request. Additionally, user profile image URLs are now stored within the \details\ JSONB field and accessed via a cast property, and the \User\ model now exposes \is\_email\_verified\ and \is\_invitation\_pending\ states derived from that same field.

redash/models · high confidence

Migrate client services from Angular to React with Axios and DOMPurify

The client application services in \client/app/services\ have been rewritten from Angular-style dependencies to a modern React-compatible architecture. HTTP communication now uses Axios instead of the legacy \$http\ service, featuring automatic CSRF token handling and session refresh interceptors. Security is improved by replacing \angular-sanitize\ with DOMPurify, which now explicitly allows the \target\ attribute on links while adding \rel="noopener noreferrer"\ to prevent reverse tabnabbing. The codebase also introduces a new \KeyboardShortcuts\ service for global key bindings, a \Location\ service for URL management, and a \Notification\ service wrapping Ant Design components, while adding unit tests for the authentication and query result logic.

client/app/services · high confidence

Migrate dashboard widgets and dialogs to React

The dashboard editing experience has been rebuilt using React, replacing the previous Angular-based implementation. This change introduces new React components for core dashboard interactions, including the Add Widget dialog (featuring query and visualization selection with parameter mapping), the Create Dashboard dialog, the Textbox editor (with live Markdown preview), and the Parameter Mappings editor. The dashboard grid itself is now a React component powered by react-grid-layout, supporting responsive layouts, widget resizing, and an AutoHeightController for dynamic widget sizing. These updates provide a more consistent UI, improved performance through React's rendering model, and better maintainability for future dashboard features.

client/app/components/dashboards · high confidence

Migrate dashboard widgets to React

The dashboard widget components (VisualizationWidget, TextboxWidget, RestrictedWidget, and the base Widget wrapper) have been rewritten in React. This migration introduces a consistent component structure with dedicated header and footer sections, supports editing text boxes via a modal dialog, and provides visualization widgets with parameter handling, query viewing, and download options (CSV, TSV, Excel). The new implementation also includes a restricted widget state for data sources without access and improves accessibility with proper ARIA labels and focus styles.

client/app/components/dashboards/dashboard-widget · high confidence

Migrate database migrations to Alembic

The project has switched its database migration tooling from the previous system to Alembic (via Flask-Migrate). This introduces a new \migrations/\ directory containing the standard Alembic configuration (\alembic.ini\), environment setup (\env.py\), and migration script templates (\script.py.mako\). Additionally, a warning script (\0001\_warning.py\) has been added to alert users who attempt to use the outdated Fabric upgrade script, ensuring they adopt the new migration process.

migrations · high confidence

Migrate query execution from Celery to RQ

The query execution engine has been migrated from Celery to Redis Queue (RQ). This change introduces new task modules for query execution and maintenance, updates the job enqueueing logic to use RQ queues and job statuses, and adds support for RQ-specific features like job timeouts and ghost lock cleanup. Users will experience query execution handled by the new RQ backend, which may affect job status reporting and error handling for scheduled and ad-hoc queries.

redash/tasks/queries · high confidence

The Add to Dashboard, Embed Query, and Schedule dialogs in the queries area have been rewritten from their previous implementations into React components. This migration introduces a consistent dialog wrapper pattern, integrates Ant Design v4 UI primitives (such as Modal, Select, and DatePicker), and adds specific capabilities like UTC time display in the Schedule dialog, configurable iframe sizing in the Embed dialog, and dashboard search functionality in the Add to Dashboard dialog.

client/app/components/queries · high confidence

Migrate tags control components to React

The tags control UI has been rewritten in React, introducing the \TagsControl\ component for displaying tags and the \EditTagsDialog\ for managing them. This change adds a new 'Add tag' button when no tags are present, improves accessibility by using \PlainButton\ and screen-reader-only text for the edit action, and ensures the tag selection input receives focus once available tags are loaded. It also introduces specific variants (\QueryTagsControl\ and \DashboardTagsControl\) that display 'Unpublished' or 'Archived' status labels with appropriate tooltips.

client/app/components/tags-control · high confidence

Migration from Celery to RQ for task execution

Redash replaces the Celery task queue with RQ (Redis Queue) for handling background jobs. This change introduces a new task infrastructure in \redash/tasks\, including custom RQ worker and queue classes that enforce hard time limits to prevent stuck jobs, integrate with Statsd for metrics, and support job cancellation. The migration updates core scheduled tasks—such as query execution, alert checking, schema refreshing, and failure reporting—to use RQ decorators and scheduling mechanisms, ensuring consistent timeout enforcement and improved reliability for background operations.

redash/tasks · high confidence

Modularized signed-out layout with extension points

The signed-out page layout has been refactored to be more modular by introducing new include files (signed\_out\_tail.html and tail.html). This change allows frontend elements to be overridden via extension points, enabling custom themes or integrations to inject content into the signed-out view without modifying core templates.

_redash/templates/\includes · medium confidence

New Docker entrypoint, release automation, and environment loading scripts

This change introduces three new scripts in the bin directory. The new docker-entrypoint script replaces previous Celery-based infrastructure with RQ (Redis Queue) for worker and scheduler tasks, adds configurable Gunicorn settings (bind address, timeout, worker count, max requests), supports remote debugging via debugpy, and provides a unified interface for running server, worker, scheduler, and test commands within the container. A new release script automates the CalVer versioning process, changelog generation, and GitHub release creation for both major and patch releases. Additionally, a shell wrapper script ensures environment variables from .env files are correctly sourced before executing container commands.

bin · high confidence

New General Settings UI with configurable formatting and feature flags

The General Settings page now includes dedicated sections for Date/Time formatting (synced with client configuration), number formatting (customizable thousands and decimal separators), Plotly chart visualization options, and Feature Flags (including experimental multiple owners support, email notifications for failed scheduled queries, and multi-byte search). It also reintroduces a Beacon Consent setting for anonymous usage data sharing, all wrapped in a DynamicComponent architecture for extensibility.

client/app/pages/settings/components/GeneralSettings · high confidence

New React components for query control dropdown and visualization editing

This change introduces three new React components within the EditVisualizationButton directory: QueryControlDropdown, QueryResultsLink, and EditVisualizationButton. The QueryControlDropdown provides a menu for users to add queries to dashboards, embed results elsewhere (subject to public URL settings), and download query results in CSV, TSV, or Excel formats via the new QueryResultsLink component. The EditVisualizationButton component renders a button to open the visualization editor. These components replace previous implementations, leveraging Ant Design for UI elements and a custom Link component for file downloads.

client/app/components/EditVisualizationButton · high confidence

New React-based client-side router and error handling system

The ApplicationArea now uses a new React-based Router component that manages client-side navigation using UniversalRouter, replacing the previous implementation. This change introduces a dedicated ErrorMessage component to display user-friendly messages for HTTP errors (such as 404 and 401/403) and unhandled JavaScript errors, ensuring a consistent error experience. The routing logic now supports dynamic route registration and includes a handleNavigationIntent utility to intercept standard link clicks for single-page application navigation. Additionally, route wrappers like routeWithUserSession and routeWithApiKeySession have been updated to integrate with this new router structure, providing session management and error boundary context to route components.

client/app/components/ApplicationArea · high confidence

New content-with-sidebar layout component for list pages

A new \ContentWithSidebar\ layout component and its associated styles have been added to the application. This component structures pages with a 25% width sidebar on the left and a 75% width content area on the right, switching to a stacked vertical layout on screens narrower than 990px. This change supports the reorganization of list pages by moving the sidebar to the left side of the content area.

client/app/components/layouts · high confidence

New left-aligned horizontal form styling and helpers

A new styling class and corresponding TypeScript helper functions have been added to support horizontal forms with left-aligned labels. The \.ant-form-horizontal--labels-left\ class ensures labels are left-aligned and removes the default colon suffix, while the \getHorizontalFormProps\ and \getHorizontalFormItemWithoutLabelProps\ functions provide pre-configured Ant Design form props to apply this layout consistently.

client/app/styles · high confidence

New signed-out layout template introduced

A new layout template for the signed-out state has been added to the application. This template defines the structure for pages displayed when a user is not authenticated, including the HTML head with viewport and compatibility meta tags, links to the main stylesheet and favicons, and a body structure that centers content. It includes a header section with the Redash logo and an optional title, a content block for page-specific content, and a scripts block for footer assets, ensuring a consistent look and feel for sign-out related pages.

redash/templates/layouts · high confidence

Redash v26.9.0 release with security fixes and new data sources

This release addresses 13 security advisories, including preventing SQL injection via query annotations, restricting API key access to declared dependencies, and disabling custom JavaScript visualizations by default. It introduces a new Cloudflare D1 data source, configurable number formatting, and automatic query limits for Trino. The frontend build tooling has migrated from Yarn to pnpm with Node.js 24, and Python dependency management has shifted from Poetry to uv.

(repo-wide) · high confidence

Redesign of the login page layout and styling

The login page has been restyled with a new two-column layout for larger screens, where the logo container and content area are floated side-by-side, and a single-column stacked layout for smaller viewports. The page background is now white, and the logo container uses a specific grey-blue color (\#668899).

client/app/assets · high confidence

Redesigned Query Editor with Auto-Limit and Autocomplete Controls

The Query Editor component has been refactored to include a new control bar featuring an 'Auto Limit' checkbox that restricts query results to the first 1,000 rows, and a toggle for enabling or disabling live autocomplete. The editor now supports schema-aware autocompletion for tables and columns, and includes improved keyboard shortcut handling and accessibility notifications for screen readers.

client/app/components/queries/QueryEditor · high confidence

Redesigned authentication and account management pages

The login, invite, password reset, forgot password, email verification, and initial setup screens have been redesigned with a new tiled UI layout. These pages now support multiple SSO providers (Google, SAML, Remote User, LDAP) with dedicated login buttons on the login and invite pages, and all forms include CSRF protection. The setup wizard now includes options to subscribe to security notifications and a newsletter.

redash/templates · high confidence

Redesigned navigation with vertical desktop sidebar and mobile top bar

The application layout now features a redesigned navigation system: desktop users see a vertical sidebar (DesktopNavbar) with icons and labels, while mobile users see a compact top bar with a hamburger menu (MobileNavbar). This change introduces new components (DesktopNavbar, MobileNavbar, VersionInfo) and styles to support the new layout, including specific handling for headless mode to hide navigation elements.

client/app/components/ApplicationArea/ApplicationLayout · high confidence

Redesigned query page with new metadata, status, and visualization components

The query page interface has been redesigned to improve usability and visual consistency. A new header component now manages the query title, tags, and action menu (including publish, archive, and fork options) with improved mobile responsiveness. Execution status and metadata are now displayed in dedicated components that clearly show row counts, runtime, data scanned, and truncation warnings, while providing a prominent cancel button during processing. Visualization management has been enhanced with a tabbed interface that supports adding, deleting, and switching between multiple visualizations, and preserves filter selections across tabs. Additionally, new alert components guide users when no data sources are available or when they lack permissions to create queries.

client/app/pages/queries/components · high confidence

Redesigns the management CLI with Click and modular command groups

The Redash management script has been rewritten to use the Click library instead of the previous Flask-script manager, providing a more robust and consistent command-line interface. The CLI is now organized into distinct subcommands for managing users, groups, data sources, organizations, queries, and RQ workers, allowing administrators to perform operations like creating root users, managing data source connections, and monitoring worker health directly from the terminal.

redash/cli · high confidence

Refactored User Profile page with new component structure

The User Profile page has been restructured into distinct, reusable components: EditableUserProfile and ReadOnlyUserProfile handle the main layout and display logic, while specific forms (UserInfoForm, ApiKeyForm, PasswordForm, ToggleUserForm) manage their respective sections. This change introduces a new CreateUserDialog for creating users and adds a test for the ReadOnlyUserProfile component. Users will see the same profile editing and viewing capabilities, but the underlying implementation is now more modular, supporting extension points via DynamicComponent for future customizations.

client/app/pages/users/components · high confidence

Refined ItemsList base component with new data-fetching classes

The ItemsList component's underlying data-fetching logic has been restructured into a set of dedicated classes (ItemsFetcher, ItemsSource, Paginator, Sorter, StateStorage). This change introduces a more modular approach to handling list data, supporting both client-side sorting/pagination for plain lists and server-side pagination for paginated lists. It also adds URL state synchronization, allowing search terms, sorting, and pagination state to be reflected in the browser's URL bar, improving shareability and browser history support for list views.

client/app/components/items-list/classes · high confidence

Removal of legacy Grunt-based build and Bower dependency infrastructure

The rd\_ui directory has removed its legacy build and dependency management files, including Gruntfile.js, bower.json, .bowerrc, and associated test configurations (karma.conf.js, karma-e2e.conf.js). This change eliminates the Bower-managed frontend dependency tree (Angular, Bootstrap, Highcharts, etc.) and the Grunt-based asset compilation pipeline, indicating a migration away from this specific build stack.

_rd\ui · high confidence

Settings restructured into a package with new organization-level configuration options

The settings module has been refactored from a single file into a package (\redash/settings\) containing \\_\init\\_.py\, \helpers.py\, \organization.py\, and \dynamic\_settings.py\. This change introduces organization-level settings in \organization.py\ that allow users to configure date/time formats, number formatting (thousands/decimal separators), and visibility options such as hiding the Plotly mode bar, disabling public URLs, and enabling multi-byte search. It also adds support for JWT authentication, custom query result persistence, SSH tunnel authentication, and dynamic query time limits. Security improvements include enforcing HTTPS, configuring Content Security Policy and HSTS headers, and securing session cookies. The refactoring also removes deprecated SAML local metadata support and introduces environment variables for controlling Redis decode responses and database connection pooling.

redash/settings · high confidence

Updated Amazon RDS and Redshift CA bundles for SSL connectivity

The bundled CA certificates used for verifying SSL connections to Amazon RDS and Redshift have been updated. The new \rds-combined-ca-bundle.pem\ includes recent Amazon RDS root and regional CAs (such as af-south-1, eu-south-1, and me-south-1), ensuring continued trust for newer RDS instances. Additionally, the \redshift-ca-bundle.crt\ has been refreshed to include the latest Amazon Root CAs (1-4) and Starfield certificates, resolving potential SSL handshake failures for Redshift connections that rely on these updated trust anchors.

_redash/query\runner/files · high confidence

Visualization editor and renderer refactored with configurable settings and filter handling

The visualization editing experience has been restructured to improve stability and configurability. A new EditVisualizationDialog component now manages the editor state, utilizing memoized query result data to prevent unnecessary re-renders and ensuring that selected filters are preserved when switching between visualizations. The underlying renderer and editor components are now wrapped to inject global client configuration, such as date/number formatting and custom map data for Choropleth charts, directly into the visualization library. Additionally, the renderer now correctly combines local and global filters, ensuring that filter selections persist and update correctly as query results or global filter contexts change.

client/app/components/visualizations · high confidence

Fixes

Added empty extensions directory to fix build failure

An empty 'extensions' directory has been added to the client application to resolve a webpack build failure that occurred when the directory was missing. This ensures the build process can locate the expected path for extensions.

client/app/extensions · high confidence

Test coverage

5 commits adding/updating tests in tests/utils; Added model unit tests for alerts, queries, and data sources; Added snapshot test for ReadOnlyUserProfile component; Added test infrastructure for Enzyme and date mocking; Added tests for query result and DSV serialization; Added tests for task execution, scheduling, and metrics; Added unit tests for query runners; Initial test coverage for backend API handlers; Initial test suite infrastructure and coverage; Removed legacy test infrastructure files.

Dependencies

Migrate build tooling to pnpm and modernize frontend dependencies

The frontend build system has switched from npm to pnpm (v10.30.3), requiring Node.js 20–25. This update upgrades the frontend stack to React 16.14.0, Ant Design 4.4.3, Webpack 5, and Babel 7.29, while adding Playwright for visual testing and use-debounce for performance. The legacy rd\_ui Grunt build and rd\_service requirements have been removed.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 42 → 43 (+0.3)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 69 → 65 (-3.8)
  • Architecture 54 → 54 (+0.0)
  • Maturity 62 → 63 (+1.5)
  • Readiness 32 → 33 (+0.7)
  • Security 63 → 63 (-0.0)
  • Domain Modelling 55 → 55 (+0.0)
  • Accessibility 43 → 43 (-0.4)
  • Performance 85 → 100 (+15.0)

Resolved (85)

  • Duplicated block (10 lines × 2) (redash/query_runner/db2.py)
  • Duplicated block (7 lines × 4) (redash/query_runner/db2.py)
  • Duplicated block (9 lines × 2) (migrations/versions/7205816877ec_change_type_of_json_fields_from_varchar_.py)
  • Duplicated block (9 lines × 2) (redash/query_runner/cloudwatch.py)
  • High secret: WD-SECRET-0005 (package-lock.json)
  • High secret: WD-SECRET-0005 (viz-lib/package-lock.json)
  • Leaked secret: high-entropy-secret (.ci/compose.e2e.yaml)
  • Leaked secret: signing-key (.ci/compose.e2e.yaml)
  • Medium CVE: [GHSA redacted] (pnpm-lock.yaml)
  • No ADRs found
  • Off-boarding risk: anonymized user #1
  • Orphaned file (client/app/components/ApplicationArea/routeWithUserSession.tsx)
  • Orphaned file (client/app/components/TagsList.tsx)
  • Orphaned file (client/app/components/cards-list/CardsList.tsx)
  • Orphaned file (migrations/versions/7205816877ec_change_type_of_json_fields_from_varchar_.py)
  • Orphaned file (redash/destinations/datadog.py)
  • Orphaned file (redash/destinations/microsoft_teams_webhook.py)
  • Orphaned file (redash/destinations/webex.py)
  • Orphaned file (redash/models/organizations.py)
  • Orphaned file (redash/models/types.py)
  • …and 65 more

New (49)

  • Duplicated block (10 lines × 2) (redash/query_runner/db2.py)
  • Edited copies of one member (3 members, 20+ corresponding lines) (redash/query_runner/phoenix.py)
  • Edited copies of one member (3 members, 24+ corresponding lines) (redash/query_runner/databend.py)
  • Edited copies of one member (3 members, 37+ corresponding lines) (redash/handlers/dashboards.py)
  • Edited copies of one member (3 members, 9+ corresponding lines) (redash/query_runner/google_analytics4.py)
  • Edited copy of a member (10 corresponding lines) (migrations/versions/5ec5c84ba61e_.py)
  • Edited copy of a member (10 corresponding lines) (redash/cli/users.py)
  • Edited copy of a member (10 corresponding lines) (redash/handlers/widgets.py)
  • Edited copy of a member (10 corresponding lines) (redash/query_runner/corporate_memory.py)
  • Edited copy of a member (11 corresponding lines) (redash/handlers/queries.py)
  • Edited copy of a member (12 corresponding lines) (redash/cli/data_sources.py)
  • Edited copy of a member (12 corresponding lines) (redash/handlers/dashboards.py)
  • Edited copy of a member (12 corresponding lines) (redash/models/init.py)
  • Edited copy of a member (12 corresponding lines) (redash/query_runner/google_analytics4.py)
  • Edited copy of a member (13 corresponding lines) (redash/query_runner/yandex_disk.py)
  • Edited copy of a member (14 corresponding lines) (redash/query_runner/pg.py)
  • Edited copy of a member (15 corresponding lines) (redash/handlers/favorites.py)
  • Edited copy of a member (15 corresponding lines) (redash/handlers/groups.py)
  • Edited copy of a member (15 corresponding lines) (redash/query_runner/snowflake.py)
  • Edited copy of a member (2 corresponding lines) (redash/query_runner/big_query.py)
  • …and 29 more

Changes since last survey

  • 3 commits — 1 feature/other, 2 fixes

By area

  • (root) — 1 commit
  • client/app — 1 commit
  • redash/handlers — 1 commit

Notable commits

  • fix: Fix 500 when creating a text widget without visualization_id (#7796)
  • fix: fix: preserve query and dashboard tag filters in URLs (#7905)
  • change: devops: submit e2e tests to Flakiness dashboard (#7907)

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

getredash/redash 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.

About this page

  • The score is its most recent published measurement, taken on 16 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit f561a53dc55eeb3f20615be951560dc78bb23f4c — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.73+preprod-52de90b74216.