Axe Core

axe-core is an automated accessibility testing engine and compliance auditor designed to scan web and mobile interfaces for violations of industry accessibility standards. It functions as a programmatic scanner and linter that analyzes HTML and source code to identify barriers and verify compliance with accessibility guidelines.

The project distinguishes itself by combining a DOM-based rule engine with computer vision and machine learning to detect complex violations that evade traditional analysis, such as visual heading discrepancies and informative images. It provides specialized capabilities for analyzing custom components, verifying text contrast via screenshots, and detecting missing focus indicators.

The system covers a broad range of capabilities including real-time accessibility linting in code editors, automated gating within CI/CD pipelines, and guided manual testing for non-experts. It also supports accessibility monitoring through centralized reporting, commit-linked result tracking, and programmatic integration with project management tools.

Features

Accessibility Testing - Provides a programmatic engine for automating accessibility testing within CI/CD pipelines and UI test suites.

UI Accessibility Scanning - Scans web pages and interface code to detect accessibility violations and generate detailed remediation reports.

Accessibility Linting - Performs static analysis on source code to identify accessibility barriers before the code is compiled.

Compliance Gating - Integrates accessibility checks into CI/CD pipelines to prevent code with accessibility violations from being merged.

Accessibility Linters - Provides a programmatic linter that detects accessibility violations in real time within code editors and CI/CD pipelines.

Accessibility - Executes automated accessibility tests from the CLI to validate complex user flows and responsive layouts.

CI/CD Integrations - Executes automated accessibility checks via command-line tools and GitHub Actions within CI/CD pipelines.

IDE Accessibility Linters - Provides real-time accessibility linting directly within code editors to catch violations during the authoring process.

CI/CD Pipeline Integrations - Automates accessibility auditing within deployment pipelines to prevent the release of non-compliant code.

CI CD Pipelines - Triggers automated accessibility audits during pull requests to prevent regressions in the codebase.

Just-in-Time Access - Marks accessibility violations directly in the editor to ensure immediate correction of patterns that block users.

GitHub Actions - Uses GitHub Actions to automatically trigger accessibility checks upon the creation of pull requests.

Rule Execution Engines - Implements a rule execution engine that validates the current browser DOM against accessibility standards.

Accessibility Data Aggregators - Aggregates accessibility scan data from multiple platforms into a centralized monitoring dashboard.

Accessibility Regression Tracking - Links accessibility results to Git commits to evaluate the impact of changes and monitor project health.

Accessibility Compliance Verifiers - Aggregates scan results and links accessibility violations to version control to track remediation progress over time.

Accessibility Scan Reports - Generates detailed reports and diagnostic data resulting from automated accessibility scans.

Guided Testing Workflows - Walks users through complex testing scenarios with step-by-step instructions to ensure compliance.

Accessibility Auditing - Verifies that web interfaces comply with industry accessibility standards and semantic HTML requirements.

Browser-Based Accessibility Auditing - Scans web pages for accessibility defects directly through the browser's developer tools.

Mobile Accessibility Auditing - Analyzes user interfaces built with various mobile frameworks to identify accessibility violations across platforms.

Accessibility Auditors - Programmatically inspects web and mobile interfaces to verify compliance with accessibility guidelines and success criteria.

Accessibility Scanners - Ships a programmatic scanner that integrates into end-to-end test suites to find interface barriers across browsers.

iOS - Analyzes iOS applications on physical devices or emulators to detect accessibility violations.

Accessibility Integrations - Wraps end-to-end test methods to automatically validate web pages for accessibility violations with minimal code changes.

CLI Test Runners - Provides a command-line interface to script page loads and user interactions for automated accessibility testing.

Accessibility Pipeline Integrations - Integrates accessibility auditing into CI/CD pipelines, GitHub Actions, or Git pre-commit hooks to block defects before they reach production.

Accessibility Remediation Tools - Produces AI-powered instructions and code fixes to resolve identified accessibility compliance issues.

Image Content Analyzers - Analyzes image content using AI to identify missing alternative text and flag informative images.

Web-Based Computer Vision - Employs web-based computer vision to identify accessibility barriers like missing semantic headings from visual appearance.

Vision Analysis - Uses vision analysis to detect visual headings and color contrast issues that are not visible in the DOM.

AI Integration - Integrates artificial intelligence to enhance accessibility detection and manage AI data sharing preferences.

Collaboration and Sharing - Distributes accessibility test records and issue groups among collaborators to coordinate remediation.

Issue Tracking - Centralizes results from automated test runs and scans to track and resolve accessibility violations.

Regression Tracking - Associates accessibility violations with version control commit hashes to monitor regressions and track remediation.

Jira Connectors - Integrates with Jira to export accessibility violations as trackable issues for development teams.

Analysis Result Exporters - Outputs accessibility test results using a standardized JSON schema for interoperability between auditing tools.

Scan Data Importers - Connects automated scanning projects to a reporting system to import and centralize accessibility information.

CLI Accessibility Auditors - Sends local files to a linting engine using a CLI tool to automate accessibility checks outside of a browser.

IDE Extensions - Provides plugins for code editors to detect accessibility violations in real time during development.

Accessibility Linter Plugins - Offers specialized plugins for code editors to perform real-time accessibility rule checking.

IDE Real-time Feedback - Provides immediate accessibility analysis and remediation guidance directly within the code editor during development.

Real-Time Code Diagnostics - Alerts developers to accessibility issues within the code editor as they write source code.

Standardized Accessibility Exports - Generates a consistent JSON output format for accessibility violations to ensure compatibility across auditing tools.

Analysis Result Exporters - Outputs accessibility violation summaries and detailed rule failures in a standardized JSON format for external integration.

Quality Gates - Integrates accessibility checks into CI/CD pipelines to prevent code containing accessibility violations from being merged into a project.

Accessibility Result Synchronization - Send page state and commit-linked data to a centralized hub to track trends and remove duplicate entries.

Version Control Integration - Associates accessibility failures with specific Git commits to pinpoint when violations were introduced.

Accessibility Training - Provides role-based overviews and deep-dive technical courses to teach accessibility standards and inclusive design.

Accessibility Analysis Libraries - Analyzes React Native code to detect accessibility violations early in the development cycle.

Assessment Progress Monitoring - Monitors the completion status of accessibility test runs across defined pages to ensure all checkpoints are verified.

Role Mappings - Maps proprietary custom element tags to standard accessibility roles to validate non-standard interface components.

CI/CD Integrations - Runs accessibility audits via command-line tools, GitHub Actions, or pre-commit hooks to block problematic code from being merged or deployed.

Accessibility Trend Analysis - Links test results to Git commits to monitor accessibility progress and evaluate the impact of code changes.

Team Collaboration Tools - Facilitates the distribution of detected accessibility violations among team members for collaborative fixing.

Rule Suppression Comments - Supports the use of inline code comments to suppress specific accessibility linting rules for targeted blocks.

Analysis Result Exports - Exports accessibility analysis findings into various portable formats for reporting and tracking.

Audit Result Tracking - Provides historical tracking of accessibility audit results linked to specific project versions.

Test Performance Monitors - Tracks execution metrics and accessibility performance data over time to measure project progress.

Accessibility Auditing Tools - Uses command-line tools and plugins to detect accessibility violations during the development cycle.

AI-Powered Analysis - Leverages machine learning to automatically detect element roles and review color contrast.

Guided Evaluations - Walks non-experts through specific testing procedures to identify accessibility violations without specialized knowledge.

Heuristic Violation Detection - Employs computer vision and language models to find complex accessibility issues that rule-based testing misses.

ML-Driven Test Automation - Uses machine learning to process screenshots and automate manual steps within guided accessibility tests.

Automated Test Suites - Allows the injection of accessibility scans into existing automated test suites, mapping failures to specific code contexts.

Accessibility Test Integrations - Integrates accessibility checks into existing automated UI tests to capture failures with Git context and centralized reporting.

Browser Automation - Integrates with browser automation tools to execute accessibility audits during simulated user interactions.

User Interaction Simulation - Executes browser actions such as form filling or banner dismissal to prepare the page state for accessibility scanning.

Accessibility Reviews - Uses machine learning to identify input labels and analyze element roles to streamline the review process.

Test Report Exporters - Serializes accessibility audit outcomes into various standardized reporting formats for external documentation.

Test Result Reporters - Generates formatted reports of accessibility test execution outcomes for analysis.

Result Sharing - Provides mechanisms to share specific accessibility test results and issue groups with other team members.

Browser Automation Testing - Orchestrates testing activity across browsers to ensure consistent accessibility evaluations across different environments.

Visual Analysis Optimizations - Processes page screenshots through machine learning to automate complex accessibility checks and improve testing accuracy.

Manual Testing Procedures - Walks users through documented workflows for verifying accessibility requirements that cannot be detected by automated scans.

Test Data Management - Stores and manages test cases, runs, and identified accessibility issues to track remediation progress.

Test Execution Reports - Maintains long-term records of accessibility execution runs and violations for reporting and auditing.

Visual Markup Analysis - Identifies headings based on visual appearance to find elements that lack correct semantic markup.

Manual Testing Guides - Provides detailed instructions for verifying specific accessibility checkpoints and logging issues discovered during manual review.

Contrast Validators - Calculates luminance ratios and uses screenshots to verify that text meets contrast requirements.

Automatic Contrast Adjusters - Identifies and automatically fixes color contrast violations to meet accessibility standards.

Accessibility Rule Mapping - Maps proprietary component properties to standard attributes to validate custom elements against accessibility rules.

Custom Component Auditing - Scans custom interface elements for accessibility defects using plugins to ensure consistency.

Semantic Heading Validation - Compares computer vision analysis with page source to find text that looks like a heading but lacks semantic markup.

Focus State Indicators - Analyzes focusable elements to ensure visual styles change when focused for keyboard accessibility.

Dynamic State Analysis - Detects DOM changes during execution and re-analyzes the page to verify that dynamic content remains accessible.

Testing Frameworks - Accessibility engine for automated web UI testing.

dequelabsaxe-core

Features

Star history