diff --git a/Cargo.lock b/Cargo.lock
index dccf1bd5a8c3..9d8e77e134b2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -184,6 +184,7 @@ dependencies = [
  "biome_graphql_analyze",
  "biome_graphql_syntax",
  "biome_grit_patterns",
+ "biome_html_analyze",
  "biome_html_formatter",
  "biome_js_analyze",
  "biome_js_formatter",
@@ -749,6 +750,29 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "biome_html_analyze"
+version = "0.5.7"
+dependencies = [
+ "biome_analyze",
+ "biome_console",
+ "biome_deserialize",
+ "biome_deserialize_macros",
+ "biome_diagnostics",
+ "biome_html_factory",
+ "biome_html_parser",
+ "biome_html_syntax",
+ "biome_rowan",
+ "biome_string_case",
+ "biome_suppression",
+ "biome_test_utils",
+ "camino",
+ "insta",
+ "schemars",
+ "serde",
+ "tests_macros",
+]
+
 [[package]]
 name = "biome_html_factory"
 version = "0.5.7"
@@ -1496,6 +1520,7 @@ dependencies = [
  "biome_grit_parser",
  "biome_grit_patterns",
  "biome_grit_syntax",
+ "biome_html_analyze",
  "biome_html_factory",
  "biome_html_formatter",
  "biome_html_parser",
@@ -4047,6 +4072,9 @@ dependencies = [
  "biome_graphql_analyze",
  "biome_graphql_parser",
  "biome_graphql_syntax",
+ "biome_html_analyze",
+ "biome_html_parser",
+ "biome_html_syntax",
  "biome_js_analyze",
  "biome_js_parser",
  "biome_js_syntax",
@@ -5752,6 +5780,9 @@ dependencies = [
  "biome_graphql_analyze",
  "biome_graphql_parser",
  "biome_graphql_syntax",
+ "biome_html_analyze",
+ "biome_html_parser",
+ "biome_html_syntax",
  "biome_js_analyze",
  "biome_js_factory",
  "biome_js_formatter",
diff --git a/Cargo.toml b/Cargo.toml
index 1e64773aee33..e8d8df4e265a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -128,6 +128,7 @@ biome_grit_formatter         = { version = "0.0.0", path = "./crates/biome_grit_
 biome_grit_parser            = { version = "0.1.0", path = "./crates/biome_grit_parser" }
 biome_grit_patterns          = { version = "0.0.1", path = "./crates/biome_grit_patterns" }
 biome_grit_syntax            = { version = "0.5.7", path = "./crates/biome_grit_syntax" }
+biome_html_analyze           = { version = "0.5.7", path = "./crates/biome_html_analyze" }
 biome_html_factory           = { version = "0.5.7", path = "./crates/biome_html_factory" }
 biome_html_formatter         = { version = "0.0.0", path = "./crates/biome_html_formatter" }
 biome_html_parser            = { version = "0.0.1", path = "./crates/biome_html_parser" }
diff --git a/crates/biome_cli/Cargo.toml b/crates/biome_cli/Cargo.toml
index dfa50d2aa018..32abc9ac33a1 100644
--- a/crates/biome_cli/Cargo.toml
+++ b/crates/biome_cli/Cargo.toml
@@ -34,6 +34,7 @@ biome_glob               = { workspace = true }
 biome_graphql_analyze    = { workspace = true }
 biome_graphql_syntax     = { workspace = true }
 biome_grit_patterns      = { workspace = true }
+biome_html_analyze       = { workspace = true }
 biome_html_formatter     = { workspace = true }
 biome_js_analyze         = { workspace = true }
 biome_js_formatter       = { workspace = true }
diff --git a/crates/biome_cli/tests/cases/html.rs b/crates/biome_cli/tests/cases/html.rs
index 7b1d98b38f6f..2dd7cddb5ddc 100644
--- a/crates/biome_cli/tests/cases/html.rs
+++ b/crates/biome_cli/tests/cases/html.rs
@@ -331,3 +331,45 @@ fn should_apply_fixes_to_embedded_languages() {
         result,
     ));
 }
+
+#[test]
+fn should_lint_a_html_file() {
+    let fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let html_file = Utf8Path::new("file.html");
+    fs.insert(
+        html_file.into(),
+        r#"<div scope="col"></div>
+"#
+        .as_bytes(),
+    );
+
+    fs.insert(
+        Utf8Path::new("biome.json").into(),
+        r#"{
+    "html": {
+        "linter": {
+            "enabled": true
+        }
+    }
+}"#
+        .as_bytes(),
+    );
+
+    let (fs, result) = run_cli(
+        fs,
+        &mut console,
+        Args::from(["lint", html_file.as_str()].as_slice()),
+    );
+
+    assert!(result.is_err(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "should_lint_a_html_file",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/biome_cli/tests/snapshots/main_cases_html/should_lint_a_html_file.snap b/crates/biome_cli/tests/snapshots/main_cases_html/should_lint_a_html_file.snap
new file mode 100644
index 000000000000..5506bda346f4
--- /dev/null
+++ b/crates/biome_cli/tests/snapshots/main_cases_html/should_lint_a_html_file.snap
@@ -0,0 +1,63 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `biome.json`
+
+```json
+{
+  "html": {
+    "linter": {
+      "enabled": true
+    }
+  }
+}
+```
+
+## `file.html`
+
+```html
+<div scope="col"></div>
+
+```
+
+# Termination Message
+
+```block
+lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
+```
+
+# Emitted Messages
+
+```block
+file.html:1:6 lint/a11y/noHeaderScope  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Avoid using the scope attribute on elements other than th elements.
+  
+  > 1 │ <div scope="col"></div>
+      │      ^^^^^^^^^^^
+    2 │ 
+  
+  i The scope attribute is used to associate a data cell with its corresponding header cell in a data table,
+                so it should be placed on th elements to provide accessibility to screen readers.
+  
+  i Follow the links for more information,
+                WCAG 1.3.1
+                WCAG 4.1.1
+  
+  i Unsafe fix: Remove the scope attribute.
+  
+    1 │ <div·scope="col"></div>
+      │      -----------       
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 1 error.
+```
diff --git a/crates/biome_configuration/Cargo.toml b/crates/biome_configuration/Cargo.toml
index c6eafb0b007d..98a3cf00e04a 100644
--- a/crates/biome_configuration/Cargo.toml
+++ b/crates/biome_configuration/Cargo.toml
@@ -13,8 +13,9 @@ version              = "0.0.1"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-biome_analyze            = { workspace = true, features = ["serde"] }
-biome_console            = { workspace = true }
+biome_analyze = { workspace = true, features = ["serde"] }
+biome_console = { workspace = true }
+
 biome_deserialize        = { workspace = true }
 biome_deserialize_macros = { workspace = true }
 biome_diagnostics        = { workspace = true }
diff --git a/crates/biome_html_analyze/Cargo.toml b/crates/biome_html_analyze/Cargo.toml
new file mode 100644
index 000000000000..2fa2742b758c
--- /dev/null
+++ b/crates/biome_html_analyze/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+authors.workspace    = true
+categories.workspace = true
+description          = "Biome's HTML linter"
+edition.workspace    = true
+homepage.workspace   = true
+keywords.workspace   = true
+license.workspace    = true
+name                 = "biome_html_analyze"
+repository.workspace = true
+version              = "0.5.7"
+
+[dependencies]
+biome_analyze            = { workspace = true }
+biome_console            = { workspace = true }
+biome_deserialize        = { workspace = true }
+biome_deserialize_macros = { workspace = true }
+biome_diagnostics        = { workspace = true }
+biome_html_factory       = { workspace = true }
+biome_html_syntax        = { workspace = true }
+biome_rowan              = { workspace = true }
+biome_string_case        = { workspace = true }
+biome_suppression        = { workspace = true }
+schemars                 = { workspace = true, optional = true }
+serde                    = { workspace = true, features = ["derive"] }
+
+[dev-dependencies]
+biome_html_parser = { path = "../biome_html_parser" }
+biome_test_utils  = { path = "../biome_test_utils" }
+camino            = { workspace = true }
+insta             = { workspace = true, features = ["glob"] }
+tests_macros      = { path = "../tests_macros" }
+
+[features]
+schema = ["schemars"]
+
+[lints]
+workspace = true
diff --git a/crates/biome_html_analyze/src/lib.rs b/crates/biome_html_analyze/src/lib.rs
new file mode 100644
index 000000000000..375a264c2807
--- /dev/null
+++ b/crates/biome_html_analyze/src/lib.rs
@@ -0,0 +1,185 @@
+#![deny(clippy::use_self)]
+
+mod lint;
+pub mod options;
+mod registry;
+mod suppression_action;
+
+pub use crate::registry::visit_registry;
+use crate::suppression_action::HtmlSuppressionAction;
+use biome_analyze::{
+    AnalysisFilter, AnalyzerOptions, AnalyzerSignal, AnalyzerSuppression, ControlFlow,
+    LanguageRoot, MatchQueryParams, MetadataRegistry, RuleAction, RuleRegistry,
+    to_analyzer_suppressions,
+};
+use biome_deserialize::TextRange;
+use biome_diagnostics::Error;
+use biome_html_syntax::HtmlLanguage;
+use biome_suppression::{SuppressionDiagnostic, parse_suppression_comment};
+use std::ops::Deref;
+use std::sync::LazyLock;
+
+pub(crate) type HtmlRuleAction = RuleAction<HtmlLanguage>;
+
+pub static METADATA: LazyLock<MetadataRegistry> = LazyLock::new(|| {
+    let mut metadata = MetadataRegistry::default();
+    visit_registry(&mut metadata);
+    metadata
+});
+
+/// Run the analyzer on the provided `root`: this process will use the given `filter`
+/// to selectively restrict analysis to specific rules / a specific source range,
+/// then call `emit_signal` when an analysis rule emits a diagnostic or action
+pub fn analyze<'a, F, B>(
+    root: &LanguageRoot<HtmlLanguage>,
+    filter: AnalysisFilter,
+    options: &'a AnalyzerOptions,
+    emit_signal: F,
+) -> (Option<B>, Vec<Error>)
+where
+    F: FnMut(&dyn AnalyzerSignal<HtmlLanguage>) -> ControlFlow<B> + 'a,
+    B: 'a,
+{
+    analyze_with_inspect_matcher(root, filter, |_| {}, options, emit_signal)
+}
+
+/// Run the analyzer on the provided `root`: this process will use the given `filter`
+/// to selectively restrict analysis to specific rules / a specific source range,
+/// then call `emit_signal` when an analysis rule emits a diagnostic or action.
+/// Additionally, this function takes a `inspect_matcher` function that can be
+/// used to inspect the "query matches" emitted by the analyzer before they are
+/// processed by the lint rules registry
+pub fn analyze_with_inspect_matcher<'a, V, F, B>(
+    root: &LanguageRoot<HtmlLanguage>,
+    filter: AnalysisFilter,
+    inspect_matcher: V,
+    options: &'a AnalyzerOptions,
+    mut emit_signal: F,
+) -> (Option<B>, Vec<Error>)
+where
+    V: FnMut(&MatchQueryParams<HtmlLanguage>) + 'a,
+    F: FnMut(&dyn AnalyzerSignal<HtmlLanguage>) -> ControlFlow<B> + 'a,
+    B: 'a,
+{
+    fn parse_linter_suppression_comment(
+        text: &str,
+        piece_range: TextRange,
+    ) -> Vec<Result<AnalyzerSuppression<'_>, SuppressionDiagnostic>> {
+        let mut result = Vec::new();
+
+        for suppression in parse_suppression_comment(text) {
+            let suppression = match suppression {
+                Ok(suppression) => suppression,
+                Err(err) => {
+                    result.push(Err(err));
+                    continue;
+                }
+            };
+
+            let analyzer_suppressions: Vec<_> = to_analyzer_suppressions(suppression, piece_range)
+                .into_iter()
+                .map(Ok)
+                .collect();
+
+            result.extend(analyzer_suppressions)
+        }
+
+        result
+    }
+
+    let mut registry = RuleRegistry::builder(&filter, root);
+    visit_registry(&mut registry);
+
+    let (registry, services, diagnostics, visitors) = registry.build();
+
+    // Bail if we can't parse a rule option
+    if !diagnostics.is_empty() {
+        return (None, diagnostics);
+    }
+
+    let mut analyzer = biome_analyze::Analyzer::new(
+        METADATA.deref(),
+        biome_analyze::InspectMatcher::new(registry, inspect_matcher),
+        parse_linter_suppression_comment,
+        Box::new(HtmlSuppressionAction),
+        &mut emit_signal,
+    );
+
+    for ((phase, _), visitor) in visitors {
+        analyzer.add_visitor(phase, visitor);
+    }
+
+    (
+        analyzer.run(biome_analyze::AnalyzerContext {
+            root: root.clone(),
+            range: filter.range,
+            services,
+            options,
+        }),
+        diagnostics,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::analyze;
+    use biome_analyze::{AnalysisFilter, AnalyzerOptions, ControlFlow, Never, RuleFilter};
+    use biome_console::fmt::{Formatter, Termcolor};
+    use biome_console::{Markup, markup};
+    use biome_diagnostics::termcolor::NoColor;
+    use biome_diagnostics::{Diagnostic, DiagnosticExt, PrintDiagnostic, Severity};
+    use biome_html_parser::parse_html;
+    use biome_rowan::TextRange;
+    use std::slice;
+
+    #[ignore]
+    #[test]
+    fn quick_test() {
+        fn markup_to_string(markup: Markup) -> String {
+            let mut buffer = Vec::new();
+            let mut write = Termcolor(NoColor::new(&mut buffer));
+            let mut fmt = Formatter::new(&mut write);
+            fmt.write_markup(markup).unwrap();
+
+            String::from_utf8(buffer).unwrap()
+        }
+
+        const SOURCE: &str = r#" "#;
+
+        let parsed = parse_html(SOURCE, Default::default());
+
+        let mut error_ranges: Vec<TextRange> = Vec::new();
+        let rule_filter = RuleFilter::Rule("nursery", "noUnknownPseudoClass");
+        let options = AnalyzerOptions::default();
+        analyze(
+            &parsed.tree(),
+            AnalysisFilter {
+                enabled_rules: Some(slice::from_ref(&rule_filter)),
+                ..AnalysisFilter::default()
+            },
+            &options,
+            |signal| {
+                if let Some(diag) = signal.diagnostic() {
+                    error_ranges.push(diag.location().span.unwrap());
+                    let error = diag
+                        .with_severity(Severity::Warning)
+                        .with_file_path("ahahah")
+                        .with_file_source_code(SOURCE);
+                    let text = markup_to_string(markup! {
+                        {PrintDiagnostic::verbose(&error)}
+                    });
+                    eprintln!("{text}");
+                }
+
+                for action in signal.actions() {
+                    let new_code = action.mutation.commit();
+                    eprintln!("{new_code}");
+                }
+
+                ControlFlow::<Never>::Continue(())
+            },
+        );
+
+        assert_eq!(error_ranges.as_slice(), &[]);
+    }
+}
diff --git a/crates/biome_html_analyze/src/lint.rs b/crates/biome_html_analyze/src/lint.rs
new file mode 100644
index 000000000000..b2f2e59b40b4
--- /dev/null
+++ b/crates/biome_html_analyze/src/lint.rs
@@ -0,0 +1,6 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+pub mod a11y;
+::biome_analyze::declare_category! { pub Lint { kind : Lint , groups : [self :: a11y :: A11y ,] } }
diff --git a/crates/biome_html_analyze/src/lint/a11y.rs b/crates/biome_html_analyze/src/lint/a11y.rs
new file mode 100644
index 000000000000..51c45be57db9
--- /dev/null
+++ b/crates/biome_html_analyze/src/lint/a11y.rs
@@ -0,0 +1,7 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+use biome_analyze::declare_lint_group;
+pub mod no_header_scope;
+declare_lint_group! { pub A11y { name : "a11y" , rules : [self :: no_header_scope :: NoHeaderScope ,] } }
diff --git a/crates/biome_html_analyze/src/lint/a11y/no_header_scope.rs b/crates/biome_html_analyze/src/lint/a11y/no_header_scope.rs
new file mode 100644
index 000000000000..9b887a8c1b10
--- /dev/null
+++ b/crates/biome_html_analyze/src/lint/a11y/no_header_scope.rs
@@ -0,0 +1,103 @@
+use biome_analyze::context::RuleContext;
+use biome_analyze::{Ast, FixKind, Rule, RuleDiagnostic, RuleSource, declare_lint_rule};
+use biome_console::markup;
+use biome_diagnostics::Severity;
+use biome_html_syntax::{AnyHtmlElement, HtmlAttribute};
+use biome_rowan::{AstNode, BatchMutationExt};
+
+use crate::HtmlRuleAction;
+
+declare_lint_rule! {
+    /// The scope prop should be used only on `<th>` elements.
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```html,expect_diagnostic
+    /// <div scope="col"></div>
+    /// ```
+    ///
+    /// ```html,expect_diagnostic
+    /// <div scope></div>
+    /// ```
+    ///
+    /// ### Valid
+    ///
+    /// ```html
+    /// <th scope="col"></th>
+    /// ```
+    ///
+    /// ```html
+    /// <th scope></th>
+    /// ```
+    ///
+    /// ## Accessibility guidelines
+    ///
+    /// - [WCAG 1.3.1](https://www.w3.org/WAI/WCAG21/Understanding/info-and-relationships)
+    /// - [WCAG 4.1.1](https://www.w3.org/WAI/WCAG21/Understanding/parsing)
+    ///
+    pub NoHeaderScope {
+        version: "next",
+        name: "noHeaderScope",
+        language: "html",
+        sources: &[RuleSource::EslintJsxA11y("scope").same()],
+        recommended: true,
+        severity: Severity::Error,
+        fix_kind: FixKind::Unsafe,
+    }
+}
+
+impl Rule for NoHeaderScope {
+    type Query = Ast<AnyHtmlElement>;
+    type State = HtmlAttribute;
+    type Signals = Option<Self::State>;
+    type Options = ();
+
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+        let element = ctx.query();
+
+        // Check if element is NOT a th element and has a scope attribute
+        if is_th_element(element)? {
+            return None;
+        }
+
+        // Check if element has a scope attribute
+        element.find_attribute_by_name("scope")
+    }
+
+    fn diagnostic(_ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {
+        let diagnostic = RuleDiagnostic::new(
+            rule_category!(),
+            state.range(),
+            markup! {"Avoid using the "<Emphasis>"scope"</Emphasis>" attribute on elements other than "<Emphasis>"th"</Emphasis>" elements."}
+                .to_owned(),
+        ).note(markup!{
+            "The "<Emphasis>"scope"</Emphasis>" attribute is used to associate a data cell with its corresponding header cell in a data table,
+            so it should be placed on "<Emphasis>"th"</Emphasis>" elements to provide accessibility to screen readers."
+        }).note(markup!{
+            "Follow the links for more information,
+            "<Hyperlink href="https://www.w3.org/WAI/WCAG21/Understanding/info-and-relationships">"WCAG 1.3.1"</Hyperlink>"
+            "<Hyperlink href="https://www.w3.org/WAI/WCAG21/Understanding/parsing">"WCAG 4.1.1"</Hyperlink>""
+        });
+
+        Some(diagnostic)
+    }
+
+    fn action(ctx: &RuleContext<Self>, state: &Self::State) -> Option<HtmlRuleAction> {
+        let mut mutation = ctx.root().begin();
+        mutation.remove_node(state.clone());
+
+        Some(HtmlRuleAction::new(
+            ctx.metadata().action_category(ctx.category(), ctx.group()),
+            ctx.metadata().applicability(),
+            markup! { "Remove the "<Emphasis>"scope"</Emphasis>" attribute." }.to_owned(),
+            mutation,
+        ))
+    }
+}
+
+// Helper function to check if element is a th element
+fn is_th_element(element: &AnyHtmlElement) -> Option<bool> {
+    Some(element.name()?.text().eq_ignore_ascii_case("th"))
+}
diff --git a/crates/biome_html_analyze/src/options.rs b/crates/biome_html_analyze/src/options.rs
new file mode 100644
index 000000000000..d4e16dd07977
--- /dev/null
+++ b/crates/biome_html_analyze/src/options.rs
@@ -0,0 +1,7 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+use crate::lint;
+pub type NoHeaderScope =
+    <lint::a11y::no_header_scope::NoHeaderScope as biome_analyze::Rule>::Options;
diff --git a/crates/biome_html_analyze/src/registry.rs b/crates/biome_html_analyze/src/registry.rs
new file mode 100644
index 000000000000..97ee757b8e1d
--- /dev/null
+++ b/crates/biome_html_analyze/src/registry.rs
@@ -0,0 +1,7 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+use biome_analyze::RegistryVisitor;
+use biome_html_syntax::HtmlLanguage;
+pub fn visit_registry<V: RegistryVisitor<HtmlLanguage>>(registry: &mut V) {
+    registry.record_category::<crate::lint::Lint>();
+}
diff --git a/crates/biome_html_analyze/src/suppression_action.rs b/crates/biome_html_analyze/src/suppression_action.rs
new file mode 100644
index 000000000000..b012769bee72
--- /dev/null
+++ b/crates/biome_html_analyze/src/suppression_action.rs
@@ -0,0 +1,110 @@
+use biome_analyze::{ApplySuppression, SuppressionAction};
+use biome_html_syntax::{HtmlLanguage, HtmlSyntaxToken};
+use biome_rowan::{BatchMutation, TriviaPieceKind};
+
+pub(crate) struct HtmlSuppressionAction;
+
+impl SuppressionAction for HtmlSuppressionAction {
+    type Language = HtmlLanguage;
+
+    fn find_token_for_inline_suppression(
+        &self,
+        token: HtmlSyntaxToken,
+    ) -> Option<ApplySuppression<Self::Language>> {
+        let mut apply_suppression = ApplySuppression {
+            token_has_trailing_comments: false,
+            token_to_apply_suppression: token.clone(),
+            should_insert_leading_newline: false,
+        };
+
+        // Find the token at the start of suppressed token's line
+        let mut current_token = token;
+        loop {
+            let trivia = current_token.leading_trivia();
+            if trivia.pieces().any(|trivia| trivia.kind().is_newline()) {
+                break;
+            } else if let Some(prev_token) = current_token.prev_token() {
+                current_token = prev_token
+            } else {
+                break;
+            }
+        }
+
+        apply_suppression.token_has_trailing_comments = current_token
+            .trailing_trivia()
+            .pieces()
+            .any(|trivia| trivia.kind().is_comment());
+        apply_suppression.token_to_apply_suppression = current_token;
+        Some(apply_suppression)
+    }
+
+    fn apply_inline_suppression(
+        &self,
+        mutation: &mut BatchMutation<Self::Language>,
+        apply_suppression: ApplySuppression<Self::Language>,
+        suppression_text: &str,
+        suppression_reason: &str,
+    ) {
+        let ApplySuppression {
+            token_to_apply_suppression,
+            token_has_trailing_comments,
+            should_insert_leading_newline: _,
+        } = apply_suppression;
+
+        let mut new_token = token_to_apply_suppression.clone();
+        let has_leading_whitespace = new_token
+            .leading_trivia()
+            .pieces()
+            .any(|trivia| trivia.is_whitespace());
+
+        if token_has_trailing_comments {
+            let mut trailing: Vec<_> = new_token
+                .trailing_trivia()
+                .pieces()
+                .map(|piece| (piece.kind(), piece.text().to_owned()))
+                .collect();
+            trailing.push((
+                TriviaPieceKind::MultiLineComment,
+                format!("<!-- {suppression_text}: {suppression_reason} -->"),
+            ));
+            trailing.push((TriviaPieceKind::Newline, "\n".to_string()));
+            let trailing_refs: Vec<_> = trailing
+                .iter()
+                .map(|(kind, text)| (*kind, text.as_str()))
+                .collect();
+            new_token = new_token.with_trailing_trivia(trailing_refs);
+        } else if has_leading_whitespace {
+            let suppression_comment = format!("<!-- {suppression_text}: {suppression_reason} -->");
+            let mut trivia = vec![
+                (
+                    TriviaPieceKind::MultiLineComment,
+                    suppression_comment.as_str(),
+                ),
+                (TriviaPieceKind::Newline, "\n"),
+            ];
+            let leading_whitespace: Vec<_> = new_token
+                .leading_trivia()
+                .pieces()
+                .filter(|p| p.is_whitespace())
+                .collect();
+
+            for w in leading_whitespace.iter() {
+                trivia.push((TriviaPieceKind::Whitespace, w.text()));
+            }
+            new_token = new_token.with_leading_trivia(trivia);
+        } else {
+            new_token = new_token.with_leading_trivia([
+                (
+                    TriviaPieceKind::MultiLineComment,
+                    format!("<!-- {suppression_text}: {suppression_reason} -->").as_str(),
+                ),
+                (TriviaPieceKind::Newline, "\n"),
+            ]);
+        }
+        mutation.replace_token_transfer_trivia(token_to_apply_suppression, new_token);
+    }
+
+    fn suppression_top_level_comment(&self, suppression_text: &str) -> String {
+        format!("<!-- {suppression_text}: <explanation> -->")
+    }
+}
diff --git a/crates/biome_html_analyze/tests/spec_tests.rs b/crates/biome_html_analyze/tests/spec_tests.rs
new file mode 100644
index 000000000000..588fd0ff0f4a
--- /dev/null
+++ b/crates/biome_html_analyze/tests/spec_tests.rs
@@ -0,0 +1,219 @@
+use biome_analyze::{AnalysisFilter, AnalyzerAction, ControlFlow, Never, RuleFilter};
+use biome_diagnostics::advice::CodeSuggestionAdvice;
+use biome_html_parser::{HtmlParseOptions, parse_html};
+use biome_html_syntax::{HtmlFileSource, HtmlLanguage};
+use biome_rowan::AstNode;
+use biome_test_utils::{
+    CheckActionType, assert_diagnostics_expectation_comment, assert_errors_are_absent,
+    code_fix_to_string, create_analyzer_options, diagnostic_to_string,
+    has_bogus_nodes_or_empty_slots, parse_test_path, register_leak_checker, scripts_from_json,
+    write_analyzer_snapshot,
+};
+use camino::Utf8Path;
+use std::ops::Deref;
+use std::{fs::read_to_string, slice};
+
+tests_macros::gen_tests! {"tests/specs/**/*.{html,json,jsonc}", crate::run_test, "module"}
+tests_macros::gen_tests! {"tests/suppression/**/*.{html,json,jsonc}", crate::run_suppression_test, "module"}
+
+fn run_test(input: &'static str, _: &str, _: &str, _: &str) {
+    register_leak_checker();
+
+    let input_file = Utf8Path::new(input);
+    let file_name = input_file.file_name().unwrap();
+
+    let (group, rule) = parse_test_path(input_file);
+    if rule == "specs" {
+        panic!("the test file must be placed in the {rule}/<group-name>/<rule-name>/ directory");
+    }
+    if group == "specs" {
+        panic!("the test file must be placed in the {group}/{rule}/<rule-name>/ directory");
+    }
+    if biome_html_analyze::METADATA
+        .deref()
+        .find_rule(group, rule)
+        .is_none()
+    {
+        panic!("could not find rule {group}/{rule}");
+    }
+
+    let rule_filter = RuleFilter::Rule(group, rule);
+    let filter = AnalysisFilter {
+        enabled_rules: Some(slice::from_ref(&rule_filter)),
+        ..AnalysisFilter::default()
+    };
+
+    let mut snapshot = String::new();
+    let extension = input_file.extension().unwrap_or_default();
+
+    let input_code = read_to_string(input_file)
+        .unwrap_or_else(|err| panic!("failed to read {input_file:?}: {err:?}"));
+
+    if let Some(scripts) = scripts_from_json(extension, &input_code) {
+        for script in scripts {
+            analyze_and_snap(
+                &mut snapshot,
+                &script,
+                HtmlFileSource::html(),
+                filter,
+                file_name,
+                input_file,
+                CheckActionType::Lint,
+            );
+        }
+    } else {
+        let Ok(source_type) = input_file.try_into() else {
+            return;
+        };
+        analyze_and_snap(
+            &mut snapshot,
+            &input_code,
+            source_type,
+            filter,
+            file_name,
+            input_file,
+            CheckActionType::Lint,
+        );
+    };
+
+    insta::with_settings!({
+        prepend_module_to_snapshot => false,
+        snapshot_path => input_file.parent().unwrap(),
+    }, {
+        insta::assert_snapshot!(file_name, snapshot, file_name);
+    });
+}
+
+pub(crate) fn analyze_and_snap(
+    snapshot: &mut String,
+    input_code: &str,
+    source_type: HtmlFileSource,
+    filter: AnalysisFilter,
+    file_name: &str,
+    input_file: &Utf8Path,
+    check_action_type: CheckActionType,
+) {
+    let parsed = parse_html(input_code, HtmlParseOptions::default());
+    let root = parsed.tree();
+
+    let mut diagnostics = Vec::new();
+    let mut code_fixes = Vec::new();
+    let options = create_analyzer_options::<HtmlLanguage>(input_file, &mut diagnostics);
+
+    let (_, errors) = biome_html_analyze::analyze(&root, filter, &options, |event| {
+        if let Some(mut diag) = event.diagnostic() {
+            for action in event.actions() {
+                if check_action_type.is_suppression() {
+                    if action.is_suppression() {
+                        check_code_action(input_file, input_code, source_type, &action);
+                        diag = diag.add_code_suggestion(CodeSuggestionAdvice::from(action));
+                    }
+                } else if !action.is_suppression() {
+                    check_code_action(input_file, input_code, source_type, &action);
+                    diag = diag.add_code_suggestion(CodeSuggestionAdvice::from(action));
+                }
+            }
+
+            diagnostics.push(diagnostic_to_string(file_name, input_code, diag.into()));
+            return ControlFlow::Continue(());
+        }
+
+        for action in event.actions() {
+            if check_action_type.is_suppression() {
+                if action.category.matches("quickfix.suppressRule") {
+                    check_code_action(input_file, input_code, source_type, &action);
+                    code_fixes.push(code_fix_to_string(input_code, action));
+                }
+            } else if !action.category.matches("quickfix.suppressRule") {
+                check_code_action(input_file, input_code, source_type, &action);
+                code_fixes.push(code_fix_to_string(input_code, action));
+            }
+        }
+
+        ControlFlow::<Never>::Continue(())
+    });
+
+    for error in errors {
+        diagnostics.push(diagnostic_to_string(file_name, input_code, error));
+    }
+
+    write_analyzer_snapshot(
+        snapshot,
+        input_code,
+        diagnostics.as_slice(),
+        code_fixes.as_slice(),
+        "html",
+    );
+
+    assert_diagnostics_expectation_comment(input_file, root.syntax(), diagnostics);
+}
+
+fn check_code_action(
+    path: &Utf8Path,
+    source: &str,
+    _source_type: HtmlFileSource,
+    action: &AnalyzerAction<HtmlLanguage>,
+) {
+    let (new_tree, text_edit) = match action
+        .mutation
+        .clone()
+        .commit_with_text_range_and_edit(true)
+    {
+        (new_tree, Some((_, text_edit))) => (new_tree, text_edit),
+        (new_tree, None) => (new_tree, Default::default()),
+    };
+
+    let output = text_edit.new_string(source);
+
+    // Checks that applying the text edits returned by the BatchMutation
+    // returns the same code as printing the modified syntax tree
+    assert_eq!(new_tree.to_string(), output);
+
+    if has_bogus_nodes_or_empty_slots(&new_tree) {
+        panic!("modified tree has bogus nodes or empty slots:\n{new_tree:#?} \n\n {new_tree}")
+    }
+
+    // Checks the returned tree contains no missing children node
+    if format!("{new_tree:?}").contains("missing (required)") {
+        panic!("modified tree has missing children:\n{new_tree:#?}")
+    }
+
+    // Re-parse the modified code and panic if the resulting tree has syntax errors
+    let re_parse = parse_html(&output, HtmlParseOptions::default());
+    assert_errors_are_absent(re_parse.tree().syntax(), re_parse.diagnostics(), path);
+}
+
+pub(crate) fn run_suppression_test(input: &'static str, _: &str, _: &str, _: &str) {
+    register_leak_checker();
+
+    let input_file = Utf8Path::new(input);
+    let file_name = input_file.file_name().unwrap();
+    let input_code = read_to_string(input_file)
+        .unwrap_or_else(|err| panic!("failed to read {input_file:?}: {err:?}"));
+
+    let (group, rule) = parse_test_path(input_file);
+
+    let rule_filter = RuleFilter::Rule(group, rule);
+    let filter = AnalysisFilter {
+        enabled_rules: Some(slice::from_ref(&rule_filter)),
+        ..AnalysisFilter::default()
+    };
+
+    let mut snapshot = String::new();
+    analyze_and_snap(
+        &mut snapshot,
+        &input_code,
+        HtmlFileSource::html(),
+        filter,
+        file_name,
+        input_file,
+        CheckActionType::Suppression,
+    );
+
+    insta::with_settings!({
+        prepend_module_to_snapshot => false,
+        snapshot_path => input_file.parent().unwrap(),
+    }, {
+        insta::assert_snapshot!(file_name, snapshot, file_name);
+    });
+}
diff --git a/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/invalid.html b/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/invalid.html
new file mode 100644
index 000000000000..c87f15f58f32
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/invalid.html
@@ -0,0 +1,6 @@
+<!-- should generate diagnostics -->
+<div scope="col"></div>
+<div scope></div>
+<td scope="col"></td>
+<span scope="row"></span>
+<p scope></p>
diff --git a/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/invalid.html.snap b/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/invalid.html.snap
new file mode 100644
index 000000000000..a3d6e5c179cc
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/invalid.html.snap
@@ -0,0 +1,143 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: invalid.html
+---
+# Input
+```html
+<!-- should generate diagnostics -->
+<div scope="col"></div>
+<div scope></div>
+<td scope="col"></td>
+<span scope="row"></span>
+<p scope></p>
+
+```
+
+# Diagnostics
+```
+invalid.html:2:6 lint/a11y/noHeaderScope  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Avoid using the scope attribute on elements other than th elements.
+  
+    1 │ <!-- should generate diagnostics -->
+  > 2 │ <div scope="col"></div>
+      │      ^^^^^^^^^^^
+    3 │ <div scope></div>
+    4 │ <td scope="col"></td>
+  
+  i The scope attribute is used to associate a data cell with its corresponding header cell in a data table,
+                so it should be placed on th elements to provide accessibility to screen readers.
+  
+  i Follow the links for more information,
+                WCAG 1.3.1
+                WCAG 4.1.1
+  
+  i Unsafe fix: Remove the scope attribute.
+  
+    2 │ <div·scope="col"></div>
+      │      -----------       
+
+```
+
+```
+invalid.html:3:6 lint/a11y/noHeaderScope  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Avoid using the scope attribute on elements other than th elements.
+  
+    1 │ <!-- should generate diagnostics -->
+    2 │ <div scope="col"></div>
+  > 3 │ <div scope></div>
+      │      ^^^^^
+    4 │ <td scope="col"></td>
+    5 │ <span scope="row"></span>
+  
+  i The scope attribute is used to associate a data cell with its corresponding header cell in a data table,
+                so it should be placed on th elements to provide accessibility to screen readers.
+  
+  i Follow the links for more information,
+                WCAG 1.3.1
+                WCAG 4.1.1
+  
+  i Unsafe fix: Remove the scope attribute.
+  
+    3 │ <div·scope></div>
+      │      -----       
+
+```
+
+```
+invalid.html:4:5 lint/a11y/noHeaderScope  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Avoid using the scope attribute on elements other than th elements.
+  
+    2 │ <div scope="col"></div>
+    3 │ <div scope></div>
+  > 4 │ <td scope="col"></td>
+      │     ^^^^^^^^^^^
+    5 │ <span scope="row"></span>
+    6 │ <p scope></p>
+  
+  i The scope attribute is used to associate a data cell with its corresponding header cell in a data table,
+                so it should be placed on th elements to provide accessibility to screen readers.
+  
+  i Follow the links for more information,
+                WCAG 1.3.1
+                WCAG 4.1.1
+  
+  i Unsafe fix: Remove the scope attribute.
+  
+    4 │ <td·scope="col"></td>
+      │     -----------      
+
+```
+
+```
+invalid.html:5:7 lint/a11y/noHeaderScope  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Avoid using the scope attribute on elements other than th elements.
+  
+    3 │ <div scope></div>
+    4 │ <td scope="col"></td>
+  > 5 │ <span scope="row"></span>
+      │       ^^^^^^^^^^^
+    6 │ <p scope></p>
+    7 │ 
+  
+  i The scope attribute is used to associate a data cell with its corresponding header cell in a data table,
+                so it should be placed on th elements to provide accessibility to screen readers.
+  
+  i Follow the links for more information,
+                WCAG 1.3.1
+                WCAG 4.1.1
+  
+  i Unsafe fix: Remove the scope attribute.
+  
+    5 │ <span·scope="row"></span>
+      │       -----------        
+
+```
+
+```
+invalid.html:6:4 lint/a11y/noHeaderScope  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Avoid using the scope attribute on elements other than th elements.
+  
+    4 │ <td scope="col"></td>
+    5 │ <span scope="row"></span>
+  > 6 │ <p scope></p>
+      │    ^^^^^
+    7 │ 
+  
+  i The scope attribute is used to associate a data cell with its corresponding header cell in a data table,
+                so it should be placed on th elements to provide accessibility to screen readers.
+  
+  i Follow the links for more information,
+                WCAG 1.3.1
+                WCAG 4.1.1
+  
+  i Unsafe fix: Remove the scope attribute.
+  
+    6 │ <p·scope></p>
+      │    -----     
+
+```
diff --git a/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/valid.html b/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/valid.html
new file mode 100644
index 000000000000..9e58269eec6d
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/valid.html
@@ -0,0 +1,6 @@
+<!-- should not generate diagnostics -->
+<th scope="col"></th>
+<th scope="row"></th>
+<th scope></th>
+<div></div>
+<td></td>
diff --git a/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/valid.html.snap b/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/valid.html.snap
new file mode 100644
index 000000000000..95e276a4dcb1
--- /dev/null
+++ b/crates/biome_html_analyze/tests/specs/a11y/noHeaderScope/valid.html.snap
@@ -0,0 +1,14 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: valid.html
+---
+# Input
+```html
+<!-- should not generate diagnostics -->
+<th scope="col"></th>
+<th scope="row"></th>
+<th scope></th>
+<div></div>
+<td></td>
+
+```
diff --git a/crates/biome_html_analyze/tests/suppression/a11y/noHeaderScope/noHeaderScope.html b/crates/biome_html_analyze/tests/suppression/a11y/noHeaderScope/noHeaderScope.html
new file mode 100644
index 000000000000..e663d968175c
--- /dev/null
+++ b/crates/biome_html_analyze/tests/suppression/a11y/noHeaderScope/noHeaderScope.html
@@ -0,0 +1,2 @@
+<!-- code that should trigger the rule and show suppression actions -->
+<div scope="col"></div>
diff --git a/crates/biome_html_analyze/tests/suppression/a11y/noHeaderScope/noHeaderScope.html.snap b/crates/biome_html_analyze/tests/suppression/a11y/noHeaderScope/noHeaderScope.html.snap
new file mode 100644
index 000000000000..4d2a6c336e74
--- /dev/null
+++ b/crates/biome_html_analyze/tests/suppression/a11y/noHeaderScope/noHeaderScope.html.snap
@@ -0,0 +1,47 @@
+---
+source: crates/biome_html_analyze/tests/spec_tests.rs
+expression: noHeaderScope.html
+---
+# Input
+```html
+<!-- code that should trigger the rule and show suppression actions -->
+<div scope="col"></div>
+
+```
+
+# Diagnostics
+```
+noHeaderScope.html:2:6 lint/a11y/noHeaderScope  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Avoid using the scope attribute on elements other than th elements.
+  
+    1 │ <!-- code that should trigger the rule and show suppression actions -->
+  > 2 │ <div scope="col"></div>
+      │      ^^^^^^^^^^^
+    3 │ 
+  
+  i The scope attribute is used to associate a data cell with its corresponding header cell in a data table,
+                so it should be placed on th elements to provide accessibility to screen readers.
+  
+  i Follow the links for more information,
+                WCAG 1.3.1
+                WCAG 4.1.1
+  
+  i Safe fix: Suppress rule lint/a11y/noHeaderScope for this line.
+  
+    1 1 │   <!-- code that should trigger the rule and show suppression actions -->
+    2   │ - <div·scope="col"></div>
+      2 │ + <!--·biome-ignore·lint/a11y/noHeaderScope:·<explanation>·-->
+      3 │ + <div·scope="col"></div>
+    3 4 │   
+  
+  i Safe fix: Suppress rule lint/a11y/noHeaderScope for the whole file.
+  
+    1 1 │   <!-- code that should trigger the rule and show suppression actions -->
+    2   │ - <div·scope="col"></div>
+      2 │ + <!--·biome-ignore-all·lint/a11y/noHeaderScope:·<explanation>·-->
+      3 │ + <div·scope="col"></div>
+    3 4 │   
+  
+
+```
diff --git a/crates/biome_html_syntax/src/element_ext.rs b/crates/biome_html_syntax/src/element_ext.rs
index 47a93015ddaa..1252d40e0b07 100644
--- a/crates/biome_html_syntax/src/element_ext.rs
+++ b/crates/biome_html_syntax/src/element_ext.rs
@@ -2,7 +2,7 @@ use crate::{
     AnyHtmlElement, HtmlAttribute, HtmlElement, HtmlSelfClosingElement, ScriptType,
     inner_string_text,
 };
-use biome_rowan::{AstNodeList, SyntaxResult};
+use biome_rowan::{AstNodeList, SyntaxResult, TokenText};
 
 /// https://html.spec.whatwg.org/#void-elements
 const VOID_ELEMENTS: &[&str] = &[
@@ -51,6 +51,23 @@ impl AnyHtmlElement {
             Self::AnyHtmlContent(_) | Self::HtmlBogusElement(_) | Self::HtmlCdataSection(_) => None,
         }
     }
+
+    pub fn name(&self) -> Option<TokenText> {
+        match self {
+            Self::HtmlElement(el) => {
+                let opening_element = el.opening_element().ok()?;
+                let name = opening_element.name().ok()?;
+                let name_token = name.value_token().ok()?;
+                Some(name_token.token_text_trimmed())
+            }
+            Self::HtmlSelfClosingElement(el) => {
+                let name = el.name().ok()?;
+                let name_token = name.value_token().ok()?;
+                Some(name_token.token_text_trimmed())
+            }
+            _ => None,
+        }
+    }
 }
 
 impl HtmlSelfClosingElement {
diff --git a/crates/biome_service/Cargo.toml b/crates/biome_service/Cargo.toml
index df458fdddf7f..cd43ba467d09 100644
--- a/crates/biome_service/Cargo.toml
+++ b/crates/biome_service/Cargo.toml
@@ -36,6 +36,7 @@ biome_grit_formatter    = { workspace = true }
 biome_grit_parser       = { workspace = true }
 biome_grit_patterns     = { workspace = true, features = ["serde"] }
 biome_grit_syntax       = { workspace = true }
+biome_html_analyze      = { workspace = true }
 biome_html_factory      = { workspace = true }
 biome_html_formatter    = { workspace = true, features = ["serde"] }
 biome_html_parser       = { workspace = true }
diff --git a/crates/biome_service/src/documentation/mod.rs b/crates/biome_service/src/documentation/mod.rs
index 16aeb566b610..ba9a150712da 100644
--- a/crates/biome_service/src/documentation/mod.rs
+++ b/crates/biome_service/src/documentation/mod.rs
@@ -6,6 +6,7 @@ use biome_console::fmt::{Display, Formatter};
 use biome_console::{Padding, markup};
 use biome_css_syntax::CssLanguage;
 use biome_graphql_syntax::GraphqlLanguage;
+use biome_html_syntax::HtmlLanguage;
 use biome_js_syntax::JsLanguage;
 use biome_json_syntax::JsonLanguage;
 use biome_rowan::Language;
@@ -53,6 +54,7 @@ impl RulesVisitor {
         };
 
         biome_graphql_analyze::visit_registry(&mut visitor);
+        biome_html_analyze::visit_registry(&mut visitor);
         biome_css_analyze::visit_registry(&mut visitor);
         biome_json_analyze::visit_registry(&mut visitor);
         biome_js_analyze::visit_registry(&mut visitor);
@@ -121,6 +123,16 @@ impl RegistryVisitor<GraphqlLanguage> for RulesVisitor {
     }
 }
 
+impl RegistryVisitor<HtmlLanguage> for RulesVisitor {
+    fn record_rule<R>(&mut self)
+    where
+        R: Rule<Options: Default, Query: Queryable<Language = HtmlLanguage, Output: Clone>>
+            + 'static,
+    {
+        self.store_rule::<R, HtmlLanguage>();
+    }
+}
+
 impl biome_console::fmt::Display for ExplainRule {
     fn fmt(&self, fmt: &mut Formatter) -> std::io::Result<()> {
         let metadata = &self.metadata;
diff --git a/crates/biome_service/src/file_handlers/css.rs b/crates/biome_service/src/file_handlers/css.rs
index fab8f6773e23..aab0fcfe6e0b 100644
--- a/crates/biome_service/src/file_handlers/css.rs
+++ b/crates/biome_service/src/file_handlers/css.rs
@@ -697,13 +697,12 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                 }
 
                 for action in signal.actions() {
-                    // suppression actions should not be part of the fixes (safe or suggested)
-                    if action.is_suppression() {
-                        continue;
-                    }
-
                     match params.fix_file_mode {
                         FixFileMode::SafeFixes => {
+                            // suppression actions should not be part of safe fixes
+                            if action.is_suppression() {
+                                continue;
+                            }
                             if action.applicability == Applicability::MaybeIncorrect {
                                 skipped_suggested_fixes += 1;
                             }
@@ -722,7 +721,9 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                             }
                         }
                         FixFileMode::ApplySuppressions => {
-                            // TODO: to implement
+                            if action.is_suppression() {
+                                return ControlFlow::Break(action);
+                            }
                         }
                     }
                 }
diff --git a/crates/biome_service/src/file_handlers/graphql.rs b/crates/biome_service/src/file_handlers/graphql.rs
index 355c2c856661..1ddb5f04dea6 100644
--- a/crates/biome_service/src/file_handlers/graphql.rs
+++ b/crates/biome_service/src/file_handlers/graphql.rs
@@ -576,13 +576,12 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
             }
 
             for action in signal.actions() {
-                // suppression actions should not be part of the fixes (safe or suggested)
-                if action.is_suppression() {
-                    continue;
-                }
-
                 match params.fix_file_mode {
                     FixFileMode::SafeFixes => {
+                        // suppression actions should not be part of safe fixes
+                        if action.is_suppression() {
+                            continue;
+                        }
                         if action.applicability == Applicability::MaybeIncorrect {
                             skipped_suggested_fixes += 1;
                         }
@@ -601,7 +600,9 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                         }
                     }
                     FixFileMode::ApplySuppressions => {
-                        // TODO: implement once a GraphQL suppression action is available
+                        if action.is_suppression() {
+                            return ControlFlow::Break(action);
+                        }
                     }
                 }
             }
diff --git a/crates/biome_service/src/file_handlers/grit.rs b/crates/biome_service/src/file_handlers/grit.rs
index e201510c0752..f7fc1fcf2c13 100644
--- a/crates/biome_service/src/file_handlers/grit.rs
+++ b/crates/biome_service/src/file_handlers/grit.rs
@@ -426,7 +426,6 @@ fn lint(params: LintParams) -> LintResults {
 
 #[tracing::instrument(level = "debug", skip(params))]
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
-    // We don't have analyzer rules yet
     let tree: GritRoot = params.parse.tree();
     let code = if params.should_format {
         format_node(
diff --git a/crates/biome_service/src/file_handlers/html.rs b/crates/biome_service/src/file_handlers/html.rs
index 8b7dd6ebf578..650227b06877 100644
--- a/crates/biome_service/src/file_handlers/html.rs
+++ b/crates/biome_service/src/file_handlers/html.rs
@@ -1,25 +1,25 @@
 use super::{
-    AnalyzerCapabilities, Capabilities, CodeActionsParams, DebugCapabilities, DocumentFileSource,
-    EnabledForPath, ExtensionHandler, FixAllParams, FormatEmbedNode, FormatterCapabilities,
-    LintParams, LintResults, ParseEmbedResult, ParseResult, ParserCapabilities, SearchCapabilities,
-    UpdateSnippetsNodes,
+    AnalyzerCapabilities, AnalyzerVisitorBuilder, Capabilities, CodeActionsParams,
+    DebugCapabilities, DocumentFileSource, EnabledForPath, ExtensionHandler, FixAllParams,
+    FormatEmbedNode, FormatterCapabilities, LintParams, LintResults, ParseEmbedResult, ParseResult,
+    ParserCapabilities, ProcessLint, SearchCapabilities, UpdateSnippetsNodes, is_diagnostic_error,
 };
 use crate::settings::{OverrideSettings, check_feature_activity, check_override_feature_activity};
-use crate::workspace::EmbeddedSnippet;
+use crate::workspace::{CodeAction, EmbeddedSnippet, FixAction, FixFileMode};
 use crate::workspace::{FixFileResult, PullActionsResult};
 use crate::{
     WorkspaceError,
     settings::{ServiceLanguage, Settings},
     workspace::GetSyntaxTreeResult,
 };
-use biome_analyze::AnalyzerOptions;
+use biome_analyze::{AnalysisFilter, AnalyzerOptions, ControlFlow, Never, RuleError};
 use biome_configuration::html::{
     HtmlAssistConfiguration, HtmlAssistEnabled, HtmlFormatterConfiguration, HtmlFormatterEnabled,
     HtmlLinterConfiguration, HtmlLinterEnabled, HtmlParseInterpolation, HtmlParserConfiguration,
 };
 use biome_css_parser::parse_css_with_offset_and_cache;
 use biome_css_syntax::{CssFileSource, CssLanguage};
-use biome_diagnostics::{Diagnostic, Severity};
+use biome_diagnostics::Applicability;
 use biome_formatter::format_element::{Interned, LineMode};
 use biome_formatter::prelude::{Document, Tag};
 use biome_formatter::{
@@ -27,6 +27,7 @@ use biome_formatter::{
     LineWidth, Printed,
 };
 use biome_fs::BiomePath;
+use biome_html_analyze::analyze;
 use biome_html_factory::make::ident;
 use biome_html_formatter::context::SelfCloseVoidElements;
 use biome_html_formatter::{
@@ -43,8 +44,9 @@ use biome_json_syntax::{JsonFileSource, JsonLanguage};
 use biome_parser::AnyParse;
 use biome_rowan::{AstNode, AstNodeList, BatchMutation, NodeCache, SendNode};
 use camino::Utf8Path;
+use std::borrow::Cow;
 use std::fmt::Debug;
-use tracing::instrument;
+use tracing::{debug_span, error, instrument, trace_span};
 
 #[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
@@ -665,51 +667,234 @@ fn format_embedded(
 
 #[tracing::instrument(level = "debug", skip(params))]
 fn lint(params: LintParams) -> LintResults {
-    let diagnostics = params
-        .parse
-        .into_serde_diagnostics(params.diagnostic_offset);
-
-    let diagnostic_count = diagnostics.len() as u32;
-    let skipped_diagnostics = diagnostic_count.saturating_sub(diagnostics.len() as u32);
-    let errors = diagnostics
-        .iter()
-        .filter(|diag| diag.severity() <= Severity::Error)
-        .count();
-
-    LintResults {
-        diagnostics,
-        errors,
-        skipped_diagnostics,
-    }
+    let workspace_settings = &params.settings;
+    let analyzer_options = workspace_settings.analyzer_options::<HtmlLanguage>(
+        params.path,
+        &params.language,
+        params.suppression_reason.as_deref(),
+    );
+    let tree = params.parse.tree();
+
+    let (enabled_rules, disabled_rules, analyzer_options) =
+        AnalyzerVisitorBuilder::new(params.settings, analyzer_options)
+            .with_only(params.only)
+            .with_skip(params.skip)
+            .with_path(params.path.as_path())
+            .with_enabled_selectors(params.enabled_selectors)
+            .with_project_layout(params.project_layout.clone())
+            .finish();
+
+    let filter = AnalysisFilter {
+        categories: params.categories,
+        enabled_rules: Some(enabled_rules.as_slice()),
+        disabled_rules: &disabled_rules,
+        range: None,
+    };
+
+    let mut process_lint = ProcessLint::new(&params);
+
+    let (_, analyze_diagnostics) = analyze(&tree, filter, &analyzer_options, |signal| {
+        process_lint.process_signal(signal)
+    });
+
+    process_lint.into_result(
+        params
+            .parse
+            .into_serde_diagnostics(params.diagnostic_offset),
+        analyze_diagnostics,
+    )
 }
 
-pub(crate) fn code_actions(_params: CodeActionsParams) -> PullActionsResult {
-    PullActionsResult { actions: vec![] }
+pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
+    let CodeActionsParams {
+        parse,
+        range,
+        settings,
+        path,
+        module_graph: _,
+        project_layout,
+        language,
+        only,
+        skip,
+        suppression_reason,
+        enabled_rules: rules,
+        plugins: _,
+        categories,
+    } = params;
+    let _ = debug_span!("Code actions HTML", range =? range, path =? path).entered();
+    let tree = parse.tree();
+    let _ = trace_span!("Parsed file", tree =? tree).entered();
+    let Some(_) = language.to_html_file_source() else {
+        error!("Could not determine the HTML file source of the file");
+        return PullActionsResult {
+            actions: Vec::new(),
+        };
+    };
+    let analyzer_options =
+        settings.analyzer_options::<HtmlLanguage>(path, &language, suppression_reason.as_deref());
+    let mut actions = Vec::new();
+    let (enabled_rules, disabled_rules, analyzer_options) =
+        AnalyzerVisitorBuilder::new(settings, analyzer_options)
+            .with_only(only)
+            .with_skip(skip)
+            .with_path(path.as_path())
+            .with_enabled_selectors(rules)
+            .with_project_layout(project_layout)
+            .finish();
+
+    let filter = AnalysisFilter {
+        categories,
+        enabled_rules: Some(enabled_rules.as_slice()),
+        disabled_rules: &disabled_rules,
+        range,
+    };
+
+    analyze(&tree, filter, &analyzer_options, |signal| {
+        actions.extend(signal.actions().into_code_action_iter().map(|item| {
+            CodeAction {
+                category: item.category.clone(),
+                rule_name: item
+                    .rule_name
+                    .map(|(group, name)| (Cow::Borrowed(group), Cow::Borrowed(name))),
+                suggestion: item.suggestion,
+            }
+        }));
+
+        ControlFlow::<Never>::Continue(())
+    });
+
+    PullActionsResult { actions }
 }
 
 #[tracing::instrument(level = "debug", skip(params))]
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
-    // We don't have analyzer rules yet
-    let tree: HtmlRoot = params.parse.tree();
-    let code = if params.should_format {
-        format_node(
-            params
-                .settings
-                .format_options::<HtmlLanguage>(params.biome_path, &params.document_file_source),
-            tree.syntax(),
-            false,
-        )?
-        .print()?
-        .into_code()
-    } else {
-        tree.syntax().to_string()
+    let mut tree: HtmlRoot = params.parse.tree();
+
+    // Compute final rules (taking `overrides` into account)
+    let rules = params.settings.as_linter_rules(params.biome_path.as_path());
+    let analyzer_options = params.settings.analyzer_options::<HtmlLanguage>(
+        params.biome_path,
+        &params.document_file_source,
+        params.suppression_reason.as_deref(),
+    );
+    let (enabled_rules, disabled_rules, analyzer_options) =
+        AnalyzerVisitorBuilder::new(params.settings, analyzer_options)
+            .with_only(params.only)
+            .with_skip(params.skip)
+            .with_path(params.biome_path.as_path())
+            .with_enabled_selectors(params.enabled_rules)
+            .with_project_layout(params.project_layout)
+            .finish();
+
+    let filter = AnalysisFilter {
+        categories: params.rule_categories,
+        enabled_rules: Some(enabled_rules.as_slice()),
+        disabled_rules: &disabled_rules,
+        range: None,
     };
-    Ok(FixFileResult {
-        code,
-        skipped_suggested_fixes: 0,
-        actions: vec![],
-        errors: 0,
-    })
+
+    let mut actions = Vec::new();
+    let mut skipped_suggested_fixes = 0;
+    let mut errors: u16 = 0;
+
+    loop {
+        let (action, _) = analyze(&tree, filter, &analyzer_options, |signal| {
+            let current_diagnostic = signal.diagnostic();
+
+            if let Some(diagnostic) = current_diagnostic.as_ref()
+                && is_diagnostic_error(diagnostic, rules.as_deref())
+            {
+                errors += 1;
+            }
+
+            for action in signal.actions() {
+                match params.fix_file_mode {
+                    FixFileMode::SafeFixes => {
+                        // suppression actions should not be part of safe fixes
+                        if action.is_suppression() {
+                            continue;
+                        }
+                        if action.applicability == Applicability::MaybeIncorrect {
+                            skipped_suggested_fixes += 1;
+                        }
+                        if action.applicability == Applicability::Always {
+                            errors = errors.saturating_sub(1);
+                            return ControlFlow::Break(action);
+                        }
+                    }
+                    FixFileMode::SafeAndUnsafeFixes => {
+                        // suppression actions should not be part of unsafe fixes either
+                        if action.is_suppression() {
+                            continue;
+                        }
+                        if matches!(
+                            action.applicability,
+                            Applicability::Always | Applicability::MaybeIncorrect
+                        ) {
+                            errors = errors.saturating_sub(1);
+                            return ControlFlow::Break(action);
+                        }
+                    }
+                    FixFileMode::ApplySuppressions => {
+                        if action.is_suppression() {
+                            return ControlFlow::Break(action);
+                        }
+                    }
+                }
+            }
+
+            ControlFlow::Continue(())
+        });
+
+        match action {
+            Some(action) => {
+                if let (root, Some((range, _))) =
+                    action.mutation.commit_with_text_range_and_edit(true)
+                {
+                    tree = match HtmlRoot::cast(root) {
+                        Some(tree) => tree,
+                        None => {
+                            return Err(WorkspaceError::RuleError(
+                                RuleError::ReplacedRootWithNonRootError {
+                                    rule_name: action.rule_name.map(|(group, rule)| {
+                                        (Cow::Borrowed(group), Cow::Borrowed(rule))
+                                    }),
+                                },
+                            ));
+                        }
+                    };
+                    actions.push(FixAction {
+                        rule_name: action
+                            .rule_name
+                            .map(|(group, rule)| (Cow::Borrowed(group), Cow::Borrowed(rule))),
+                        range,
+                    });
+                }
+            }
+            None => {
+                let code = if params.should_format {
+                    format_node(
+                        params.settings.format_options::<HtmlLanguage>(
+                            params.biome_path,
+                            &params.document_file_source,
+                        ),
+                        tree.syntax(),
+                        true,
+                    )?
+                    .print()?
+                    .into_code()
+                } else {
+                    tree.syntax().to_string()
+                };
+                return Ok(FixFileResult {
+                    code,
+                    skipped_suggested_fixes,
+                    actions,
+                    errors: errors.into(),
+                });
+            }
+        }
+    }
 }
 
 #[instrument(level = "debug", skip_all)]
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index 1cb39a519805..324e8659dced 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -919,6 +919,7 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                             }
                         }
                         FixFileMode::SafeFixes => {
+                            // suppression actions should not be part of safe fixes
                             if action.is_suppression() {
                                 continue;
                             }
diff --git a/crates/biome_service/src/file_handlers/json.rs b/crates/biome_service/src/file_handlers/json.rs
index ef5b0289bc68..a2eab315aaf9 100644
--- a/crates/biome_service/src/file_handlers/json.rs
+++ b/crates/biome_service/src/file_handlers/json.rs
@@ -696,7 +696,41 @@ fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
                         }
                     }
                     FixFileMode::ApplySuppressions => {
-                        // TODO: implement once a JSON suppression action is available
+                        for action in signal.actions() {
+                            match params.fix_file_mode {
+                                FixFileMode::SafeFixes => {
+                                    // suppression actions should not be part of safe fixes
+                                    if action.is_suppression() {
+                                        continue;
+                                    }
+                                    if action.applicability == Applicability::MaybeIncorrect {
+                                        skipped_suggested_fixes += 1;
+                                    }
+                                    if action.applicability == Applicability::Always {
+                                        errors = errors.saturating_sub(1);
+                                        return ControlFlow::Break(action);
+                                    }
+                                }
+                                FixFileMode::SafeAndUnsafeFixes => {
+                                    // suppression actions should not be part of safe and unsafe fixes
+                                    if action.is_suppression() {
+                                        continue;
+                                    }
+                                    if matches!(
+                                        action.applicability,
+                                        Applicability::Always | Applicability::MaybeIncorrect
+                                    ) {
+                                        errors = errors.saturating_sub(1);
+                                        return ControlFlow::Break(action);
+                                    }
+                                }
+                                FixFileMode::ApplySuppressions => {
+                                    if action.is_suppression() {
+                                        return ControlFlow::Break(action);
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
index 67a18fd68007..35144f46df13 100644
--- a/crates/biome_service/src/file_handlers/mod.rs
+++ b/crates/biome_service/src/file_handlers/mod.rs
@@ -32,7 +32,7 @@ use biome_graphql_analyze::METADATA as graphql_metadata;
 use biome_graphql_syntax::{GraphqlFileSource, GraphqlLanguage};
 use biome_grit_patterns::{GritQuery, GritQueryEffect, GritTargetFile};
 use biome_grit_syntax::file_source::GritFileSource;
-use biome_html_syntax::HtmlFileSource;
+use biome_html_syntax::{HtmlFileSource, HtmlLanguage};
 use biome_js_analyze::METADATA as js_metadata;
 use biome_js_parser::{JsParserOptions, parse};
 use biome_js_syntax::{
@@ -1021,6 +1021,25 @@ impl RegistryVisitor<GraphqlLanguage> for SyntaxVisitor<'_> {
     }
 }
 
+impl RegistryVisitor<HtmlLanguage> for SyntaxVisitor<'_> {
+    fn record_category<C: GroupCategory<Language = HtmlLanguage>>(&mut self) {
+        if C::CATEGORY == RuleCategory::Syntax {
+            C::record_groups(self)
+        }
+    }
+
+    fn record_rule<R>(&mut self)
+    where
+        R: Rule<Options: Default, Query: Queryable<Language = HtmlLanguage, Output: Clone>>
+            + 'static,
+    {
+        self.enabled_rules.push(RuleFilter::Rule(
+            <R::Group as RuleGroup>::NAME,
+            R::METADATA.name,
+        ))
+    }
+}
+
 /// Type meant to register all the lint rules for each language supported by Biome
 ///
 #[derive(Debug)]
@@ -1335,6 +1354,30 @@ impl RegistryVisitor<GraphqlLanguage> for LintVisitor<'_, '_> {
     }
 }
 
+impl RegistryVisitor<HtmlLanguage> for LintVisitor<'_, '_> {
+    fn record_category<C: GroupCategory<Language = HtmlLanguage>>(&mut self) {
+        if C::CATEGORY == RuleCategory::Lint {
+            C::record_groups(self)
+        }
+    }
+
+    fn record_group<G: RuleGroup<Language = HtmlLanguage>>(&mut self) {
+        G::record_rules(self)
+    }
+
+    fn record_rule<R>(&mut self)
+    where
+        R: Rule<Options: Default, Query: Queryable<Language = HtmlLanguage, Output: Clone>>
+            + 'static,
+    {
+        self.push_rule::<R, <R::Query as Queryable>::Language>(
+            biome_html_analyze::METADATA
+                .find_rule(R::Group::NAME, R::METADATA.name)
+                .map(RuleFilter::from),
+        )
+    }
+}
+
 struct AssistsVisitor<'a, 'b> {
     settings: &'b Settings,
     enabled_rules: Vec<RuleFilter<'a>>,
@@ -1487,6 +1530,22 @@ impl RegistryVisitor<GraphqlLanguage> for AssistsVisitor<'_, '_> {
     }
 }
 
+impl RegistryVisitor<HtmlLanguage> for AssistsVisitor<'_, '_> {
+    fn record_category<C: GroupCategory<Language = HtmlLanguage>>(&mut self) {
+        if C::CATEGORY == RuleCategory::Action {
+            C::record_groups(self)
+        }
+    }
+
+    fn record_rule<R>(&mut self)
+    where
+        R: Rule<Options: Default, Query: Queryable<Language = HtmlLanguage, Output: Clone>>
+            + 'static,
+    {
+        self.push_rule::<R, <R::Query as Queryable>::Language>();
+    }
+}
+
 pub(crate) struct AnalyzerVisitorBuilder<'a> {
     settings: &'a Settings,
     only: Option<&'a [AnalyzerSelector]>,
@@ -1564,6 +1623,7 @@ impl<'b> AnalyzerVisitorBuilder<'b> {
         biome_css_analyze::visit_registry(&mut syntax);
         biome_json_analyze::visit_registry(&mut syntax);
         biome_graphql_analyze::visit_registry(&mut syntax);
+        biome_html_analyze::visit_registry(&mut syntax);
         enabled_rules.extend(syntax.enabled_rules);
 
         let package_json = self
@@ -1584,6 +1644,7 @@ impl<'b> AnalyzerVisitorBuilder<'b> {
         biome_css_analyze::visit_registry(&mut lint);
         biome_json_analyze::visit_registry(&mut lint);
         biome_graphql_analyze::visit_registry(&mut lint);
+        biome_html_analyze::visit_registry(&mut lint);
         let (linter_enabled_rules, linter_disabled_rules) = lint.finish();
         enabled_rules.extend(linter_enabled_rules);
         disabled_rules.extend(linter_disabled_rules);
@@ -1594,6 +1655,7 @@ impl<'b> AnalyzerVisitorBuilder<'b> {
         biome_css_analyze::visit_registry(&mut assist);
         biome_json_analyze::visit_registry(&mut assist);
         biome_graphql_analyze::visit_registry(&mut assist);
+        biome_html_analyze::visit_registry(&mut assist);
         let (assists_enabled_rules, assists_disabled_rules) = assist.finish();
         enabled_rules.extend(assists_enabled_rules);
         disabled_rules.extend(assists_disabled_rules);
diff --git a/xtask/codegen/Cargo.toml b/xtask/codegen/Cargo.toml
index 3dac9cddb480..ee723c4fbfaf 100644
--- a/xtask/codegen/Cargo.toml
+++ b/xtask/codegen/Cargo.toml
@@ -24,6 +24,9 @@ biome_diagnostics     = { workspace = true, optional = true }
 biome_graphql_analyze = { workspace = true, optional = true }
 biome_graphql_parser  = { workspace = true, optional = true }
 biome_graphql_syntax  = { workspace = true, optional = true }
+biome_html_analyze    = { workspace = true, optional = true }
+biome_html_parser     = { workspace = true, optional = true }
+biome_html_syntax     = { workspace = true, optional = true }
 biome_js_analyze      = { workspace = true, optional = true }
 biome_js_factory      = { workspace = true, optional = true }
 biome_js_formatter    = { workspace = true, optional = true }
@@ -51,6 +54,8 @@ configuration = [
   "biome_css_syntax",
   "biome_graphql_analyze",
   "biome_graphql_syntax",
+  "biome_html_analyze",
+  "biome_html_syntax",
   "biome_rowan",
   "pulldown-cmark",
   "biome_diagnostics",
diff --git a/xtask/codegen/src/generate_analyzer.rs b/xtask/codegen/src/generate_analyzer.rs
index 5a7658a48ec8..007f1d6de21e 100644
--- a/xtask/codegen/src/generate_analyzer.rs
+++ b/xtask/codegen/src/generate_analyzer.rs
@@ -10,6 +10,7 @@ pub fn generate_analyzer() -> Result<()> {
     generate_json_analyzer()?;
     generate_css_analyzer()?;
     generate_graphql_analyzer()?;
+    generate_html_analyzer()?;
     Ok(())
 }
 
@@ -49,6 +50,14 @@ fn generate_graphql_analyzer() -> Result<()> {
     update_graphql_registry_builder(analyzers)
 }
 
+fn generate_html_analyzer() -> Result<()> {
+    let base_path = project_root().join("crates/biome_html_analyze/src");
+    let mut analyzers = BTreeMap::new();
+    generate_category("lint", &mut analyzers, &base_path)?;
+
+    update_html_registry_builder(analyzers)
+}
+
 fn generate_category(
     name: &'static str,
     entries: &mut BTreeMap<&'static str, TokenStream>,
@@ -283,3 +292,22 @@ fn update_graphql_registry_builder(analyzers: BTreeMap<&'static str, TokenStream
 
     Ok(())
 }
+
+fn update_html_registry_builder(analyzers: BTreeMap<&'static str, TokenStream>) -> Result<()> {
+    let path = project_root().join("crates/biome_html_analyze/src/registry.rs");
+
+    let categories = analyzers.into_values();
+
+    let tokens = xtask::reformat(quote! {
+        use biome_analyze::RegistryVisitor;
+        use biome_html_syntax::HtmlLanguage;
+
+        pub fn visit_registry<V: RegistryVisitor<HtmlLanguage>>(registry: &mut V) {
+            #( #categories )*
+        }
+    })?;
+
+    fs2::write(path, tokens)?;
+
+    Ok(())
+}
diff --git a/xtask/codegen/src/generate_configuration.rs b/xtask/codegen/src/generate_configuration.rs
index 6808eaa65794..f532a9b2ce42 100644
--- a/xtask/codegen/src/generate_configuration.rs
+++ b/xtask/codegen/src/generate_configuration.rs
@@ -3,6 +3,7 @@ use biome_analyze::{
 };
 use biome_css_syntax::CssLanguage;
 use biome_graphql_syntax::GraphqlLanguage;
+use biome_html_syntax::HtmlLanguage;
 use biome_js_syntax::JsLanguage;
 use biome_json_syntax::JsonLanguage;
 use biome_string_case::Case;
@@ -106,6 +107,25 @@ impl RegistryVisitor<GraphqlLanguage> for LintRulesVisitor {
     }
 }
 
+impl RegistryVisitor<HtmlLanguage> for LintRulesVisitor {
+    fn record_category<C: GroupCategory<Language = HtmlLanguage>>(&mut self) {
+        if matches!(C::CATEGORY, RuleCategory::Lint) {
+            C::record_groups(self);
+        }
+    }
+
+    fn record_rule<R>(&mut self)
+    where
+        R: Rule<Options: Default, Query: Queryable<Language = HtmlLanguage, Output: Clone>>
+            + 'static,
+    {
+        self.groups
+            .entry(<R::Group as RuleGroup>::NAME)
+            .or_default()
+            .insert(R::METADATA.name, R::METADATA);
+    }
+}
+
 // ======= ASSIST ======
 #[derive(Default)]
 struct AssistActionsVisitor {
@@ -187,6 +207,25 @@ impl RegistryVisitor<GraphqlLanguage> for AssistActionsVisitor {
     }
 }
 
+impl RegistryVisitor<HtmlLanguage> for AssistActionsVisitor {
+    fn record_category<C: GroupCategory<Language = HtmlLanguage>>(&mut self) {
+        if matches!(C::CATEGORY, RuleCategory::Action) {
+            C::record_groups(self);
+        }
+    }
+
+    fn record_rule<R>(&mut self)
+    where
+        R: Rule<Options: Default, Query: Queryable<Language = HtmlLanguage, Output: Clone>>
+            + 'static,
+    {
+        self.groups
+            .entry(<R::Group as RuleGroup>::NAME)
+            .or_default()
+            .insert(R::METADATA.name, R::METADATA);
+    }
+}
+
 pub(crate) fn generate_rule_options(mode: Mode) -> Result<()> {
     let rule_options_root = get_analyzer_rule_options_path();
     let lib_root = rule_options_root.join("lib.rs");
@@ -200,6 +239,8 @@ pub(crate) fn generate_rule_options(mode: Mode) -> Result<()> {
     biome_css_analyze::visit_registry(&mut assist_visitor);
     biome_graphql_analyze::visit_registry(&mut lint_visitor);
     biome_graphql_analyze::visit_registry(&mut assist_visitor);
+    biome_html_analyze::visit_registry(&mut lint_visitor);
+    biome_html_analyze::visit_registry(&mut assist_visitor);
 
     let mut rule_names = BTreeSet::default();
     let mut lib_exports = vec![quote! {
@@ -257,6 +298,8 @@ pub(crate) fn generate_rules_configuration(mode: Mode) -> Result<()> {
     biome_css_analyze::visit_registry(&mut assist_visitor);
     biome_graphql_analyze::visit_registry(&mut lint_visitor);
     biome_graphql_analyze::visit_registry(&mut assist_visitor);
+    biome_html_analyze::visit_registry(&mut lint_visitor);
+    biome_html_analyze::visit_registry(&mut assist_visitor);
 
     // let LintRulesVisitor { groups } = lint_visitor;
 
diff --git a/xtask/rules_check/Cargo.toml b/xtask/rules_check/Cargo.toml
index 6c063980f645..dcfa4a09407b 100644
--- a/xtask/rules_check/Cargo.toml
+++ b/xtask/rules_check/Cargo.toml
@@ -19,6 +19,9 @@ biome_fs              = { workspace = true }
 biome_graphql_analyze = { workspace = true }
 biome_graphql_parser  = { workspace = true }
 biome_graphql_syntax  = { workspace = true }
+biome_html_analyze    = { workspace = true }
+biome_html_parser     = { workspace = true }
+biome_html_syntax     = { workspace = true }
 biome_js_analyze      = { workspace = true }
 biome_js_parser       = { workspace = true }
 biome_js_syntax       = { workspace = true }
diff --git a/xtask/rules_check/src/lib.rs b/xtask/rules_check/src/lib.rs
index f2bcc080b11a..d4a48da6f66a 100644
--- a/xtask/rules_check/src/lib.rs
+++ b/xtask/rules_check/src/lib.rs
@@ -18,6 +18,8 @@ use biome_css_syntax::CssLanguage;
 use biome_deserialize::json::deserialize_from_json_ast;
 use biome_diagnostics::{DiagnosticExt, PrintDiagnostic, Severity};
 use biome_graphql_syntax::GraphqlLanguage;
+use biome_html_parser::HtmlParseOptions;
+use biome_html_syntax::HtmlLanguage;
 use biome_js_parser::JsParserOptions;
 use biome_js_syntax::{EmbeddingKind, JsFileSource, JsLanguage, TextSize};
 use biome_json_factory::make;
@@ -125,11 +127,22 @@ pub fn check_rules() -> anyhow::Result<()> {
         }
     }
 
+    impl RegistryVisitor<HtmlLanguage> for LintRulesVisitor {
+        fn record_rule<R>(&mut self)
+        where
+            R: Rule<Options: Default, Query: Queryable<Language = HtmlLanguage, Output: Clone>>
+                + 'static,
+        {
+            self.push_rule::<R, <R::Query as Queryable>::Language>()
+        }
+    }
+
     let mut visitor = LintRulesVisitor::default();
     biome_js_analyze::visit_registry(&mut visitor);
     biome_json_analyze::visit_registry(&mut visitor);
     biome_css_analyze::visit_registry(&mut visitor);
     biome_graphql_analyze::visit_registry(&mut visitor);
+    biome_html_analyze::visit_registry(&mut visitor);
 
     let LintRulesVisitor { groups, errors } = visitor;
     if !errors.is_empty() {
@@ -392,7 +405,45 @@ fn assert_lint(
                 });
             }
         }
-        DocumentFileSource::Html(..) => todo!("HTML analysis is not yet supported"),
+        DocumentFileSource::Html(..) => {
+            let parse = biome_html_parser::parse_html(code, HtmlParseOptions::default());
+
+            if parse.has_errors() {
+                for diag in parse.into_diagnostics() {
+                    let error = diag
+                        .with_file_path(test.file_path())
+                        .with_file_source_code(code);
+                    diagnostics.write_parse_error(error);
+                }
+            } else {
+                let root = parse.tree();
+
+                let rule_filter = RuleFilter::Rule(group, rule);
+                let filter = AnalysisFilter {
+                    enabled_rules: Some(slice::from_ref(&rule_filter)),
+                    ..AnalysisFilter::default()
+                };
+
+                let options = test.create_analyzer_options::<HtmlLanguage>(config)?;
+
+                biome_html_analyze::analyze(&root, filter, &options, |signal| {
+                    if let Some(mut diag) = signal.diagnostic() {
+                        for action in signal.actions() {
+                            if !action.is_suppression() {
+                                diag = diag.add_code_suggestion(action.into());
+                            }
+                        }
+
+                        let error = diag
+                            .with_file_path(test.file_path())
+                            .with_file_source_code(code);
+                        diagnostics.write_diagnostic(error);
+                    }
+
+                    ControlFlow::<()>::Continue(())
+                });
+            }
+        }
         DocumentFileSource::Grit(..) => todo!("Grit analysis is not yet supported"),
 
         // Unknown code blocks should be ignored by tests