diff --git a/.changeset/happy-cats-drive.md b/.changeset/happy-cats-drive.md
new file mode 100644
index 000000000000..8bccf9850ebd
--- /dev/null
+++ b/.changeset/happy-cats-drive.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#8605](https://github.com/biomejs/biome/issues/8605): Text expressions in some template languages (`{{ expr }}` or `{ expr }`) at the top level of an HTML document no longer causes panicking.
diff --git a/crates/biome_html_factory/src/generated/node_factory.rs b/crates/biome_html_factory/src/generated/node_factory.rs
index 84c558f2a850..65e856d2775a 100644
--- a/crates/biome_html_factory/src/generated/node_factory.rs
+++ b/crates/biome_html_factory/src/generated/node_factory.rs
@@ -66,6 +66,20 @@ impl HtmlAttributeBuilder {
         ))
     }
 }
+pub fn html_attribute_double_text_expression(
+    l_double_curly_token: SyntaxToken,
+    expression: HtmlTextExpression,
+    r_double_curly_token: SyntaxToken,
+) -> HtmlAttributeDoubleTextExpression {
+    HtmlAttributeDoubleTextExpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION,
+        [
+            Some(SyntaxElement::Token(l_double_curly_token)),
+            Some(SyntaxElement::Node(expression.into_syntax())),
+            Some(SyntaxElement::Token(r_double_curly_token)),
+        ],
+    ))
+}
 pub fn html_attribute_initializer_clause(
     eq_token: SyntaxToken,
     value: AnyHtmlAttributeInitializer,
@@ -84,6 +98,20 @@ pub fn html_attribute_name(value_token: SyntaxToken) -> HtmlAttributeName {
         [Some(SyntaxElement::Token(value_token))],
     ))
 }
+pub fn html_attribute_single_text_expression(
+    l_curly_token: SyntaxToken,
+    expression: HtmlTextExpression,
+    r_curly_token: SyntaxToken,
+) -> HtmlAttributeSingleTextExpression {
+    HtmlAttributeSingleTextExpression::unwrap_cast(SyntaxNode::new_detached(
+        HtmlSyntaxKind::HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION,
+        [
+            Some(SyntaxElement::Token(l_curly_token)),
+            Some(SyntaxElement::Node(expression.into_syntax())),
+            Some(SyntaxElement::Token(r_curly_token)),
+        ],
+    ))
+}
 pub fn html_cdata_section(
     cdata_start_token: SyntaxToken,
     content_token: SyntaxToken,
diff --git a/crates/biome_html_factory/src/generated/syntax_factory.rs b/crates/biome_html_factory/src/generated/syntax_factory.rs
index efe1463d5f9a..73a28cc20f9b 100644
--- a/crates/biome_html_factory/src/generated/syntax_factory.rs
+++ b/crates/biome_html_factory/src/generated/syntax_factory.rs
@@ -102,6 +102,39 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 }
                 slots.into_node(HTML_ATTRIBUTE, children)
             }
+            HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["{{"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && HtmlTextExpression::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T!["}}"]
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION, children)
+            }
             HTML_ATTRIBUTE_INITIALIZER_CLAUSE => {
                 let mut elements = (&children).into_iter();
                 let mut slots: RawNodeSlots<2usize> = RawNodeSlots::default();
@@ -147,6 +180,39 @@ impl SyntaxFactory for HtmlSyntaxFactory {
                 }
                 slots.into_node(HTML_ATTRIBUTE_NAME, children)
             }
+            HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION => {
+                let mut elements = (&children).into_iter();
+                let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
+                let mut current_element = elements.next();
+                if let Some(element) = &current_element
+                    && element.kind() == T!['{']
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && HtmlTextExpression::can_cast(element.kind())
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if let Some(element) = &current_element
+                    && element.kind() == T!['}']
+                {
+                    slots.mark_present();
+                    current_element = elements.next();
+                }
+                slots.next_slot();
+                if current_element.is_some() {
+                    return RawSyntaxNode::new(
+                        HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION.to_bogus(),
+                        children.into_iter().map(Some),
+                    );
+                }
+                slots.into_node(HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION, children)
+            }
             HTML_CDATA_SECTION => {
                 let mut elements = (&children).into_iter();
                 let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default();
diff --git a/crates/biome_html_formatter/src/generated.rs b/crates/biome_html_formatter/src/generated.rs
index 196ebbe7f7b7..6245f837066b 100644
--- a/crates/biome_html_formatter/src/generated.rs
+++ b/crates/biome_html_formatter/src/generated.rs
@@ -120,6 +120,19 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlAttribute {
         )
     }
 }
+impl FormatRule < biome_html_syntax :: HtmlAttributeDoubleTextExpression > for crate :: html :: auxiliary :: attribute_double_text_expression :: FormatHtmlAttributeDoubleTextExpression { type Context = HtmlFormatContext ; # [inline (always)] fn fmt (& self , node : & biome_html_syntax :: HtmlAttributeDoubleTextExpression , f : & mut HtmlFormatter) -> FormatResult < () > { FormatNodeRule :: < biome_html_syntax :: HtmlAttributeDoubleTextExpression > :: fmt (self , node , f) } }
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlAttributeDoubleTextExpression {
+    type Format < 'a > = FormatRefWithRule < 'a , biome_html_syntax :: HtmlAttributeDoubleTextExpression , crate :: html :: auxiliary :: attribute_double_text_expression :: FormatHtmlAttributeDoubleTextExpression > ;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule :: new (self , crate :: html :: auxiliary :: attribute_double_text_expression :: FormatHtmlAttributeDoubleTextExpression :: default ())
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlAttributeDoubleTextExpression {
+    type Format = FormatOwnedWithRule < biome_html_syntax :: HtmlAttributeDoubleTextExpression , crate :: html :: auxiliary :: attribute_double_text_expression :: FormatHtmlAttributeDoubleTextExpression > ;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule :: new (self , crate :: html :: auxiliary :: attribute_double_text_expression :: FormatHtmlAttributeDoubleTextExpression :: default ())
+    }
+}
 impl FormatRule<biome_html_syntax::HtmlAttributeInitializerClause>
     for crate::html::auxiliary::attribute_initializer_clause::FormatHtmlAttributeInitializerClause
 {
@@ -190,6 +203,19 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlAttributeName {
         )
     }
 }
+impl FormatRule < biome_html_syntax :: HtmlAttributeSingleTextExpression > for crate :: html :: auxiliary :: attribute_single_text_expression :: FormatHtmlAttributeSingleTextExpression { type Context = HtmlFormatContext ; # [inline (always)] fn fmt (& self , node : & biome_html_syntax :: HtmlAttributeSingleTextExpression , f : & mut HtmlFormatter) -> FormatResult < () > { FormatNodeRule :: < biome_html_syntax :: HtmlAttributeSingleTextExpression > :: fmt (self , node , f) } }
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlAttributeSingleTextExpression {
+    type Format < 'a > = FormatRefWithRule < 'a , biome_html_syntax :: HtmlAttributeSingleTextExpression , crate :: html :: auxiliary :: attribute_single_text_expression :: FormatHtmlAttributeSingleTextExpression > ;
+    fn format(&self) -> Self::Format<'_> {
+        FormatRefWithRule :: new (self , crate :: html :: auxiliary :: attribute_single_text_expression :: FormatHtmlAttributeSingleTextExpression :: default ())
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlAttributeSingleTextExpression {
+    type Format = FormatOwnedWithRule < biome_html_syntax :: HtmlAttributeSingleTextExpression , crate :: html :: auxiliary :: attribute_single_text_expression :: FormatHtmlAttributeSingleTextExpression > ;
+    fn into_format(self) -> Self::Format {
+        FormatOwnedWithRule :: new (self , crate :: html :: auxiliary :: attribute_single_text_expression :: FormatHtmlAttributeSingleTextExpression :: default ())
+    }
+}
 impl FormatRule<biome_html_syntax::HtmlCdataSection>
     for crate::html::auxiliary::cdata_section::FormatHtmlCdataSection
 {
diff --git a/crates/biome_html_formatter/src/html/any/attribute.rs b/crates/biome_html_formatter/src/html/any/attribute.rs
index 561f0dcb2765..a807c7c59488 100644
--- a/crates/biome_html_formatter/src/html/any/attribute.rs
+++ b/crates/biome_html_formatter/src/html/any/attribute.rs
@@ -10,9 +10,9 @@ impl FormatRule<AnyHtmlAttribute> for FormatAnyHtmlAttribute {
         match node {
             AnyHtmlAttribute::AnyVueDirective(node) => node.format().fmt(f),
             AnyHtmlAttribute::HtmlAttribute(node) => node.format().fmt(f),
+            AnyHtmlAttribute::HtmlAttributeDoubleTextExpression(node) => node.format().fmt(f),
+            AnyHtmlAttribute::HtmlAttributeSingleTextExpression(node) => node.format().fmt(f),
             AnyHtmlAttribute::HtmlBogusAttribute(node) => node.format().fmt(f),
-            AnyHtmlAttribute::HtmlDoubleTextExpression(node) => node.format().fmt(f),
-            AnyHtmlAttribute::HtmlSingleTextExpression(node) => node.format().fmt(f),
             AnyHtmlAttribute::SvelteAttachAttribute(node) => node.format().fmt(f),
         }
     }
diff --git a/crates/biome_html_formatter/src/html/any/attribute_initializer.rs b/crates/biome_html_formatter/src/html/any/attribute_initializer.rs
index 79709c0a9cbe..9c163f33bebc 100644
--- a/crates/biome_html_formatter/src/html/any/attribute_initializer.rs
+++ b/crates/biome_html_formatter/src/html/any/attribute_initializer.rs
@@ -8,7 +8,9 @@ impl FormatRule<AnyHtmlAttributeInitializer> for FormatAnyHtmlAttributeInitializ
     type Context = HtmlFormatContext;
     fn fmt(&self, node: &AnyHtmlAttributeInitializer, f: &mut HtmlFormatter) -> FormatResult<()> {
         match node {
-            AnyHtmlAttributeInitializer::HtmlSingleTextExpression(node) => node.format().fmt(f),
+            AnyHtmlAttributeInitializer::HtmlAttributeSingleTextExpression(node) => {
+                node.format().fmt(f)
+            }
             AnyHtmlAttributeInitializer::HtmlString(node) => node.format().fmt(f),
         }
     }
diff --git a/crates/biome_html_formatter/src/html/auxiliary/attribute_double_text_expression.rs b/crates/biome_html_formatter/src/html/auxiliary/attribute_double_text_expression.rs
new file mode 100644
index 000000000000..c8d8b90faded
--- /dev/null
+++ b/crates/biome_html_formatter/src/html/auxiliary/attribute_double_text_expression.rs
@@ -0,0 +1,33 @@
+use crate::prelude::*;
+use biome_formatter::write;
+use biome_html_syntax::{
+    HtmlAttributeDoubleTextExpression, HtmlAttributeDoubleTextExpressionFields,
+};
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatHtmlAttributeDoubleTextExpression;
+
+impl FormatNodeRule<HtmlAttributeDoubleTextExpression> for FormatHtmlAttributeDoubleTextExpression {
+    fn fmt_fields(
+        &self,
+        node: &HtmlAttributeDoubleTextExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        let HtmlAttributeDoubleTextExpressionFields {
+            l_double_curly_token,
+            expression,
+            r_double_curly_token,
+        } = node.as_fields();
+
+        write!(
+            f,
+            [
+                l_double_curly_token.format(),
+                space(),
+                expression.format(),
+                space(),
+                r_double_curly_token.format(),
+            ]
+        )
+    }
+}
diff --git a/crates/biome_html_formatter/src/html/auxiliary/attribute_single_text_expression.rs b/crates/biome_html_formatter/src/html/auxiliary/attribute_single_text_expression.rs
new file mode 100644
index 000000000000..b901919845b1
--- /dev/null
+++ b/crates/biome_html_formatter/src/html/auxiliary/attribute_single_text_expression.rs
@@ -0,0 +1,31 @@
+use crate::prelude::*;
+use biome_formatter::write;
+use biome_html_syntax::{
+    HtmlAttributeSingleTextExpression, HtmlAttributeSingleTextExpressionFields,
+};
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatHtmlAttributeSingleTextExpression;
+
+impl FormatNodeRule<HtmlAttributeSingleTextExpression> for FormatHtmlAttributeSingleTextExpression {
+    fn fmt_fields(
+        &self,
+        node: &HtmlAttributeSingleTextExpression,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        let HtmlAttributeSingleTextExpressionFields {
+            l_curly_token,
+            expression,
+            r_curly_token,
+        } = node.as_fields();
+
+        write!(
+            f,
+            [
+                l_curly_token.format(),
+                expression.format(),
+                r_curly_token.format()
+            ]
+        )
+    }
+}
diff --git a/crates/biome_html_formatter/src/html/auxiliary/mod.rs b/crates/biome_html_formatter/src/html/auxiliary/mod.rs
index 260ed313e467..b955937453f8 100644
--- a/crates/biome_html_formatter/src/html/auxiliary/mod.rs
+++ b/crates/biome_html_formatter/src/html/auxiliary/mod.rs
@@ -1,8 +1,10 @@
 //! This is a generated file. Don't modify it by hand! Run 'cargo codegen formatter' to re-generate the file.
 
 pub(crate) mod attribute;
+pub(crate) mod attribute_double_text_expression;
 pub(crate) mod attribute_initializer_clause;
 pub(crate) mod attribute_name;
+pub(crate) mod attribute_single_text_expression;
 pub(crate) mod cdata_section;
 pub(crate) mod closing_element;
 pub(crate) mod content;
diff --git a/crates/biome_html_formatter/src/html/lists/attribute_list.rs b/crates/biome_html_formatter/src/html/lists/attribute_list.rs
index 611abde8975a..321867123e58 100644
--- a/crates/biome_html_formatter/src/html/lists/attribute_list.rs
+++ b/crates/biome_html_formatter/src/html/lists/attribute_list.rs
@@ -60,10 +60,10 @@ impl FormatRule<HtmlAttributeList> for FormatHtmlAttributeList {
                                             tag_name: self.tag_name.clone(),
                                         })
                                         .fmt(f),
-                                    AnyHtmlAttribute::HtmlDoubleTextExpression(attr) => {
+                                    AnyHtmlAttribute::HtmlAttributeDoubleTextExpression(attr) => {
                                         attr.format().fmt(f)
                                     }
-                                    AnyHtmlAttribute::HtmlSingleTextExpression(attr) => {
+                                    AnyHtmlAttribute::HtmlAttributeSingleTextExpression(attr) => {
                                         attr.format().fmt(f)
                                     }
                                     AnyHtmlAttribute::HtmlBogusAttribute(attr) => {
diff --git a/crates/biome_html_formatter/src/html/lists/element_list.rs b/crates/biome_html_formatter/src/html/lists/element_list.rs
index 76a19aa8e46c..ce70f153b50b 100644
--- a/crates/biome_html_formatter/src/html/lists/element_list.rs
+++ b/crates/biome_html_formatter/src/html/lists/element_list.rs
@@ -245,6 +245,9 @@ impl FormatHtmlElementList {
                             // Some(WordSeparator::Lines(2))
                         }
 
+                        // Don't add a newline before a bogus element as it may break the layout
+                        Some(HtmlChild::NonText(AnyHtmlElement::HtmlBogusElement(_))) => None,
+
                         // Last word or last word before an element without any whitespace in between
                         Some(HtmlChild::NonText(next_child)) => Some(WordSeparator::EndOfText {
                             is_soft_line_break: !matches!(
diff --git a/crates/biome_html_formatter/src/utils/children.rs b/crates/biome_html_formatter/src/utils/children.rs
index 3c878191fd3c..975a3f506018 100644
--- a/crates/biome_html_formatter/src/utils/children.rs
+++ b/crates/biome_html_formatter/src/utils/children.rs
@@ -398,14 +398,16 @@ where
             }
 
             // Check for trailing whitespace, and preserve it if
-            // - its embedded expression content
-            // - its an element
+            // - it's embedded expression content
+            // - it's an element
+            // - it's a bogus element
             // This preserves spaces between expressions/elements and following text content.
             if matches!(
                 &child,
                 AnyHtmlElement::AnyHtmlContent(_)
                     | AnyHtmlElement::HtmlElement(_)
                     | AnyHtmlElement::HtmlSelfClosingElement(_)
+                    | AnyHtmlElement::HtmlBogusElement(_)
             ) && let Some(last_token) = child.syntax().last_token()
                 && last_token.has_trailing_whitespace()
             {
diff --git a/crates/biome_html_formatter/tests/specs/html/interpolation/interpolation.html.snap b/crates/biome_html_formatter/tests/specs/html/interpolation/interpolation.html.snap
index 4fdc257476b4..22ae535f571d 100644
--- a/crates/biome_html_formatter/tests/specs/html/interpolation/interpolation.html.snap
+++ b/crates/biome_html_formatter/tests/specs/html/interpolation/interpolation.html.snap
@@ -31,9 +31,7 @@ Self close void elements: never
 -----
 
 ```html
-<div>
-	{{ $interpolation }}
-</div>
+<div>{{ $interpolation }}</div>
 ```
 
 ## Output 1
@@ -51,7 +49,5 @@ Self close void elements: never
 -----
 
 ```html
-<div>
-	{{ $interpolation }}
-</div>
+<div>{{ $interpolation }}</div>
 ```
diff --git a/crates/biome_html_formatter/tests/specs/prettier/html/interpolation/example.html.snap b/crates/biome_html_formatter/tests/specs/prettier/html/interpolation/example.html.snap
index 123a226c2353..e93e5aba267c 100644
--- a/crates/biome_html_formatter/tests/specs/prettier/html/interpolation/example.html.snap
+++ b/crates/biome_html_formatter/tests/specs/prettier/html/interpolation/example.html.snap
@@ -40,16 +40,15 @@ x => {
 ```diff
 --- Prettier
 +++ Biome
-@@ -1,8 +1,26 @@
--<!--interpolations in html should be treated as normal text-->
--<div>
+@@ -1,8 +1,31 @@
+ <!--interpolations in html should be treated as normal text-->
+ <div>
 -  Fuga magnam facilis. Voluptatem quaerat porro.{{ x => { const hello = 'world'
 -  return hello; } }} Magni consectetur in et molestias neque esse voluptatibus
 -  voluptas. {{ some_variable }} Eum quia nihil nulla esse. Dolorem asperiores
 -  vero est error {{ preserve invalid interpolation }} reprehenderit voluptates
 -  minus {{console.log( short_interpolation )}} nemo.
--</div>
-+<!--interpolations in html should be treated as normal text--><div>Fuga magnam facilis. Voluptatem quaerat porro.{{
++  Fuga magnam facilis. Voluptatem quaerat porro.{{
 +
 +
 +x => {
@@ -59,14 +58,16 @@ x => {
 +
 +
 +
-+}} Magni consectetur in et molestias neque esse voluptatibus voluptas. {{  
++}} Magni consectetur in et molestias neque esse voluptatibus voluptas.
++  {{  
 +    
 +    
 +    some_variable 
 +
 +
 +
-+}} Eum quia nihil nulla esse. Dolorem asperiores vero est error {{
++}} Eum quia nihil nulla esse. Dolorem asperiores vero est error
++  {{
 +
 +                    preserve
 +
@@ -74,13 +75,16 @@ x => {
 +                    
 +                    interpolation
 +
-+}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
++}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.
+ </div>
 ```
 
 # Output
 
 ```html
-<!--interpolations in html should be treated as normal text--><div>Fuga magnam facilis. Voluptatem quaerat porro.{{
+<!--interpolations in html should be treated as normal text-->
+<div>
+  Fuga magnam facilis. Voluptatem quaerat porro.{{
 
 
 x => {
@@ -90,14 +94,16 @@ x => {
 
 
 
-}} Magni consectetur in et molestias neque esse voluptatibus voluptas. {{  
+}} Magni consectetur in et molestias neque esse voluptatibus voluptas.
+  {{  
     
     
     some_variable 
 
 
 
-}} Eum quia nihil nulla esse. Dolorem asperiores vero est error {{
+}} Eum quia nihil nulla esse. Dolorem asperiores vero est error
+  {{
 
                     preserve
 
@@ -105,7 +111,8 @@ x => {
                     
                     interpolation
 
-}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
+}} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.
+</div>
 ```
 
 # Errors
@@ -174,9 +181,3 @@ example.html:26:35 parse ━━━━━━━━━━━━━━━━━━
   
 
 ```
-
-# Lines exceeding max width of 80 characters
-```
-    1: <!--interpolations in html should be treated as normal text--><div>Fuga magnam facilis. Voluptatem quaerat porro.{{
-   26: }} reprehenderit voluptates minus {{console.log(  short_interpolation )}} nemo.</div>
-```
diff --git a/crates/biome_html_formatter/tests/specs/prettier/vue/html-vue/hello-world.html.snap b/crates/biome_html_formatter/tests/specs/prettier/vue/html-vue/hello-world.html.snap
index a4dfb188c87c..2b15625d878f 100644
--- a/crates/biome_html_formatter/tests/specs/prettier/vue/html-vue/hello-world.html.snap
+++ b/crates/biome_html_formatter/tests/specs/prettier/vue/html-vue/hello-world.html.snap
@@ -36,21 +36,20 @@ info: vue/html-vue/hello-world.html
 ```diff
 --- Prettier
 +++ Biome
-@@ -1,5 +1,5 @@
+@@ -1,22 +1,20 @@
  <!-- Hello World example from https://github.com/vuejs/vuejs.org/blob/master/src/v2/examples/vue-20-hello-world/index.html -->
 -<!doctype html>
 +<!DOCTYPE html>
  <html>
    <head>
      <title>My first Vue app</title>
-@@ -7,16 +7,16 @@
+     <script src="https://unpkg.com/vue"></script>
    </head>
    <body>
-     <div id="app">
+-    <div id="app">
 -      {{ message }}
 -    </div>
-+    {{ message }}
-+  </div>
++    <div id="app">{{ message }}</div>
  
      <script>
 -      var app = new Vue({
@@ -82,9 +81,7 @@ info: vue/html-vue/hello-world.html
     <script src="https://unpkg.com/vue"></script>
   </head>
   <body>
-    <div id="app">
-    {{ message }}
-  </div>
+    <div id="app">{{ message }}</div>
 
     <script>
     var app = new Vue({
diff --git a/crates/biome_html_parser/src/syntax/mod.rs b/crates/biome_html_parser/src/syntax/mod.rs
index 1da85f760bda..7c91cb243f3e 100644
--- a/crates/biome_html_parser/src/syntax/mod.rs
+++ b/crates/biome_html_parser/src/syntax/mod.rs
@@ -558,7 +558,11 @@ fn parse_double_text_expression(p: &mut HtmlParser, context: HtmlLexContext) ->
 
     if p.at(T!["}}"]) {
         p.expect_with_context(T!["}}"], context);
-        Present(m.complete(p, HTML_DOUBLE_TEXT_EXPRESSION))
+        if context == HtmlLexContext::InsideTag || context == HtmlLexContext::InsideTagVue {
+            Present(m.complete(p, HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION))
+        } else {
+            Present(m.complete(p, HTML_DOUBLE_TEXT_EXPRESSION))
+        }
     } else if p.at(T![<]) {
         let diagnostic = expected_closing_text_expression(p, p.cur_range(), opening_range);
         p.error(diagnostic);
@@ -605,7 +609,11 @@ pub(crate) fn parse_single_text_expression(
 
     if p.at(T!['}']) {
         p.bump_remap_with_context(T!['}'], context);
-        Present(m.complete(p, HTML_SINGLE_TEXT_EXPRESSION))
+        if context == HtmlLexContext::InsideTag || context == HtmlLexContext::InsideTagVue {
+            Present(m.complete(p, HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION))
+        } else {
+            Present(m.complete(p, HTML_SINGLE_TEXT_EXPRESSION))
+        }
     } else if p.at(T![<]) {
         let diagnostic = expected_closing_text_expression(p, p.cur_range(), opening_range);
         p.error(diagnostic);
diff --git a/crates/biome_html_parser/tests/html_specs/error/interpolation.html.snap b/crates/biome_html_parser/tests/html_specs/error/interpolation.html.snap
index 1f40382e288f..34d0c7489b73 100644
--- a/crates/biome_html_parser/tests/html_specs/error/interpolation.html.snap
+++ b/crates/biome_html_parser/tests/html_specs/error/interpolation.html.snap
@@ -27,56 +27,52 @@ HtmlRoot {
     frontmatter: missing (optional),
     directive: missing (optional),
     html: HtmlElementList [
-        HtmlBogusElement {
-            items: [
-                HtmlOpeningElement {
-                    l_angle_token: L_ANGLE@0..1 "<" [] [],
-                    name: HtmlTagName {
-                        value_token: HTML_LITERAL@1..4 "div" [] [],
-                    },
-                    attributes: HtmlAttributeList [],
-                    r_angle_token: R_ANGLE@4..5 ">" [] [],
+        HtmlElement {
+            opening_element: HtmlOpeningElement {
+                l_angle_token: L_ANGLE@0..1 "<" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@1..4 "div" [] [],
                 },
-                HtmlBogus {
+                attributes: HtmlAttributeList [],
+                r_angle_token: R_ANGLE@4..5 ">" [] [],
+            },
+            children: HtmlElementList [
+                HtmlContent {
+                    value_token: HTML_LITERAL@5..51 "Fuga magnam facilis. Voluptatem quaerat porro." [] [],
+                },
+                HtmlBogusElement {
                     items: [
-                        HtmlContent {
-                            value_token: HTML_LITERAL@5..51 "Fuga magnam facilis. Voluptatem quaerat porro." [] [],
-                        },
-                        HtmlBogusAttribute {
-                            items: [
-                                L_DOUBLE_CURLY@51..53 "{{" [] [],
-                                HtmlTextExpression {
-                                    html_literal_token: HTML_LITERAL@53..108 "\n\n\n\tx => {\n\tconst hello = 'world'\n\treturn hello;\n\t}\n\n\n\t" [] [],
-                                },
-                                R_DOUBLE_CURLY@108..111 "}}" [] [Whitespace(" ")],
-                            ],
-                        },
-                        HtmlContent {
-                            value_token: HTML_LITERAL@111..142 "reprehenderit voluptates minus" [] [Whitespace(" ")],
+                        L_DOUBLE_CURLY@51..53 "{{" [] [],
+                        HtmlTextExpression {
+                            html_literal_token: HTML_LITERAL@53..108 "\n\n\n\tx => {\n\tconst hello = 'world'\n\treturn hello;\n\t}\n\n\n\t" [] [],
                         },
-                        HtmlBogusAttribute {
-                            items: [
-                                L_DOUBLE_CURLY@142..144 "{{" [] [],
-                                HtmlTextExpression {
-                                    html_literal_token: HTML_LITERAL@144..179 "console.log(  short_interpolation )" [] [],
-                                },
-                                R_DOUBLE_CURLY@179..182 "}}" [] [Whitespace(" ")],
-                            ],
-                        },
-                        HtmlContent {
-                            value_token: HTML_LITERAL@182..187 "nemo." [] [],
+                        R_DOUBLE_CURLY@108..111 "}}" [] [Whitespace(" ")],
+                    ],
+                },
+                HtmlContent {
+                    value_token: HTML_LITERAL@111..142 "reprehenderit voluptates minus" [] [Whitespace(" ")],
+                },
+                HtmlBogusElement {
+                    items: [
+                        L_DOUBLE_CURLY@142..144 "{{" [] [],
+                        HtmlTextExpression {
+                            html_literal_token: HTML_LITERAL@144..179 "console.log(  short_interpolation )" [] [],
                         },
+                        R_DOUBLE_CURLY@179..182 "}}" [] [Whitespace(" ")],
                     ],
                 },
-                HtmlClosingElement {
-                    l_angle_token: L_ANGLE@187..188 "<" [] [],
-                    slash_token: SLASH@188..189 "/" [] [],
-                    name: HtmlTagName {
-                        value_token: HTML_LITERAL@189..192 "div" [] [],
-                    },
-                    r_angle_token: R_ANGLE@192..193 ">" [] [],
+                HtmlContent {
+                    value_token: HTML_LITERAL@182..187 "nemo." [] [],
                 },
             ],
+            closing_element: HtmlClosingElement {
+                l_angle_token: L_ANGLE@187..188 "<" [] [],
+                slash_token: SLASH@188..189 "/" [] [],
+                name: HtmlTagName {
+                    value_token: HTML_LITERAL@189..192 "div" [] [],
+                },
+                r_angle_token: R_ANGLE@192..193 ">" [] [],
+            },
         },
     ],
     eof_token: EOF@193..194 "" [Newline("\n")] [],
@@ -91,24 +87,24 @@ HtmlRoot {
   1: (empty)
   2: (empty)
   3: HTML_ELEMENT_LIST@0..193
-    0: HTML_BOGUS_ELEMENT@0..193
+    0: HTML_ELEMENT@0..193
       0: HTML_OPENING_ELEMENT@0..5
         0: L_ANGLE@0..1 "<" [] []
         1: HTML_TAG_NAME@1..4
           0: HTML_LITERAL@1..4 "div" [] []
         2: HTML_ATTRIBUTE_LIST@4..4
         3: R_ANGLE@4..5 ">" [] []
-      1: HTML_BOGUS@5..187
+      1: HTML_ELEMENT_LIST@5..187
         0: HTML_CONTENT@5..51
           0: HTML_LITERAL@5..51 "Fuga magnam facilis. Voluptatem quaerat porro." [] []
-        1: HTML_BOGUS_ATTRIBUTE@51..111
+        1: HTML_BOGUS_ELEMENT@51..111
           0: L_DOUBLE_CURLY@51..53 "{{" [] []
           1: HTML_TEXT_EXPRESSION@53..108
             0: HTML_LITERAL@53..108 "\n\n\n\tx => {\n\tconst hello = 'world'\n\treturn hello;\n\t}\n\n\n\t" [] []
           2: R_DOUBLE_CURLY@108..111 "}}" [] [Whitespace(" ")]
         2: HTML_CONTENT@111..142
           0: HTML_LITERAL@111..142 "reprehenderit voluptates minus" [] [Whitespace(" ")]
-        3: HTML_BOGUS_ATTRIBUTE@142..182
+        3: HTML_BOGUS_ELEMENT@142..182
           0: L_DOUBLE_CURLY@142..144 "{{" [] []
           1: HTML_TEXT_EXPRESSION@144..179
             0: HTML_LITERAL@144..179 "console.log(  short_interpolation )" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-8605.html b/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-8605.html
new file mode 100644
index 000000000000..415d86f4ca13
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-8605.html
@@ -0,0 +1 @@
+{{ some_form }}
diff --git a/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-8605.html.snap b/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-8605.html.snap
new file mode 100644
index 000000000000..09535fff6637
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/error/template-langs/django/issue-8605.html.snap
@@ -0,0 +1,65 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```html
+{{ some_form }}
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlBogusElement {
+            items: [
+                L_DOUBLE_CURLY@0..2 "{{" [] [],
+                HtmlTextExpression {
+                    html_literal_token: HTML_LITERAL@2..13 " some_form " [] [],
+                },
+                R_DOUBLE_CURLY@13..15 "}}" [] [],
+            ],
+        },
+    ],
+    eof_token: EOF@15..16 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..16
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..15
+    0: HTML_BOGUS_ELEMENT@0..15
+      0: L_DOUBLE_CURLY@0..2 "{{" [] []
+      1: HTML_TEXT_EXPRESSION@2..13
+        0: HTML_LITERAL@2..13 " some_form " [] []
+      2: R_DOUBLE_CURLY@13..15 "}}" [] []
+  4: EOF@15..16 "" [Newline("\n")] []
+
+```
+
+## Diagnostics
+
+```
+issue-8605.html:1:1 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Text expressions aren't supported.
+  
+  > 1 │ {{ some_form }}
+      │ ^^^^^^^^^^^^^^^
+    2 │ 
+  
+  i Remove it or enable the parsing using the html.parser.interpolation option.
+  
+```
diff --git a/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro.snap b/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro.snap
index 256d56051ee0..ee093158ed0d 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/astro/attribute_expression.astro.snap
@@ -52,7 +52,7 @@ HtmlRoot {
                                 },
                                 initializer: HtmlAttributeInitializerClause {
                                     eq_token: EQ@51..52 "=" [] [],
-                                    value: HtmlSingleTextExpression {
+                                    value: HtmlAttributeSingleTextExpression {
                                         l_curly_token: L_CURLY@52..53 "{" [] [],
                                         expression: HtmlTextExpression {
                                             html_literal_token: HTML_LITERAL@53..56 "foo" [] [],
@@ -120,7 +120,7 @@ HtmlRoot {
                   0: HTML_LITERAL@49..51 "id" [] []
                 1: HTML_ATTRIBUTE_INITIALIZER_CLAUSE@51..57
                   0: EQ@51..52 "=" [] []
-                  1: HTML_SINGLE_TEXT_EXPRESSION@52..57
+                  1: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@52..57
                     0: L_CURLY@52..53 "{" [] []
                     1: HTML_TEXT_EXPRESSION@53..56
                       0: HTML_LITERAL@53..56 "foo" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte/attach.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte/attach.svelte.snap
index a2f583a36ca7..bac2aac4554f 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/svelte/attach.svelte.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte/attach.svelte.snap
@@ -110,7 +110,7 @@ HtmlRoot {
                         },
                         initializer: HtmlAttributeInitializerClause {
                             eq_token: EQ@108..109 "=" [] [],
-                            value: HtmlSingleTextExpression {
+                            value: HtmlAttributeSingleTextExpression {
                                 l_curly_token: L_CURLY@109..110 "{" [] [],
                                 expression: HtmlTextExpression {
                                     html_literal_token: HTML_LITERAL@110..112 "32" [] [],
@@ -125,7 +125,7 @@ HtmlRoot {
                         },
                         initializer: HtmlAttributeInitializerClause {
                             eq_token: EQ@121..122 "=" [] [],
-                            value: HtmlSingleTextExpression {
+                            value: HtmlAttributeSingleTextExpression {
                                 l_curly_token: L_CURLY@122..123 "{" [] [],
                                 expression: HtmlTextExpression {
                                     html_literal_token: HTML_LITERAL@123..125 "32" [] [],
@@ -223,7 +223,7 @@ HtmlRoot {
               0: HTML_LITERAL@101..108 "width" [Newline("\n"), Whitespace("\t")] []
             1: HTML_ATTRIBUTE_INITIALIZER_CLAUSE@108..113
               0: EQ@108..109 "=" [] []
-              1: HTML_SINGLE_TEXT_EXPRESSION@109..113
+              1: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@109..113
                 0: L_CURLY@109..110 "{" [] []
                 1: HTML_TEXT_EXPRESSION@110..112
                   0: HTML_LITERAL@110..112 "32" [] []
@@ -233,7 +233,7 @@ HtmlRoot {
               0: HTML_LITERAL@113..121 "height" [Newline("\n"), Whitespace("\t")] []
             1: HTML_ATTRIBUTE_INITIALIZER_CLAUSE@121..126
               0: EQ@121..122 "=" [] []
-              1: HTML_SINGLE_TEXT_EXPRESSION@122..126
+              1: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@122..126
                 0: L_CURLY@122..123 "{" [] []
                 1: HTML_TEXT_EXPRESSION@123..125
                   0: HTML_LITERAL@123..125 "32" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte/await_multiline.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte/await_multiline.svelte.snap
index deac9df2beba..f7aac936c6fa 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/svelte/await_multiline.svelte.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte/await_multiline.svelte.snap
@@ -315,7 +315,7 @@ HtmlRoot {
                                                 },
                                                 initializer: HtmlAttributeInitializerClause {
                                                     eq_token: EQ@352..353 "=" [] [],
-                                                    value: HtmlSingleTextExpression {
+                                                    value: HtmlAttributeSingleTextExpression {
                                                         l_curly_token: L_CURLY@353..354 "{" [] [],
                                                         expression: HtmlTextExpression {
                                                             html_literal_token: HTML_LITERAL@354..359 "retry" [] [],
@@ -570,7 +570,7 @@ HtmlRoot {
                           0: HTML_LITERAL@344..352 "on:click" [] []
                         1: HTML_ATTRIBUTE_INITIALIZER_CLAUSE@352..360
                           0: EQ@352..353 "=" [] []
-                          1: HTML_SINGLE_TEXT_EXPRESSION@353..360
+                          1: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@353..360
                             0: L_CURLY@353..354 "{" [] []
                             1: HTML_TEXT_EXPRESSION@354..359
                               0: HTML_LITERAL@354..359 "retry" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte/complex_expressions.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte/complex_expressions.svelte.snap
index 422c7f9341f0..6f44f7fbf365 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/svelte/complex_expressions.svelte.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte/complex_expressions.svelte.snap
@@ -48,7 +48,7 @@ HtmlRoot {
                         value_token: HTML_LITERAL@53..67 "InputOTP.Slot" [] [Whitespace(" ")],
                     },
                     attributes: HtmlAttributeList [
-                        HtmlSingleTextExpression {
+                        HtmlAttributeSingleTextExpression {
                             l_curly_token: L_CURLY@67..68 "{" [] [],
                             expression: HtmlTextExpression {
                                 html_literal_token: HTML_LITERAL@68..72 "cell" [] [],
@@ -102,7 +102,7 @@ HtmlRoot {
                         value_token: HTML_LITERAL@129..143 "InputOTP.Slot" [] [Whitespace(" ")],
                     },
                     attributes: HtmlAttributeList [
-                        HtmlSingleTextExpression {
+                        HtmlAttributeSingleTextExpression {
                             l_curly_token: L_CURLY@143..144 "{" [] [],
                             expression: HtmlTextExpression {
                                 html_literal_token: HTML_LITERAL@144..148 "cell" [] [],
@@ -152,7 +152,7 @@ HtmlRoot {
           1: HTML_TAG_NAME@53..67
             0: HTML_LITERAL@53..67 "InputOTP.Slot" [] [Whitespace(" ")]
           2: HTML_ATTRIBUTE_LIST@67..74
-            0: HTML_SINGLE_TEXT_EXPRESSION@67..74
+            0: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@67..74
               0: L_CURLY@67..68 "{" [] []
               1: HTML_TEXT_EXPRESSION@68..72
                 0: HTML_LITERAL@68..72 "cell" [] []
@@ -190,7 +190,7 @@ HtmlRoot {
           1: HTML_TAG_NAME@129..143
             0: HTML_LITERAL@129..143 "InputOTP.Slot" [] [Whitespace(" ")]
           2: HTML_ATTRIBUTE_LIST@143..150
-            0: HTML_SINGLE_TEXT_EXPRESSION@143..150
+            0: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@143..150
               0: L_CURLY@143..144 "{" [] []
               1: HTML_TEXT_EXPRESSION@144..148
                 0: HTML_LITERAL@144..148 "cell" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte/dynamic-prop.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte/dynamic-prop.svelte.snap
index af17d566f9b0..6f52d979e382 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/svelte/dynamic-prop.svelte.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte/dynamic-prop.svelte.snap
@@ -31,7 +31,7 @@ HtmlRoot {
                         },
                         initializer: HtmlAttributeInitializerClause {
                             eq_token: EQ@16..17 "=" [] [],
-                            value: HtmlSingleTextExpression {
+                            value: HtmlAttributeSingleTextExpression {
                                 l_curly_token: L_CURLY@17..18 "{" [] [],
                                 expression: HtmlTextExpression {
                                     html_literal_token: HTML_LITERAL@18..23 "false" [] [],
@@ -81,7 +81,7 @@ HtmlRoot {
               0: HTML_LITERAL@8..16 "disabled" [] []
             1: HTML_ATTRIBUTE_INITIALIZER_CLAUSE@16..24
               0: EQ@16..17 "=" [] []
-              1: HTML_SINGLE_TEXT_EXPRESSION@17..24
+              1: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@17..24
                 0: L_CURLY@17..18 "{" [] []
                 1: HTML_TEXT_EXPRESSION@18..23
                   0: HTML_LITERAL@18..23 "false" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte/each_as_in_identifier.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte/each_as_in_identifier.svelte.snap
index f8bce0247c12..a1cefbc153d0 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/svelte/each_as_in_identifier.svelte.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte/each_as_in_identifier.svelte.snap
@@ -55,7 +55,7 @@ HtmlRoot {
                                 },
                                 initializer: HtmlAttributeInitializerClause {
                                     eq_token: EQ@37..38 "=" [] [],
-                                    value: HtmlSingleTextExpression {
+                                    value: HtmlAttributeSingleTextExpression {
                                         l_curly_token: L_CURLY@38..39 "{" [] [],
                                         expression: HtmlTextExpression {
                                             html_literal_token: HTML_LITERAL@39..44 "class" [] [],
@@ -176,7 +176,7 @@ HtmlRoot {
                   0: HTML_LITERAL@32..37 "class" [] []
                 1: HTML_ATTRIBUTE_INITIALIZER_CLAUSE@37..45
                   0: EQ@37..38 "=" [] []
-                  1: HTML_SINGLE_TEXT_EXPRESSION@38..45
+                  1: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@38..45
                     0: L_CURLY@38..39 "{" [] []
                     1: HTML_TEXT_EXPRESSION@39..44
                       0: HTML_LITERAL@39..44 "class" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte/shorthand-prop.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte/shorthand-prop.svelte.snap
index 144579ab1b16..a6cd46dca399 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/svelte/shorthand-prop.svelte.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte/shorthand-prop.svelte.snap
@@ -25,7 +25,7 @@ HtmlRoot {
                     value_token: HTML_LITERAL@1..8 "button" [] [Whitespace(" ")],
                 },
                 attributes: HtmlAttributeList [
-                    HtmlSingleTextExpression {
+                    HtmlAttributeSingleTextExpression {
                         l_curly_token: L_CURLY@8..9 "{" [] [],
                         expression: HtmlTextExpression {
                             html_literal_token: HTML_LITERAL@9..17 "disabled" [] [],
@@ -68,7 +68,7 @@ HtmlRoot {
         1: HTML_TAG_NAME@1..8
           0: HTML_LITERAL@1..8 "button" [] [Whitespace(" ")]
         2: HTML_ATTRIBUTE_LIST@8..18
-          0: HTML_SINGLE_TEXT_EXPRESSION@8..18
+          0: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@8..18
             0: L_CURLY@8..9 "{" [] []
             1: HTML_TEXT_EXPRESSION@9..17
               0: HTML_LITERAL@9..17 "disabled" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/svelte/shorthand-spread-props.svelte.snap b/crates/biome_html_parser/tests/html_specs/ok/svelte/shorthand-spread-props.svelte.snap
index 385241c54392..0f105ba173d1 100644
--- a/crates/biome_html_parser/tests/html_specs/ok/svelte/shorthand-spread-props.svelte.snap
+++ b/crates/biome_html_parser/tests/html_specs/ok/svelte/shorthand-spread-props.svelte.snap
@@ -25,7 +25,7 @@ HtmlRoot {
                     value_token: HTML_LITERAL@1..8 "button" [] [Whitespace(" ")],
                 },
                 attributes: HtmlAttributeList [
-                    HtmlSingleTextExpression {
+                    HtmlAttributeSingleTextExpression {
                         l_curly_token: L_CURLY@8..9 "{" [] [],
                         expression: HtmlTextExpression {
                             html_literal_token: HTML_LITERAL@9..17 "...props" [] [],
@@ -68,7 +68,7 @@ HtmlRoot {
         1: HTML_TAG_NAME@1..8
           0: HTML_LITERAL@1..8 "button" [] [Whitespace(" ")]
         2: HTML_ATTRIBUTE_LIST@8..18
-          0: HTML_SINGLE_TEXT_EXPRESSION@8..18
+          0: HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION@8..18
             0: L_CURLY@8..9 "{" [] []
             1: HTML_TEXT_EXPRESSION@9..17
               0: HTML_LITERAL@9..17 "...props" [] []
diff --git a/crates/biome_html_parser/tests/html_specs/ok/with-text-expressions/issue-8605.html b/crates/biome_html_parser/tests/html_specs/ok/with-text-expressions/issue-8605.html
new file mode 100644
index 000000000000..415d86f4ca13
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/with-text-expressions/issue-8605.html
@@ -0,0 +1 @@
+{{ some_form }}
diff --git a/crates/biome_html_parser/tests/html_specs/ok/with-text-expressions/issue-8605.html.snap b/crates/biome_html_parser/tests/html_specs/ok/with-text-expressions/issue-8605.html.snap
new file mode 100644
index 000000000000..386c704a2c07
--- /dev/null
+++ b/crates/biome_html_parser/tests/html_specs/ok/with-text-expressions/issue-8605.html.snap
@@ -0,0 +1,48 @@
+---
+source: crates/biome_html_parser/tests/spec_test.rs
+expression: snapshot
+---
+## Input
+
+```html
+{{ some_form }}
+
+```
+
+
+## AST
+
+```
+HtmlRoot {
+    bom_token: missing (optional),
+    frontmatter: missing (optional),
+    directive: missing (optional),
+    html: HtmlElementList [
+        HtmlDoubleTextExpression {
+            l_double_curly_token: L_DOUBLE_CURLY@0..2 "{{" [] [],
+            expression: HtmlTextExpression {
+                html_literal_token: HTML_LITERAL@2..13 " some_form " [] [],
+            },
+            r_double_curly_token: R_DOUBLE_CURLY@13..15 "}}" [] [],
+        },
+    ],
+    eof_token: EOF@15..16 "" [Newline("\n")] [],
+}
+```
+
+## CST
+
+```
+0: HTML_ROOT@0..16
+  0: (empty)
+  1: (empty)
+  2: (empty)
+  3: HTML_ELEMENT_LIST@0..15
+    0: HTML_DOUBLE_TEXT_EXPRESSION@0..15
+      0: L_DOUBLE_CURLY@0..2 "{{" [] []
+      1: HTML_TEXT_EXPRESSION@2..13
+        0: HTML_LITERAL@2..13 " some_form " [] []
+      2: R_DOUBLE_CURLY@13..15 "}}" [] []
+  4: EOF@15..16 "" [Newline("\n")] []
+
+```
diff --git a/crates/biome_html_parser/tests/spec_test.rs b/crates/biome_html_parser/tests/spec_test.rs
index 98333fc6b959..8dd1c43a9019 100644
--- a/crates/biome_html_parser/tests/spec_test.rs
+++ b/crates/biome_html_parser/tests/spec_test.rs
@@ -31,7 +31,14 @@ pub fn run(test_case: &str, _snapshot_name: &str, test_directory: &str, outcome_
     let content = fs::read_to_string(test_case_path)
         .expect("Expected test path to be a readable file in UTF8 encoding");
 
-    let file_source = HtmlFileSource::try_from(test_case_path).unwrap_or_default();
+    let mut file_source = HtmlFileSource::try_from(test_case_path).unwrap_or_default();
+    if test_case_path
+        .iter()
+        .any(|segment| segment == "with-text-expressions")
+    {
+        file_source = HtmlFileSource::html_with_text_expressions();
+    }
+
     let parser_options = HtmlParseOptions::from(&file_source);
     let parsed = parse_html(&content, parser_options);
     validate_eof_token(parsed.syntax());
diff --git a/crates/biome_html_syntax/src/attr_ext.rs b/crates/biome_html_syntax/src/attr_ext.rs
index 03ac73ef25d3..4cd4c8d03f10 100644
--- a/crates/biome_html_syntax/src/attr_ext.rs
+++ b/crates/biome_html_syntax/src/attr_ext.rs
@@ -8,7 +8,7 @@ impl AnyHtmlAttributeInitializer {
     /// Returns the string value of the attribute, if available, without quotes.
     pub fn string_value(&self) -> Option<Text> {
         match self {
-            Self::HtmlSingleTextExpression(_) => None,
+            Self::HtmlAttributeSingleTextExpression(_) => None,
             Self::HtmlString(string) => Some(
                 string
                     .value_token()
diff --git a/crates/biome_html_syntax/src/generated/kind.rs b/crates/biome_html_syntax/src/generated/kind.rs
index 0629deeee8c7..9439522bc754 100644
--- a/crates/biome_html_syntax/src/generated/kind.rs
+++ b/crates/biome_html_syntax/src/generated/kind.rs
@@ -83,6 +83,8 @@ pub enum HtmlSyntaxKind {
     HTML_DOUBLE_TEXT_EXPRESSION,
     HTML_SINGLE_TEXT_EXPRESSION,
     HTML_TEXT_EXPRESSION,
+    HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION,
+    HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION,
     ASTRO_FRONTMATTER_ELEMENT,
     ASTRO_EMBEDDED_CONTENT,
     SVELTE_DEBUG_BLOCK,
diff --git a/crates/biome_html_syntax/src/generated/macros.rs b/crates/biome_html_syntax/src/generated/macros.rs
index 7d47614e4ca0..3b8a0c1b237e 100644
--- a/crates/biome_html_syntax/src/generated/macros.rs
+++ b/crates/biome_html_syntax/src/generated/macros.rs
@@ -28,6 +28,11 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::HtmlAttribute::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION => {
+                    let $pattern =
+                        unsafe { $crate::HtmlAttributeDoubleTextExpression::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_ATTRIBUTE_INITIALIZER_CLAUSE => {
                     let $pattern =
                         unsafe { $crate::HtmlAttributeInitializerClause::new_unchecked(node) };
@@ -37,6 +42,11 @@ macro_rules! map_syntax_node {
                     let $pattern = unsafe { $crate::HtmlAttributeName::new_unchecked(node) };
                     $body
                 }
+                $crate::HtmlSyntaxKind::HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION => {
+                    let $pattern =
+                        unsafe { $crate::HtmlAttributeSingleTextExpression::new_unchecked(node) };
+                    $body
+                }
                 $crate::HtmlSyntaxKind::HTML_CDATA_SECTION => {
                     let $pattern = unsafe { $crate::HtmlCdataSection::new_unchecked(node) };
                     $body
diff --git a/crates/biome_html_syntax/src/generated/nodes.rs b/crates/biome_html_syntax/src/generated/nodes.rs
index 238b5f7e7294..1d5e8f77190e 100644
--- a/crates/biome_html_syntax/src/generated/nodes.rs
+++ b/crates/biome_html_syntax/src/generated/nodes.rs
@@ -140,6 +140,51 @@ pub struct HtmlAttributeFields {
     pub initializer: Option<HtmlAttributeInitializerClause>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlAttributeDoubleTextExpression {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlAttributeDoubleTextExpression {
+    #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
+    #[doc = r""]
+    #[doc = r" # Safety"]
+    #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"]
+    #[doc = r" or a match on [SyntaxNode::kind]"]
+    #[inline]
+    pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
+        Self { syntax }
+    }
+    pub fn as_fields(&self) -> HtmlAttributeDoubleTextExpressionFields {
+        HtmlAttributeDoubleTextExpressionFields {
+            l_double_curly_token: self.l_double_curly_token(),
+            expression: self.expression(),
+            r_double_curly_token: self.r_double_curly_token(),
+        }
+    }
+    pub fn l_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn expression(&self) -> SyntaxResult<HtmlTextExpression> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn r_double_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
+    }
+}
+impl Serialize for HtmlAttributeDoubleTextExpression {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlAttributeDoubleTextExpressionFields {
+    pub l_double_curly_token: SyntaxResult<SyntaxToken>,
+    pub expression: SyntaxResult<HtmlTextExpression>,
+    pub r_double_curly_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct HtmlAttributeInitializerClause {
     pub(crate) syntax: SyntaxNode,
 }
@@ -215,6 +260,51 @@ pub struct HtmlAttributeNameFields {
     pub value_token: SyntaxResult<SyntaxToken>,
 }
 #[derive(Clone, PartialEq, Eq, Hash)]
+pub struct HtmlAttributeSingleTextExpression {
+    pub(crate) syntax: SyntaxNode,
+}
+impl HtmlAttributeSingleTextExpression {
+    #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"]
+    #[doc = r""]
+    #[doc = r" # Safety"]
+    #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"]
+    #[doc = r" or a match on [SyntaxNode::kind]"]
+    #[inline]
+    pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self {
+        Self { syntax }
+    }
+    pub fn as_fields(&self) -> HtmlAttributeSingleTextExpressionFields {
+        HtmlAttributeSingleTextExpressionFields {
+            l_curly_token: self.l_curly_token(),
+            expression: self.expression(),
+            r_curly_token: self.r_curly_token(),
+        }
+    }
+    pub fn l_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 0usize)
+    }
+    pub fn expression(&self) -> SyntaxResult<HtmlTextExpression> {
+        support::required_node(&self.syntax, 1usize)
+    }
+    pub fn r_curly_token(&self) -> SyntaxResult<SyntaxToken> {
+        support::required_token(&self.syntax, 2usize)
+    }
+}
+impl Serialize for HtmlAttributeSingleTextExpression {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_fields().serialize(serializer)
+    }
+}
+#[derive(Serialize)]
+pub struct HtmlAttributeSingleTextExpressionFields {
+    pub l_curly_token: SyntaxResult<SyntaxToken>,
+    pub expression: SyntaxResult<HtmlTextExpression>,
+    pub r_curly_token: SyntaxResult<SyntaxToken>,
+}
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct HtmlCdataSection {
     pub(crate) syntax: SyntaxNode,
 }
@@ -2717,9 +2807,9 @@ impl AnyAstroFrontmatterElement {
 pub enum AnyHtmlAttribute {
     AnyVueDirective(AnyVueDirective),
     HtmlAttribute(HtmlAttribute),
+    HtmlAttributeDoubleTextExpression(HtmlAttributeDoubleTextExpression),
+    HtmlAttributeSingleTextExpression(HtmlAttributeSingleTextExpression),
     HtmlBogusAttribute(HtmlBogusAttribute),
-    HtmlDoubleTextExpression(HtmlDoubleTextExpression),
-    HtmlSingleTextExpression(HtmlSingleTextExpression),
     SvelteAttachAttribute(SvelteAttachAttribute),
 }
 impl AnyHtmlAttribute {
@@ -2735,21 +2825,25 @@ impl AnyHtmlAttribute {
             _ => None,
         }
     }
-    pub fn as_html_bogus_attribute(&self) -> Option<&HtmlBogusAttribute> {
+    pub fn as_html_attribute_double_text_expression(
+        &self,
+    ) -> Option<&HtmlAttributeDoubleTextExpression> {
         match &self {
-            Self::HtmlBogusAttribute(item) => Some(item),
+            Self::HtmlAttributeDoubleTextExpression(item) => Some(item),
             _ => None,
         }
     }
-    pub fn as_html_double_text_expression(&self) -> Option<&HtmlDoubleTextExpression> {
+    pub fn as_html_attribute_single_text_expression(
+        &self,
+    ) -> Option<&HtmlAttributeSingleTextExpression> {
         match &self {
-            Self::HtmlDoubleTextExpression(item) => Some(item),
+            Self::HtmlAttributeSingleTextExpression(item) => Some(item),
             _ => None,
         }
     }
-    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
+    pub fn as_html_bogus_attribute(&self) -> Option<&HtmlBogusAttribute> {
         match &self {
-            Self::HtmlSingleTextExpression(item) => Some(item),
+            Self::HtmlBogusAttribute(item) => Some(item),
             _ => None,
         }
     }
@@ -2762,13 +2856,15 @@ impl AnyHtmlAttribute {
 }
 #[derive(Clone, PartialEq, Eq, Hash, Serialize)]
 pub enum AnyHtmlAttributeInitializer {
-    HtmlSingleTextExpression(HtmlSingleTextExpression),
+    HtmlAttributeSingleTextExpression(HtmlAttributeSingleTextExpression),
     HtmlString(HtmlString),
 }
 impl AnyHtmlAttributeInitializer {
-    pub fn as_html_single_text_expression(&self) -> Option<&HtmlSingleTextExpression> {
+    pub fn as_html_attribute_single_text_expression(
+        &self,
+    ) -> Option<&HtmlAttributeSingleTextExpression> {
         match &self {
-            Self::HtmlSingleTextExpression(item) => Some(item),
+            Self::HtmlAttributeSingleTextExpression(item) => Some(item),
             _ => None,
         }
     }
@@ -3220,6 +3316,61 @@ impl From<HtmlAttribute> for SyntaxElement {
         n.syntax.into()
     }
 }
+impl AstNode for HtmlAttributeDoubleTextExpression {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax
+    }
+}
+impl std::fmt::Debug for HtmlAttributeDoubleTextExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } };
+        let current_depth = DEPTH.get();
+        let result = if current_depth < 16 {
+            DEPTH.set(current_depth + 1);
+            f.debug_struct("HtmlAttributeDoubleTextExpression")
+                .field(
+                    "l_double_curly_token",
+                    &support::DebugSyntaxResult(self.l_double_curly_token()),
+                )
+                .field("expression", &support::DebugSyntaxResult(self.expression()))
+                .field(
+                    "r_double_curly_token",
+                    &support::DebugSyntaxResult(self.r_double_curly_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("HtmlAttributeDoubleTextExpression").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<HtmlAttributeDoubleTextExpression> for SyntaxNode {
+    fn from(n: HtmlAttributeDoubleTextExpression) -> Self {
+        n.syntax
+    }
+}
+impl From<HtmlAttributeDoubleTextExpression> for SyntaxElement {
+    fn from(n: HtmlAttributeDoubleTextExpression) -> Self {
+        n.syntax.into()
+    }
+}
 impl AstNode for HtmlAttributeInitializerClause {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
@@ -3318,6 +3469,61 @@ impl From<HtmlAttributeName> for SyntaxElement {
         n.syntax.into()
     }
 }
+impl AstNode for HtmlAttributeSingleTextExpression {
+    type Language = Language;
+    const KIND_SET: SyntaxKindSet<Language> =
+        SyntaxKindSet::from_raw(RawSyntaxKind(HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION as u16));
+    fn can_cast(kind: SyntaxKind) -> bool {
+        kind == HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+    fn into_syntax(self) -> SyntaxNode {
+        self.syntax
+    }
+}
+impl std::fmt::Debug for HtmlAttributeSingleTextExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } };
+        let current_depth = DEPTH.get();
+        let result = if current_depth < 16 {
+            DEPTH.set(current_depth + 1);
+            f.debug_struct("HtmlAttributeSingleTextExpression")
+                .field(
+                    "l_curly_token",
+                    &support::DebugSyntaxResult(self.l_curly_token()),
+                )
+                .field("expression", &support::DebugSyntaxResult(self.expression()))
+                .field(
+                    "r_curly_token",
+                    &support::DebugSyntaxResult(self.r_curly_token()),
+                )
+                .finish()
+        } else {
+            f.debug_struct("HtmlAttributeSingleTextExpression").finish()
+        };
+        DEPTH.set(current_depth);
+        result
+    }
+}
+impl From<HtmlAttributeSingleTextExpression> for SyntaxNode {
+    fn from(n: HtmlAttributeSingleTextExpression) -> Self {
+        n.syntax
+    }
+}
+impl From<HtmlAttributeSingleTextExpression> for SyntaxElement {
+    fn from(n: HtmlAttributeSingleTextExpression) -> Self {
+        n.syntax.into()
+    }
+}
 impl AstNode for HtmlCdataSection {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
@@ -6321,19 +6527,19 @@ impl From<HtmlAttribute> for AnyHtmlAttribute {
         Self::HtmlAttribute(node)
     }
 }
-impl From<HtmlBogusAttribute> for AnyHtmlAttribute {
-    fn from(node: HtmlBogusAttribute) -> Self {
-        Self::HtmlBogusAttribute(node)
+impl From<HtmlAttributeDoubleTextExpression> for AnyHtmlAttribute {
+    fn from(node: HtmlAttributeDoubleTextExpression) -> Self {
+        Self::HtmlAttributeDoubleTextExpression(node)
     }
 }
-impl From<HtmlDoubleTextExpression> for AnyHtmlAttribute {
-    fn from(node: HtmlDoubleTextExpression) -> Self {
-        Self::HtmlDoubleTextExpression(node)
+impl From<HtmlAttributeSingleTextExpression> for AnyHtmlAttribute {
+    fn from(node: HtmlAttributeSingleTextExpression) -> Self {
+        Self::HtmlAttributeSingleTextExpression(node)
     }
 }
-impl From<HtmlSingleTextExpression> for AnyHtmlAttribute {
-    fn from(node: HtmlSingleTextExpression) -> Self {
-        Self::HtmlSingleTextExpression(node)
+impl From<HtmlBogusAttribute> for AnyHtmlAttribute {
+    fn from(node: HtmlBogusAttribute) -> Self {
+        Self::HtmlBogusAttribute(node)
     }
 }
 impl From<SvelteAttachAttribute> for AnyHtmlAttribute {
@@ -6345,16 +6551,16 @@ impl AstNode for AnyHtmlAttribute {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> = AnyVueDirective::KIND_SET
         .union(HtmlAttribute::KIND_SET)
+        .union(HtmlAttributeDoubleTextExpression::KIND_SET)
+        .union(HtmlAttributeSingleTextExpression::KIND_SET)
         .union(HtmlBogusAttribute::KIND_SET)
-        .union(HtmlDoubleTextExpression::KIND_SET)
-        .union(HtmlSingleTextExpression::KIND_SET)
         .union(SvelteAttachAttribute::KIND_SET);
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
             HTML_ATTRIBUTE
+            | HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION
+            | HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION
             | HTML_BOGUS_ATTRIBUTE
-            | HTML_DOUBLE_TEXT_EXPRESSION
-            | HTML_SINGLE_TEXT_EXPRESSION
             | SVELTE_ATTACH_ATTRIBUTE => true,
             k if AnyVueDirective::can_cast(k) => true,
             _ => false,
@@ -6363,13 +6569,17 @@ impl AstNode for AnyHtmlAttribute {
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
             HTML_ATTRIBUTE => Self::HtmlAttribute(HtmlAttribute { syntax }),
-            HTML_BOGUS_ATTRIBUTE => Self::HtmlBogusAttribute(HtmlBogusAttribute { syntax }),
-            HTML_DOUBLE_TEXT_EXPRESSION => {
-                Self::HtmlDoubleTextExpression(HtmlDoubleTextExpression { syntax })
+            HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION => {
+                Self::HtmlAttributeDoubleTextExpression(HtmlAttributeDoubleTextExpression {
+                    syntax,
+                })
             }
-            HTML_SINGLE_TEXT_EXPRESSION => {
-                Self::HtmlSingleTextExpression(HtmlSingleTextExpression { syntax })
+            HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION => {
+                Self::HtmlAttributeSingleTextExpression(HtmlAttributeSingleTextExpression {
+                    syntax,
+                })
             }
+            HTML_BOGUS_ATTRIBUTE => Self::HtmlBogusAttribute(HtmlBogusAttribute { syntax }),
             SVELTE_ATTACH_ATTRIBUTE => {
                 Self::SvelteAttachAttribute(SvelteAttachAttribute { syntax })
             }
@@ -6385,9 +6595,9 @@ impl AstNode for AnyHtmlAttribute {
     fn syntax(&self) -> &SyntaxNode {
         match self {
             Self::HtmlAttribute(it) => it.syntax(),
+            Self::HtmlAttributeDoubleTextExpression(it) => it.syntax(),
+            Self::HtmlAttributeSingleTextExpression(it) => it.syntax(),
             Self::HtmlBogusAttribute(it) => it.syntax(),
-            Self::HtmlDoubleTextExpression(it) => it.syntax(),
-            Self::HtmlSingleTextExpression(it) => it.syntax(),
             Self::SvelteAttachAttribute(it) => it.syntax(),
             Self::AnyVueDirective(it) => it.syntax(),
         }
@@ -6395,9 +6605,9 @@ impl AstNode for AnyHtmlAttribute {
     fn into_syntax(self) -> SyntaxNode {
         match self {
             Self::HtmlAttribute(it) => it.into_syntax(),
+            Self::HtmlAttributeDoubleTextExpression(it) => it.into_syntax(),
+            Self::HtmlAttributeSingleTextExpression(it) => it.into_syntax(),
             Self::HtmlBogusAttribute(it) => it.into_syntax(),
-            Self::HtmlDoubleTextExpression(it) => it.into_syntax(),
-            Self::HtmlSingleTextExpression(it) => it.into_syntax(),
             Self::SvelteAttachAttribute(it) => it.into_syntax(),
             Self::AnyVueDirective(it) => it.into_syntax(),
         }
@@ -6408,9 +6618,9 @@ impl std::fmt::Debug for AnyHtmlAttribute {
         match self {
             Self::AnyVueDirective(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlAttribute(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlAttributeDoubleTextExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlAttributeSingleTextExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlBogusAttribute(it) => std::fmt::Debug::fmt(it, f),
-            Self::HtmlDoubleTextExpression(it) => std::fmt::Debug::fmt(it, f),
-            Self::HtmlSingleTextExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::SvelteAttachAttribute(it) => std::fmt::Debug::fmt(it, f),
         }
     }
@@ -6420,9 +6630,9 @@ impl From<AnyHtmlAttribute> for SyntaxNode {
         match n {
             AnyHtmlAttribute::AnyVueDirective(it) => it.into_syntax(),
             AnyHtmlAttribute::HtmlAttribute(it) => it.into_syntax(),
+            AnyHtmlAttribute::HtmlAttributeDoubleTextExpression(it) => it.into_syntax(),
+            AnyHtmlAttribute::HtmlAttributeSingleTextExpression(it) => it.into_syntax(),
             AnyHtmlAttribute::HtmlBogusAttribute(it) => it.into_syntax(),
-            AnyHtmlAttribute::HtmlDoubleTextExpression(it) => it.into_syntax(),
-            AnyHtmlAttribute::HtmlSingleTextExpression(it) => it.into_syntax(),
             AnyHtmlAttribute::SvelteAttachAttribute(it) => it.into_syntax(),
         }
     }
@@ -6433,9 +6643,9 @@ impl From<AnyHtmlAttribute> for SyntaxElement {
         node.into()
     }
 }
-impl From<HtmlSingleTextExpression> for AnyHtmlAttributeInitializer {
-    fn from(node: HtmlSingleTextExpression) -> Self {
-        Self::HtmlSingleTextExpression(node)
+impl From<HtmlAttributeSingleTextExpression> for AnyHtmlAttributeInitializer {
+    fn from(node: HtmlAttributeSingleTextExpression) -> Self {
+        Self::HtmlAttributeSingleTextExpression(node)
     }
 }
 impl From<HtmlString> for AnyHtmlAttributeInitializer {
@@ -6446,14 +6656,16 @@ impl From<HtmlString> for AnyHtmlAttributeInitializer {
 impl AstNode for AnyHtmlAttributeInitializer {
     type Language = Language;
     const KIND_SET: SyntaxKindSet<Language> =
-        HtmlSingleTextExpression::KIND_SET.union(HtmlString::KIND_SET);
+        HtmlAttributeSingleTextExpression::KIND_SET.union(HtmlString::KIND_SET);
     fn can_cast(kind: SyntaxKind) -> bool {
-        matches!(kind, HTML_SINGLE_TEXT_EXPRESSION | HTML_STRING)
+        matches!(kind, HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION | HTML_STRING)
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
-            HTML_SINGLE_TEXT_EXPRESSION => {
-                Self::HtmlSingleTextExpression(HtmlSingleTextExpression { syntax })
+            HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION => {
+                Self::HtmlAttributeSingleTextExpression(HtmlAttributeSingleTextExpression {
+                    syntax,
+                })
             }
             HTML_STRING => Self::HtmlString(HtmlString { syntax }),
             _ => return None,
@@ -6462,13 +6674,13 @@ impl AstNode for AnyHtmlAttributeInitializer {
     }
     fn syntax(&self) -> &SyntaxNode {
         match self {
-            Self::HtmlSingleTextExpression(it) => it.syntax(),
+            Self::HtmlAttributeSingleTextExpression(it) => it.syntax(),
             Self::HtmlString(it) => it.syntax(),
         }
     }
     fn into_syntax(self) -> SyntaxNode {
         match self {
-            Self::HtmlSingleTextExpression(it) => it.into_syntax(),
+            Self::HtmlAttributeSingleTextExpression(it) => it.into_syntax(),
             Self::HtmlString(it) => it.into_syntax(),
         }
     }
@@ -6476,7 +6688,7 @@ impl AstNode for AnyHtmlAttributeInitializer {
 impl std::fmt::Debug for AnyHtmlAttributeInitializer {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::HtmlSingleTextExpression(it) => std::fmt::Debug::fmt(it, f),
+            Self::HtmlAttributeSingleTextExpression(it) => std::fmt::Debug::fmt(it, f),
             Self::HtmlString(it) => std::fmt::Debug::fmt(it, f),
         }
     }
@@ -6484,7 +6696,7 @@ impl std::fmt::Debug for AnyHtmlAttributeInitializer {
 impl From<AnyHtmlAttributeInitializer> for SyntaxNode {
     fn from(n: AnyHtmlAttributeInitializer) -> Self {
         match n {
-            AnyHtmlAttributeInitializer::HtmlSingleTextExpression(it) => it.into_syntax(),
+            AnyHtmlAttributeInitializer::HtmlAttributeSingleTextExpression(it) => it.into_syntax(),
             AnyHtmlAttributeInitializer::HtmlString(it) => it.into_syntax(),
         }
     }
@@ -7312,6 +7524,11 @@ impl std::fmt::Display for HtmlAttribute {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for HtmlAttributeDoubleTextExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for HtmlAttributeInitializerClause {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
@@ -7322,6 +7539,11 @@ impl std::fmt::Display for HtmlAttributeName {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for HtmlAttributeSingleTextExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for HtmlCdataSection {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/biome_html_syntax/src/generated/nodes_mut.rs b/crates/biome_html_syntax/src/generated/nodes_mut.rs
index e690dfef61fd..f2fbb6334fc1 100644
--- a/crates/biome_html_syntax/src/generated/nodes_mut.rs
+++ b/crates/biome_html_syntax/src/generated/nodes_mut.rs
@@ -45,6 +45,26 @@ impl HtmlAttribute {
         ))
     }
 }
+impl HtmlAttributeDoubleTextExpression {
+    pub fn with_l_double_curly_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_expression(self, element: HtmlTextExpression) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_double_curly_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into()))),
+        )
+    }
+}
 impl HtmlAttributeInitializerClause {
     pub fn with_eq_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
@@ -67,6 +87,26 @@ impl HtmlAttributeName {
         )
     }
 }
+impl HtmlAttributeSingleTextExpression {
+    pub fn with_l_curly_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(0usize..=0usize, once(Some(element.into()))),
+        )
+    }
+    pub fn with_expression(self, element: HtmlTextExpression) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(1usize..=1usize, once(Some(element.into_syntax().into()))),
+        )
+    }
+    pub fn with_r_curly_token(self, element: SyntaxToken) -> Self {
+        Self::unwrap_cast(
+            self.syntax
+                .splice_slots(2usize..=2usize, once(Some(element.into()))),
+        )
+    }
+}
 impl HtmlCdataSection {
     pub fn with_cdata_start_token(self, element: SyntaxToken) -> Self {
         Self::unwrap_cast(
diff --git a/xtask/codegen/html.ungram b/xtask/codegen/html.ungram
index 83b0f5763f8d..c3fdf23136a4 100644
--- a/xtask/codegen/html.ungram
+++ b/xtask/codegen/html.ungram
@@ -162,8 +162,8 @@ HtmlAttributeList = AnyHtmlAttribute*
 
 AnyHtmlAttribute =
 	HtmlAttribute
-	| HtmlDoubleTextExpression
-	| HtmlSingleTextExpression
+	| HtmlAttributeDoubleTextExpression
+	| HtmlAttributeSingleTextExpression
 	| SvelteAttachAttribute
 	| AnyVueDirective
 	| HtmlBogusAttribute
@@ -184,8 +184,24 @@ HtmlAttributeInitializerClause =
 
 AnyHtmlAttributeInitializer =
 	HtmlString
-	| HtmlSingleTextExpression
+	| HtmlAttributeSingleTextExpression
+
+
+// <a {{ expression }}>
+//    ^^^^^^^^^^^^^^^^
+HtmlAttributeDoubleTextExpression =
+	'{{'
+	expression: HtmlTextExpression
+	'}}'
 
+// <a {expression}>
+//    ^^^^^^^^^^^^
+// <a href={expression}>
+//         ^^^^^^^^^^^^
+HtmlAttributeSingleTextExpression =
+	'{'
+	expression: HtmlTextExpression
+	'}'
 
 
 // ==================================
diff --git a/xtask/codegen/src/html_kinds_src.rs b/xtask/codegen/src/html_kinds_src.rs
index 81d13188438d..678405461f8c 100644
--- a/xtask/codegen/src/html_kinds_src.rs
+++ b/xtask/codegen/src/html_kinds_src.rs
@@ -77,6 +77,8 @@ pub const HTML_KINDS_SRC: KindsSrc = KindsSrc {
         "HTML_DOUBLE_TEXT_EXPRESSION",
         "HTML_SINGLE_TEXT_EXPRESSION",
         "HTML_TEXT_EXPRESSION",
+        "HTML_ATTRIBUTE_DOUBLE_TEXT_EXPRESSION",
+        "HTML_ATTRIBUTE_SINGLE_TEXT_EXPRESSION",
         // Astro nodes
         "ASTRO_FRONTMATTER_ELEMENT",
         "ASTRO_EMBEDDED_CONTENT",