diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6d68d5278fe..798d56be795 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -91,6 +91,18 @@ if no error diagnostics are emitted.
   rome check --error-on-wanrings ./src
   ```
 
+- Add a configuration to enable parsing comments inside JSON files:
+
+  ```json
+  {
+    "json": {
+      "parser": {
+        "allowComments": true
+      }
+    }
+  }
+  ```
+
 ### Editors
 
 #### Other changes
@@ -99,9 +111,11 @@ if no error diagnostics are emitted.
 
 ### Formatter
 
-- Added a new option called `--jsx-quote-style` to the formatter. This option allows you to choose between single and double quotes for JSX attributes. [#4486](https://github.com/rome/tools/issues/4486)
+- Add a new option called `--jsx-quote-style` to the formatter. This option allows you to choose between single and double quotes for JSX attributes. [#4486](https://github.com/rome/tools/issues/4486)
 
-- Added a new option called `--arrow-parentheses` to the formatter. This option allows you to set the parentheses style for arrow functions. [#4666](https://github.com/rome/tools/issues/4666)
+- Add a new option called `--arrow-parentheses` to the formatter. This option allows you to set the parentheses style for arrow functions. [#4666](https://github.com/rome/tools/issues/4666)
+
+- The JSON formatter is now able to format `.json` files that have comments.
 
 ### Linter
 
@@ -345,7 +359,17 @@ if no error diagnostics are emitted.
  		}
  	}
 	```
+- Add for parsing comments inside JSON files:
 
+  ```json
+  {
+    "json": {
+      "parser": {
+        "allowComments": true
+      }
+    }
+  }
+  ```
 ### VSCode
 
 ### JavaScript APIs
diff --git a/Cargo.lock b/Cargo.lock
index 8eb3b6f1c1f..1d29440b4d8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2075,6 +2075,7 @@ dependencies = [
  "rome_json_syntax",
  "rome_parser",
  "rome_rowan",
+ "rome_suppression",
  "serde",
  "serde_json",
  "tests_macros",
@@ -2215,6 +2216,15 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "rome_suppression"
+version = "0.0.1"
+dependencies = [
+ "rome_console",
+ "rome_diagnostics",
+ "rome_rowan",
+]
+
 [[package]]
 name = "rome_text_edit"
 version = "0.0.1"
diff --git a/Cargo.toml b/Cargo.toml
index 138a7f74b94..494d9522e29 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -60,6 +60,7 @@ rome_migrate                = { path = "./crates/rome_migrate" }
 rome_parser                 = { version = "0.0.1", path = "./crates/rome_parser" }
 rome_rowan                  = { version = "0.0.1", path = "./crates/rome_rowan" }
 rome_service                = { path = "./crates/rome_service" }
+rome_suppression            = { version = "0.0.1", path = "./crates/rome_suppression" }
 rome_text_edit              = { version = "0.0.1", path = "./crates/rome_text_edit" }
 rome_text_size              = { version = "0.0.1", path = "./crates/rome_text_size" }
 tests_macros                = { path = "./crates/tests_macros" }
diff --git a/crates/rome_cli/tests/snapshots/main_commands_format/ignore_comments_error_when_allow_comments.snap b/crates/rome_cli/tests/snapshots/main_commands_format/ignore_comments_error_when_allow_comments.snap
index 8533db6ebd7..e2c875de6ae 100644
--- a/crates/rome_cli/tests/snapshots/main_commands_format/ignore_comments_error_when_allow_comments.snap
+++ b/crates/rome_cli/tests/snapshots/main_commands_format/ignore_comments_error_when_allow_comments.snap
@@ -18,17 +18,6 @@ expression: content
 
 /*test*/ [1, 2, 3]
 	
-```
-
-# Termination Message
-
-```block
-internalError/io ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × No files were processed in the specified paths.
-  
-
-
 ```
 
 # Emitted Messages
@@ -36,7 +25,12 @@ internalError/io ━━━━━━━━━━━━━━━━━━━━━
 ```block
 tsconfig.json format ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-  × Format with errors is disabled.
+  i Formatter would have printed the following content:
+  
+    1   │ - 
+    2 1 │   /*test*/ [1, 2, 3]
+    3   │ - → 
+      2 │ + 
   
 
 ```
@@ -45,8 +39,4 @@ tsconfig.json format ━━━━━━━━━━━━━━━━━━━
 Compared 1 file(s) in <TIME>
 ```
 
-```block
-Skipped 1 file(s)
-```
-
 
diff --git a/crates/rome_formatter/src/comments.rs b/crates/rome_formatter/src/comments.rs
index 63ed14709c7..6dc34697d5f 100644
--- a/crates/rome_formatter/src/comments.rs
+++ b/crates/rome_formatter/src/comments.rs
@@ -1173,3 +1173,47 @@ where
         write!(f, [item.piece.as_piece()])
     }
 }
+
+/// Returns `true` if `comment` is a multi line block comment:
+///
+/// # Examples
+///
+/// ```rs,ignore
+/// assert!(is_doc_comment(&parse_comment(r#"
+///     /**
+///      * Multiline doc comment
+///      */
+/// "#)));
+///
+/// assert!(is_doc_comment(&parse_comment(r#"
+///     /*
+///      * Single star
+///      */
+/// "#)));
+///
+///
+/// // Non doc-comments
+/// assert!(!is_doc_comment(&parse_comment(r#"/** has no line break */"#)));
+///
+/// assert!(!is_doc_comment(&parse_comment(r#"
+/// /*
+///  *
+///  this line doesn't start with a star
+///  */
+/// "#)));
+/// ```
+pub fn is_doc_comment<L: Language>(comment: &SyntaxTriviaPieceComments<L>) -> bool {
+    if !comment.has_newline() {
+        return false;
+    }
+
+    let text = comment.text();
+
+    text.lines().enumerate().all(|(index, line)| {
+        if index == 0 {
+            line.starts_with("/*")
+        } else {
+            line.trim_start().starts_with('*')
+        }
+    })
+}
diff --git a/crates/rome_formatter_test/src/check_reformat.rs b/crates/rome_formatter_test/src/check_reformat.rs
index 92fdb545ac8..648fc3c2bf2 100644
--- a/crates/rome_formatter_test/src/check_reformat.rs
+++ b/crates/rome_formatter_test/src/check_reformat.rs
@@ -71,6 +71,7 @@ where
             .language
             .format_node(self.options.clone(), &re_parse.syntax())
             .unwrap();
+
         let printed = formatted.print().unwrap();
 
         if self.text != printed.as_code() {
diff --git a/crates/rome_js_formatter/src/comments.rs b/crates/rome_js_formatter/src/comments.rs
index 41e9f0bb980..1678f6bb1ec 100644
--- a/crates/rome_js_formatter/src/comments.rs
+++ b/crates/rome_js_formatter/src/comments.rs
@@ -1,6 +1,7 @@
 use crate::prelude::*;
 use crate::utils::AnyJsConditional;
 use rome_diagnostics_categories::category;
+use rome_formatter::comments::is_doc_comment;
 use rome_formatter::{
     comments::{
         CommentKind, CommentPlacement, CommentStyle, CommentTextPosition, Comments,
@@ -67,67 +68,6 @@ impl FormatRule<SourceComment<JsLanguage>> for FormatJsLeadingComment {
     }
 }
 
-/// Returns `true` if `comment` is a multi line block comment:
-///
-/// # Examples
-///
-/// ```
-/// # use rome_js_parser::{JsParserOptions, parse_module};
-/// # use rome_js_syntax::JsLanguage;
-/// # use rome_rowan::{Direction, SyntaxTriviaPieceComments};
-///  use rome_js_formatter::comments::is_doc_comment;
-///
-/// # fn parse_comment(source: &str) -> SyntaxTriviaPieceComments<JsLanguage> {
-/// #     let root = parse_module(source, JsParserOptions::default()).tree();
-/// #     root
-/// #        .eof_token()
-/// #        .expect("Root to have an EOF token")
-/// #        .leading_trivia()
-/// #        .pieces()
-/// #        .filter_map(|piece| piece.as_comments())
-/// #        .next()
-/// #        .expect("Source to contain a comment.")
-/// # }
-///
-/// assert!(is_doc_comment(&parse_comment(r#"
-///     /**
-///      * Multiline doc comment
-///      */
-/// "#)));
-///
-/// assert!(is_doc_comment(&parse_comment(r#"
-///     /*
-///      * Single star
-///      */
-/// "#)));
-///
-///
-/// // Non doc-comments
-/// assert!(!is_doc_comment(&parse_comment(r#"/** has no line break */"#)));
-///
-/// assert!(!is_doc_comment(&parse_comment(r#"
-/// /*
-///  *
-///  this line doesn't start with a star
-///  */
-/// "#)));
-/// ```
-pub fn is_doc_comment(comment: &SyntaxTriviaPieceComments<JsLanguage>) -> bool {
-    if !comment.has_newline() {
-        return false;
-    }
-
-    let text = comment.text();
-
-    text.lines().enumerate().all(|(index, line)| {
-        if index == 0 {
-            line.starts_with("/*")
-        } else {
-            line.trim_start().starts_with('*')
-        }
-    })
-}
-
 #[derive(Eq, PartialEq, Copy, Clone, Debug, Default)]
 pub struct JsCommentStyle;
 
diff --git a/crates/rome_js_formatter/src/lib.rs b/crates/rome_js_formatter/src/lib.rs
index 2c4c4519f8f..e0817200d43 100644
--- a/crates/rome_js_formatter/src/lib.rs
+++ b/crates/rome_js_formatter/src/lib.rs
@@ -86,7 +86,7 @@
 //! It helps you to understand which nodes need to be implemented/modified
 //! in order to implement formatting. Alternatively, you can locally run the playground by following
 //! the [playground instructions](https://github.com/rome/tools/blob/main/website/playground/README.md).
-//! 5. Use the [`quick_test()`](https://github.com/rome/tools/blob/main/crates/rome_js_formatter/src/lib.rs#L597-L616)
+//! 5. Use the `quick_test.rs` file in `tests/` directory.
 //! function to test you snippet straight from your IDE, without running the whole test suite. The test
 //! is ignored on purpose, so you won't need to worry about the CI breaking.
 //!
diff --git a/crates/rome_js_formatter/tests/quick_test.rs b/crates/rome_js_formatter/tests/quick_test.rs
index bde26a22f2d..e1c8eda4b4c 100644
--- a/crates/rome_js_formatter/tests/quick_test.rs
+++ b/crates/rome_js_formatter/tests/quick_test.rs
@@ -29,7 +29,6 @@ fn quick_test() {
         syntax,
         JsParserOptions::default().with_parse_class_parameter_decorators(),
     );
-    dbg!(tree.syntax());
     let options = JsFormatOptions::new(syntax)
         .with_semicolons(Semicolons::Always)
         .with_quote_style(QuoteStyle::Double)
diff --git a/crates/rome_json_formatter/Cargo.toml b/crates/rome_json_formatter/Cargo.toml
index fb7150a0fba..e990ab5a670 100644
--- a/crates/rome_json_formatter/Cargo.toml
+++ b/crates/rome_json_formatter/Cargo.toml
@@ -13,14 +13,15 @@ version              = "0.0.1"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+rome_diagnostics = { workspace = true }
 rome_formatter   = { workspace = true }
 rome_json_syntax = { workspace = true }
 rome_rowan       = { workspace = true }
+rome_suppression = { workspace = true }
 
 [dev-dependencies]
 countme             = { workspace = true, features = ["enable"] }
 insta               = { workspace = true, features = ["glob"] }
-rome_diagnostics    = { workspace = true }
 rome_formatter_test = { workspace = true }
 rome_fs             = { workspace = true }
 rome_json_factory   = { workspace = true }
diff --git a/crates/rome_json_formatter/src/comments.rs b/crates/rome_json_formatter/src/comments.rs
new file mode 100644
index 00000000000..ab0881049cd
--- /dev/null
+++ b/crates/rome_json_formatter/src/comments.rs
@@ -0,0 +1,85 @@
+use crate::prelude::*;
+use rome_diagnostics::category;
+use rome_formatter::comments::{
+    is_doc_comment, CommentKind, CommentStyle, Comments, SourceComment,
+};
+use rome_formatter::formatter::Formatter;
+use rome_formatter::{write, FormatResult, FormatRule};
+use rome_json_syntax::{JsonLanguage, TextLen};
+use rome_rowan::SyntaxTriviaPieceComments;
+use rome_suppression::parse_suppression_comment;
+
+pub type JsonComments = Comments<JsonLanguage>;
+
+#[derive(Default)]
+pub struct FormatJsonLeadingComment;
+
+impl FormatRule<SourceComment<JsonLanguage>> for FormatJsonLeadingComment {
+    type Context = JsonFormatContext;
+
+    fn fmt(
+        &self,
+        comment: &SourceComment<JsonLanguage>,
+        f: &mut Formatter<Self::Context>,
+    ) -> FormatResult<()> {
+        if is_doc_comment(comment.piece()) {
+            let mut source_offset = comment.piece().text_range().start();
+
+            let mut lines = comment.piece().text().lines();
+
+            // SAFETY: Safe, `is_doc_comment` only returns `true` for multiline comments
+            let first_line = lines.next().unwrap();
+            write!(f, [dynamic_text(first_line.trim_end(), source_offset)])?;
+
+            source_offset += first_line.text_len();
+
+            // Indent the remaining lines by one space so that all `*` are aligned.
+            write!(
+                f,
+                [align(
+                    1,
+                    &format_once(|f| {
+                        for line in lines {
+                            write!(
+                                f,
+                                [hard_line_break(), dynamic_text(line.trim(), source_offset)]
+                            )?;
+
+                            source_offset += line.text_len();
+                        }
+
+                        Ok(())
+                    })
+                )]
+            )
+        } else {
+            write!(f, [comment.piece().as_piece()])
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Copy, Clone, Debug, Default)]
+pub struct JsonCommentStyle;
+
+impl CommentStyle for JsonCommentStyle {
+    type Language = JsonLanguage;
+
+    fn is_suppression(text: &str) -> bool {
+        parse_suppression_comment(text)
+            .filter_map(Result::ok)
+            .flat_map(|suppression| suppression.categories)
+            .any(|(key, _)| key == category!("format"))
+    }
+
+    fn get_comment_kind(comment: &SyntaxTriviaPieceComments<Self::Language>) -> CommentKind {
+        if comment.text().starts_with("/*") {
+            if comment.has_newline() {
+                CommentKind::Block
+            } else {
+                CommentKind::InlineBlock
+            }
+        } else {
+            CommentKind::Line
+        }
+    }
+}
diff --git a/crates/rome_json_formatter/src/context.rs b/crates/rome_json_formatter/src/context.rs
index bb2a5205ff9..1dcba2b7f2e 100644
--- a/crates/rome_json_formatter/src/context.rs
+++ b/crates/rome_json_formatter/src/context.rs
@@ -4,23 +4,32 @@ use rome_formatter::{
     CstFormatContext, FormatContext, FormatOptions, IndentStyle, LineWidth, TransformSourceMap,
 };
 
-use rome_formatter::comments::{Comments, FormatPlainComment};
+use crate::comments::{FormatJsonLeadingComment, JsonComments};
 use rome_json_syntax::JsonLanguage;
 use std::fmt;
+use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct JsonFormatContext {
     options: JsonFormatOptions,
-    comments: Comments<JsonLanguage>,
+    /// The comments of the nodes and tokens in the program.
+    comments: Rc<JsonComments>,
+    source_map: Option<TransformSourceMap>,
 }
 
 impl JsonFormatContext {
-    pub fn new(options: JsonFormatOptions) -> Self {
+    pub fn new(options: JsonFormatOptions, comments: JsonComments) -> Self {
         Self {
             options,
-            comments: Comments::default(),
+            comments: Rc::new(comments),
+            source_map: None,
         }
     }
+
+    pub fn with_source_map(mut self, source_map: Option<TransformSourceMap>) -> Self {
+        self.source_map = source_map;
+        self
+    }
 }
 
 impl FormatContext for JsonFormatContext {
@@ -38,9 +47,9 @@ impl FormatContext for JsonFormatContext {
 impl CstFormatContext for JsonFormatContext {
     type Language = JsonLanguage;
     type Style = JsonCommentStyle;
-    type CommentRule = FormatPlainComment<Self>;
+    type CommentRule = FormatJsonLeadingComment;
 
-    fn comments(&self) -> &Comments<Self::Language> {
+    fn comments(&self) -> &JsonComments {
         &self.comments
     }
 }
diff --git a/crates/rome_json_formatter/src/json/value/object_value.rs b/crates/rome_json_formatter/src/json/value/object_value.rs
index b2e4481d0a7..bbaf952f8fb 100644
--- a/crates/rome_json_formatter/src/json/value/object_value.rs
+++ b/crates/rome_json_formatter/src/json/value/object_value.rs
@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use rome_formatter::write;
+use rome_formatter::{format_args, write};
 use rome_json_syntax::JsonObjectValue;
 use rome_rowan::AstNode;
 
@@ -8,18 +8,43 @@ pub(crate) struct FormatJsonObjectValue;
 
 impl FormatNodeRule<JsonObjectValue> for FormatJsonObjectValue {
     fn fmt_fields(&self, node: &JsonObjectValue, f: &mut JsonFormatter) -> FormatResult<()> {
-        write!(f, [node.l_curly_token().format(),])?;
-
         let should_expand = node.json_member_list().syntax().has_leading_newline();
 
-        write!(
-            f,
-            [group(&soft_space_or_block_indent(
-                &node.json_member_list().format()
-            ))
-            .should_expand(should_expand)]
-        )?;
+        let list = format_with(|f| {
+            write!(
+                f,
+                [group(&soft_space_or_block_indent(
+                    &node.json_member_list().format()
+                ))
+                .should_expand(should_expand)]
+            )
+        });
+        if f.comments().has_leading_comments(node.syntax()) {
+            write!(
+                f,
+                [
+                    format_leading_comments(node.syntax()),
+                    group(&format_args![
+                        node.l_curly_token().format(),
+                        list,
+                        node.r_curly_token().format()
+                    ]),
+                ]
+            )
+        } else {
+            write!(
+                f,
+                [
+                    node.l_curly_token().format(),
+                    list,
+                    node.r_curly_token().format()
+                ]
+            )
+        }
+    }
 
-        write!(f, [node.r_curly_token().format()])
+    fn fmt_leading_comments(&self, _: &JsonObjectValue, _: &mut JsonFormatter) -> FormatResult<()> {
+        // Formatted as part of `fmt_fields`
+        Ok(())
     }
 }
diff --git a/crates/rome_json_formatter/src/lib.rs b/crates/rome_json_formatter/src/lib.rs
index 2ea9e1bcc1b..a435b233789 100644
--- a/crates/rome_json_formatter/src/lib.rs
+++ b/crates/rome_json_formatter/src/lib.rs
@@ -1,3 +1,4 @@
+mod comments;
 pub mod context;
 mod cst;
 mod format_string;
@@ -6,18 +7,19 @@ mod json;
 mod prelude;
 mod separated;
 
+use crate::comments::JsonCommentStyle;
 pub(crate) use crate::context::JsonFormatContext;
 use crate::context::JsonFormatOptions;
 use crate::cst::FormatJsonSyntaxNode;
-use rome_formatter::comments::{CommentKind, CommentStyle};
+use rome_formatter::comments::Comments;
 use rome_formatter::prelude::*;
 use rome_formatter::{
-    FormatContext, FormatLanguage, FormatOwnedWithRule, FormatRefWithRule, FormatToken,
-    TransformSourceMap,
+    write, CstFormatContext, FormatContext, FormatLanguage, FormatOwnedWithRule, FormatRefWithRule,
+    FormatToken, TransformSourceMap,
 };
 use rome_formatter::{Formatted, Printed};
 use rome_json_syntax::{AnyJsonValue, JsonLanguage, JsonSyntaxNode, JsonSyntaxToken};
-use rome_rowan::{AstNode, SyntaxNode, SyntaxTriviaPieceComments, TextRange};
+use rome_rowan::{AstNode, SyntaxNode, TextRange};
 
 /// Used to get an object that knows how to format this object.
 pub(crate) trait AsFormat<Context> {
@@ -159,17 +161,57 @@ where
 
 pub(crate) type JsonFormatter<'buf> = Formatter<'buf, JsonFormatContext>;
 
+/// Format a [JsonSyntaxNode]
 pub(crate) trait FormatNodeRule<N>
 where
     N: AstNode<Language = JsonLanguage>,
 {
     fn fmt(&self, node: &N, f: &mut JsonFormatter) -> FormatResult<()> {
-        f.comments().mark_suppression_checked(node.syntax());
+        if self.is_suppressed(node, f) {
+            return write!(f, [format_suppressed_node(node.syntax())]);
+        }
 
-        self.fmt_fields(node, f)
+        self.fmt_leading_comments(node, f)?;
+        self.fmt_fields(node, f)?;
+        self.fmt_dangling_comments(node, f)?;
+        self.fmt_trailing_comments(node, f)
     }
 
     fn fmt_fields(&self, node: &N, f: &mut JsonFormatter) -> FormatResult<()>;
+
+    /// Returns `true` if the node has a suppression comment and should use the same formatting as in the source document.
+    fn is_suppressed(&self, node: &N, f: &JsonFormatter) -> bool {
+        f.context().comments().is_suppressed(node.syntax())
+    }
+
+    /// Formats the [leading comments](rome_formatter::comments#leading-comments) of the node.
+    ///
+    /// You may want to override this method if you want to manually handle the formatting of comments
+    /// inside of the `fmt_fields` method or customize the formatting of the leading comments.
+    fn fmt_leading_comments(&self, node: &N, f: &mut JsonFormatter) -> FormatResult<()> {
+        format_leading_comments(node.syntax()).fmt(f)
+    }
+
+    /// Formats the [dangling comments](rome_formatter::comments#dangling-comments) of the node.
+    ///
+    /// You should override this method if the node handled by this rule can have dangling comments because the
+    /// default implementation formats the dangling comments at the end of the node, which isn't ideal but ensures that
+    /// no comments are dropped.
+    ///
+    /// A node can have dangling comments if all its children are tokens or if all node childrens are optional.
+    fn fmt_dangling_comments(&self, node: &N, f: &mut JsonFormatter) -> FormatResult<()> {
+        format_dangling_comments(node.syntax())
+            .with_soft_block_indent()
+            .fmt(f)
+    }
+
+    /// Formats the [trailing comments](rome_formatter::comments#trailing-comments) of the node.
+    ///
+    /// You may want to override this method if you want to manually handle the formatting of comments
+    /// inside of the `fmt_fields` method or customize the formatting of the trailing comments.
+    fn fmt_trailing_comments(&self, node: &N, f: &mut JsonFormatter) -> FormatResult<()> {
+        format_trailing_comments(node.syntax()).fmt(f)
+    }
 }
 
 /// Rule for formatting an bogus nodes.
@@ -208,21 +250,11 @@ impl FormatLanguage for JsonFormatLanguage {
 
     fn create_context(
         self,
-        _root: &JsonSyntaxNode,
-        _source_map: Option<TransformSourceMap>,
+        root: &JsonSyntaxNode,
+        source_map: Option<TransformSourceMap>,
     ) -> Self::Context {
-        JsonFormatContext::new(self.options)
-    }
-}
-
-#[derive(Default)]
-pub struct JsonCommentStyle;
-
-impl CommentStyle for JsonCommentStyle {
-    type Language = JsonLanguage;
-
-    fn get_comment_kind(_: &SyntaxTriviaPieceComments<Self::Language>) -> CommentKind {
-        CommentKind::Line
+        let comments = Comments::from_node(root, &JsonCommentStyle, source_map.as_ref());
+        JsonFormatContext::new(self.options, comments).with_source_map(source_map)
     }
 }
 
diff --git a/crates/rome_json_formatter/tests/language.rs b/crates/rome_json_formatter/tests/language.rs
index 38fedeaf9e5..bae948c95b9 100644
--- a/crates/rome_json_formatter/tests/language.rs
+++ b/crates/rome_json_formatter/tests/language.rs
@@ -20,7 +20,7 @@ impl TestFormatLanguage for JsonTestFormatLanguage {
     type FormatLanguage = JsonFormatLanguage;
 
     fn parse(&self, text: &str) -> AnyParse {
-        let parse = parse_json(text, JsonParserOptions::default());
+        let parse = parse_json(text, JsonParserOptions::default().with_allow_comments());
 
         AnyParse::new(
             parse.syntax().as_send().unwrap(),
diff --git a/crates/rome_json_formatter/tests/quick_test.rs b/crates/rome_json_formatter/tests/quick_test.rs
index 0286f31d3bc..ac11556e689 100644
--- a/crates/rome_json_formatter/tests/quick_test.rs
+++ b/crates/rome_json_formatter/tests/quick_test.rs
@@ -11,23 +11,11 @@ mod language {
 #[test]
 // use this test check if your snippet prints as you wish, without using a snapshot
 fn quick_test() {
-    let src = r#"
-{
-    "enabled": true,
-    "formatWithErrors": false,
-    "indentSize": 2,
-    "indentStyle": "space",
-    "lineWidth": 80,
-    "ignore": [
-      "**/cache/**",
-      "**/dist/**",
-      "./packages/laravel/**/*",
-      "./packages/presets/templates/**/*",
-      "./sandboxes/**/*"
-    ]
-  }
+    let src = r#"// comment
+ // comment
+ { "test": "test"} /** comment **/
 "#;
-    let parse = parse_json(src, JsonParserOptions::default());
+    let parse = parse_json(src, JsonParserOptions::default().with_allow_comments());
     let options = JsonFormatOptions::default();
     let result = format_node(options.clone(), &parse.syntax())
         .unwrap()
@@ -36,19 +24,17 @@ fn quick_test() {
 
     let root = &parse.syntax();
     let language = language::JsonTestFormatLanguage::default();
+
     let check_reformat =
         CheckReformat::new(root, result.as_code(), "quick_test", &language, options);
     check_reformat.check_reformat();
 
     assert_eq!(
         result.as_code(),
-        r#"{
-    "a": 5,
-    "b": [1, 2, 3, 4],
-    "c": null,
-    "d": true,
-    "e": false
-}
+        r#"// comment
+// comment
+{ "test": "test"}
+// comment
 "#
     );
 }
diff --git a/crates/rome_json_formatter/tests/specs/json/comments/multiline.json b/crates/rome_json_formatter/tests/specs/json/comments/multiline.json
new file mode 100644
index 00000000000..9c25dcd8bec
--- /dev/null
+++ b/crates/rome_json_formatter/tests/specs/json/comments/multiline.json
@@ -0,0 +1,16 @@
+/**
+* Leading
+**/ {
+	/**
+	* Leading
+	**/
+	"number": 1123123213123123123123122311231232131231231231231223,/**
+* Trailing
+**/
+	"string": "some-long-long-long-long-long-long-long-string",
+	"array": [12312321, {"another-number": 12321321, "string": "some-string"}],
+	"object": {"array":  [123214123, "some-long-long-string", [12312312, "some-long-long-string"]]},
+	"null": null
+} /**
+* Trailing
+**/
diff --git a/crates/rome_json_formatter/tests/specs/json/comments/multiline.json.snap b/crates/rome_json_formatter/tests/specs/json/comments/multiline.json.snap
new file mode 100644
index 00000000000..d83f2b28474
--- /dev/null
+++ b/crates/rome_json_formatter/tests/specs/json/comments/multiline.json.snap
@@ -0,0 +1,65 @@
+---
+source: crates/rome_formatter_test/src/snapshot_builder.rs
+info: json/comments/multiline.json
+---
+
+# Input
+
+```json
+/**
+* Leading
+**/ {
+	/**
+	* Leading
+	**/
+	"number": 1123123213123123123123122311231232131231231231231223,/**
+* Trailing
+**/
+	"string": "some-long-long-long-long-long-long-long-string",
+	"array": [12312321, {"another-number": 12321321, "string": "some-string"}],
+	"object": {"array":  [123214123, "some-long-long-string", [12312312, "some-long-long-string"]]},
+	"null": null
+} /**
+* Trailing
+**/
+
+```
+
+
+=============================
+
+# Outputs
+
+## Output 1
+
+-----
+Indent style: Tab
+Line width: 80
+-----
+
+```json
+/**
+ * Leading
+ **/ {
+	/**
+	 * Leading
+	 **/
+	"number": 1123123213123123123123122311231232131231231231231223 /**
+	 * Trailing
+	 **/,
+	"string": "some-long-long-long-long-long-long-long-string",
+	"array": [12312321, { "another-number": 12321321, "string": "some-string" }],
+	"object": {
+		"array": [
+			123214123,
+			"some-long-long-string",
+			[12312312, "some-long-long-string"]
+		]
+	},
+	"null": null
+} /**
+ * Trailing
+ **/
+```
+
+
diff --git a/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/block-comment.json.snap b/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/block-comment.json.snap
deleted file mode 100644
index 65213160ef8..00000000000
--- a/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/block-comment.json.snap
+++ /dev/null
@@ -1,54 +0,0 @@
----
-source: crates/rome_formatter_test/src/snapshot_builder.rs
-info:
-  test_file: json/with-comment/block-comment.json
----
-
-# Input
-
-```json
-{/*comment*/"K":"V"}
-
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1 +1 @@
--{ /*comment*/ "K": "V" }
-+{/*comment*/"K":"V"}
-```
-
-# Output
-
-```json
-{/*comment*/"K":"V"}
-```
-
-# Errors
-```
-block-comment.json:1:2 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × JSON standard does not allow comments.
-  
-  > 1 │ {/*comment*/"K":"V"}
-      │  ^^^^^^^^^^^
-    2 │ 
-  
-block-comment.json:1:13 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × expected `,` but instead found `"K"`
-  
-  > 1 │ {/*comment*/"K":"V"}
-      │             ^^^
-    2 │ 
-  
-  i Remove "K"
-  
-
-```
-
-
diff --git a/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/line-comment.json.snap b/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/line-comment.json.snap
deleted file mode 100644
index 5aa1ed412f3..00000000000
--- a/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/line-comment.json.snap
+++ /dev/null
@@ -1,114 +0,0 @@
----
-source: crates/rome_formatter_test/src/snapshot_builder.rs
-info:
-  test_file: json/with-comment/line-comment.json
----
-
-# Input
-
-```json
-{
-  //comment
-  "K":"V"
-}
-
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,4 +1,4 @@
- {
-   //comment
--  "K": "V"
-+  "K":"V"
- }
-```
-
-# Output
-
-```json
-{
-  //comment
-  "K":"V"
-}
-```
-
-# Errors
-```
-line-comment.json:2:3 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × expected a property but instead found '//comment'
-  
-    1 │ {
-  > 2 │   //comment
-      │   ^^^^^^^^^
-    3 │   "K":"V"
-    4 │ }
-  
-  i Expected a property here
-  
-    1 │ {
-  > 2 │   //comment
-      │   ^^^^^^^^^
-    3 │   "K":"V"
-    4 │ }
-  
-line-comment.json:3:3 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × End of file expected
-  
-    1 │ {
-    2 │   //comment
-  > 3 │   "K":"V"
-      │   ^^^
-    4 │ }
-    5 │ 
-  
-  i Use an array for a sequence of values: `[1, 2]`
-  
-line-comment.json:3:6 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × End of file expected
-  
-    1 │ {
-    2 │   //comment
-  > 3 │   "K":"V"
-      │      ^
-    4 │ }
-    5 │ 
-  
-  i Use an array for a sequence of values: `[1, 2]`
-  
-line-comment.json:3:7 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × End of file expected
-  
-    1 │ {
-    2 │   //comment
-  > 3 │   "K":"V"
-      │       ^^^
-    4 │ }
-    5 │ 
-  
-  i Use an array for a sequence of values: `[1, 2]`
-  
-line-comment.json:4:1 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × End of file expected
-  
-    2 │   //comment
-    3 │   "K":"V"
-  > 4 │ }
-      │ ^
-    5 │ 
-  
-  i Use an array for a sequence of values: `[1, 2]`
-  
-
-```
-
-
diff --git a/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/top-block-comment.json.snap b/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/top-block-comment.json.snap
deleted file mode 100644
index 2eb2525fdf7..00000000000
--- a/crates/rome_json_formatter/tests/specs/prettier/json/with-comment/top-block-comment.json.snap
+++ /dev/null
@@ -1,64 +0,0 @@
----
-source: crates/rome_formatter_test/src/snapshot_builder.rs
-info:
-  test_file: json/with-comment/top-block-comment.json
----
-
-# Input
-
-```json
-/* comment */{
-  "foo": "bar"
-}
-
-```
-
-
-# Prettier differences
-
-```diff
---- Prettier
-+++ Rome
-@@ -1,3 +1,3 @@
--/* comment */ {
-+/* comment */{
-   "foo": "bar"
- }
-```
-
-# Output
-
-```json
-/* comment */{
-  "foo": "bar"
-}
-```
-
-# Errors
-```
-top-block-comment.json:1:1 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × JSON standard does not allow comments.
-  
-  > 1 │ /* comment */{
-      │ ^^^^^^^^^^^^^
-    2 │   "foo": "bar"
-    3 │ }
-  
-top-block-comment.json:1:14 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  × End of file expected
-  
-  > 1 │ /* comment */{
-      │              ^
-  > 2 │   "foo": "bar"
-  > 3 │ }
-      │ ^
-    4 │ 
-  
-  i Use an array for a sequence of values: `[1, 2]`
-  
-
-```
-
-
diff --git a/crates/rome_json_parser/src/parser.rs b/crates/rome_json_parser/src/parser.rs
index 02a3eed26ff..58842128238 100644
--- a/crates/rome_json_parser/src/parser.rs
+++ b/crates/rome_json_parser/src/parser.rs
@@ -17,6 +17,13 @@ pub struct JsonParserOptions {
     pub allow_comments: bool,
 }
 
+impl JsonParserOptions {
+    pub fn with_allow_comments(mut self) -> Self {
+        self.allow_comments = true;
+        self
+    }
+}
+
 impl<'source> JsonParser<'source> {
     pub fn new(source: &'source str, config: JsonParserOptions) -> Self {
         Self {
diff --git a/crates/rome_service/src/file_handlers/json.rs b/crates/rome_service/src/file_handlers/json.rs
index bae1ee5cd02..6103c344a49 100644
--- a/crates/rome_service/src/file_handlers/json.rs
+++ b/crates/rome_service/src/file_handlers/json.rs
@@ -96,10 +96,9 @@ fn parse(
     settings: SettingsHandle,
     cache: &mut NodeCache,
 ) -> AnyParse {
-    let _parser = &settings.as_ref().languages.json.parser;
+    let parser = &settings.as_ref().languages.json.parser;
     let options: JsonParserOptions = JsonParserOptions {
-        // TODO: enable once the formatter is ready
-        allow_comments: false,
+        allow_comments: parser.allow_comments,
     };
     let source_type =
         JsonFileSource::try_from(rome_path.as_path()).unwrap_or_else(|_| match language_hint {
diff --git a/crates/rome_suppression/Cargo.toml b/crates/rome_suppression/Cargo.toml
new file mode 100644
index 00000000000..a5489b85f44
--- /dev/null
+++ b/crates/rome_suppression/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+authors     = { workspace = true }
+description = "Rome suppression utilities"
+edition     = { workspace = true }
+license     = { workspace = true }
+name        = "rome_suppression"
+repository  = { workspace = true }
+version     = "0.0.1"
+
+
+[dependencies]
+rome_console     = { workspace = true }
+rome_diagnostics = { workspace = true }
+rome_rowan       = { workspace = true }
diff --git a/crates/rome_suppression/README.md b/crates/rome_suppression/README.md
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/crates/rome_suppression/src/lib.rs b/crates/rome_suppression/src/lib.rs
new file mode 100644
index 00000000000..cec9ab53537
--- /dev/null
+++ b/crates/rome_suppression/src/lib.rs
@@ -0,0 +1,449 @@
+use rome_diagnostics::{Category, Diagnostic};
+use rome_rowan::{TextRange, TextSize};
+
+/// Single instance of a suppression comment, with the following syntax:
+///
+/// `// rome-ignore { <category> { (<value>) }? }+: <reason>`
+///
+/// The category broadly describes what feature is being suppressed (formatting,
+/// linting, ...) with the value being and optional, category-specific name of
+/// a specific element to disable (for instance a specific lint name). A single
+/// suppression may specify one or more categories + values, for instance to
+/// disable multiple lints at once
+///
+/// A suppression must specify a reason: this part has no semantic meaning but
+/// is required to document why a particular feature is being disable for this
+/// line (lint false-positive, specific formatting requirements, ...)
+#[derive(Debug, PartialEq, Eq)]
+pub struct Suppression<'a> {
+    /// List of categories for this suppression
+    ///
+    /// Categories are pair of the category name +
+    /// an optional category value
+    pub categories: Vec<(&'a Category, Option<&'a str>)>,
+    /// Reason for this suppression comment to exist
+    pub reason: &'a str,
+}
+
+pub fn parse_suppression_comment(
+    base: &str,
+) -> impl Iterator<Item = Result<Suppression, SuppressionDiagnostic>> {
+    let (head, mut comment) = base.split_at(2);
+    let is_block_comment = match head {
+        "//" => false,
+        "/*" => {
+            comment = comment
+                .strip_suffix("*/")
+                .or_else(|| comment.strip_suffix(&['*', '/']))
+                .unwrap_or(comment);
+            true
+        }
+        token => panic!("comment with unknown opening token {token:?}, from {comment}"),
+    };
+
+    comment.lines().filter_map(move |line| {
+        // Eat start of line whitespace
+        let mut line = line.trim_start();
+
+        // If we're in a block comment eat stars, then whitespace again
+        if is_block_comment {
+            line = line.trim_start_matches('*').trim_start()
+        }
+
+        const PATTERNS: [[char; 2]; 11] = [
+            ['r', 'R'],
+            ['o', 'O'],
+            ['m', 'M'],
+            ['e', 'E'],
+            ['-', '_'],
+            ['i', 'I'],
+            ['g', 'G'],
+            ['n', 'N'],
+            ['o', 'O'],
+            ['r', 'R'],
+            ['e', 'E'],
+        ];
+
+        // Checks for `/rome[-_]ignore/i` without a regex, or skip the line
+        // entirely if it doesn't match
+        for pattern in PATTERNS {
+            line = line.strip_prefix(pattern)?;
+        }
+
+        let line = line.trim_start();
+        Some(
+            parse_suppression_line(line).map_err(|err| SuppressionDiagnostic {
+                message: err.message,
+                // Adjust the position of the diagnostic in the whole comment
+                span: err.span + offset_from(base, line),
+            }),
+        )
+    })
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Diagnostic)]
+#[diagnostic(category = "suppressions/parse")]
+pub struct SuppressionDiagnostic {
+    #[message]
+    #[description]
+    message: SuppressionDiagnosticKind,
+    #[location(span)]
+    span: TextRange,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum SuppressionDiagnosticKind {
+    MissingColon,
+    ParseCategory(String),
+    MissingCategory,
+    MissingParen,
+}
+
+impl std::fmt::Display for SuppressionDiagnosticKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SuppressionDiagnosticKind::MissingColon => write!(
+                f,
+                "unexpected token, expected one of ':', '(' or whitespace"
+            ),
+            SuppressionDiagnosticKind::ParseCategory(category) => {
+                write!(f, "failed to parse category {category:?}")
+            }
+            SuppressionDiagnosticKind::MissingCategory => {
+                write!(f, "unexpected token, expected one of ':' or whitespace")
+            }
+            SuppressionDiagnosticKind::MissingParen => write!(f, "unexpected token, expected ')'"),
+        }
+    }
+}
+
+impl rome_console::fmt::Display for SuppressionDiagnosticKind {
+    fn fmt(&self, fmt: &mut rome_console::fmt::Formatter) -> std::io::Result<()> {
+        match self {
+            SuppressionDiagnosticKind::MissingColon => write!(
+                fmt,
+                "unexpected token, expected one of ':', '(' or whitespace"
+            ),
+            SuppressionDiagnosticKind::ParseCategory(category) => {
+                write!(fmt, "failed to parse category {category:?}")
+            }
+            SuppressionDiagnosticKind::MissingCategory => {
+                write!(fmt, "unexpected token, expected one of ':' or whitespace")
+            }
+            SuppressionDiagnosticKind::MissingParen => {
+                write!(fmt, "unexpected token, expected ')'")
+            }
+        }
+    }
+}
+
+/// Parse the `{ <category> { (<value>) }? }+: <reason>` section of a suppression line
+fn parse_suppression_line(base: &str) -> Result<Suppression, SuppressionDiagnostic> {
+    let mut line = base;
+    let mut categories = Vec::new();
+
+    loop {
+        // Find either a colon opening parenthesis or space
+        let separator = line
+            .find(|c: char| c == ':' || c == '(' || c.is_whitespace())
+            .ok_or_else(|| SuppressionDiagnostic {
+                message: SuppressionDiagnosticKind::MissingColon,
+                span: TextRange::at(offset_from(base, line), TextSize::of(line)),
+            })?;
+
+        let (category, rest) = line.split_at(separator);
+        let category = category.trim_end();
+        let category: Option<&'static Category> = if !category.is_empty() {
+            let category = category.parse().map_err(|()| SuppressionDiagnostic {
+                message: SuppressionDiagnosticKind::ParseCategory(category.into()),
+                span: TextRange::at(offset_from(base, category), TextSize::of(category)),
+            })?;
+            Some(category)
+        } else {
+            None
+        };
+
+        // Skip over and match the separator
+        let (separator, rest) = rest.split_at(1);
+
+        match separator {
+            // Colon token: stop parsing categories
+            ":" => {
+                if let Some(category) = category {
+                    categories.push((category, None));
+                }
+
+                line = rest.trim_start();
+                break;
+            }
+            // Paren token: parse a category + value
+            "(" => {
+                let category = category.ok_or_else(|| SuppressionDiagnostic {
+                    message: SuppressionDiagnosticKind::MissingCategory,
+                    span: TextRange::at(
+                        offset_from(base, line),
+                        offset_from(line, separator) + TextSize::of(separator),
+                    ),
+                })?;
+                let paren = rest.find(')').ok_or_else(|| SuppressionDiagnostic {
+                    message: SuppressionDiagnosticKind::MissingParen,
+                    span: TextRange::at(offset_from(base, rest), TextSize::of(rest)),
+                })?;
+
+                let (value, rest) = rest.split_at(paren);
+                let value = value.trim();
+
+                categories.push((category, Some(value)));
+
+                line = rest.strip_prefix(')').unwrap().trim_start();
+            }
+            // Whitespace: push a category without value
+            _ => {
+                if let Some(category) = category {
+                    categories.push((category, None));
+                }
+
+                line = rest.trim_start();
+            }
+        }
+    }
+
+    let reason = line.trim_end();
+    Ok(Suppression { categories, reason })
+}
+
+/// Returns the byte offset of `substr` within `base`
+///
+/// # Safety
+///
+/// `substr` must be a substring of `base`, or calling this method will result
+/// in undefined behavior.
+fn offset_from(base: &str, substr: &str) -> TextSize {
+    let base_len = base.len();
+    assert!(substr.len() <= base_len);
+
+    let base = base.as_ptr();
+    let substr = substr.as_ptr();
+    let offset = unsafe { substr.offset_from(base) };
+
+    // SAFETY: converting from `isize` to `usize` can only fail if `offset` is
+    // negative, meaning `base` is either a substring of `substr` or the two
+    // string slices are unrelated
+    let offset = usize::try_from(offset).expect("usize underflow");
+    assert!(offset <= base_len);
+
+    // SAFETY: the conversion from `usize` to `TextSize` can fail if `offset`
+    // is larger than 2^32
+    TextSize::try_from(offset).expect("TextSize overflow")
+}
+
+#[cfg(test)]
+mod tests {
+    use rome_diagnostics::category;
+    use rome_rowan::{TextRange, TextSize};
+
+    use crate::{offset_from, SuppressionDiagnostic, SuppressionDiagnosticKind};
+
+    use super::{parse_suppression_comment, Suppression};
+
+    #[test]
+    fn parse_simple_suppression() {
+        assert_eq!(
+            parse_suppression_comment("// rome-ignore parse: explanation1").collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![(category!("parse"), None)],
+                reason: "explanation1"
+            })],
+        );
+
+        assert_eq!(
+            parse_suppression_comment("/** rome-ignore parse: explanation2 */").collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![(category!("parse"), None)],
+                reason: "explanation2"
+            })],
+        );
+
+        assert_eq!(
+            parse_suppression_comment(
+                "/**
+                  * rome-ignore parse: explanation3
+                  */"
+            )
+            .collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![(category!("parse"), None)],
+                reason: "explanation3"
+            })],
+        );
+
+        assert_eq!(
+            parse_suppression_comment(
+                "/**
+                  * hello
+                  * rome-ignore parse: explanation4
+                  */"
+            )
+            .collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![(category!("parse"), None)],
+                reason: "explanation4"
+            })],
+        );
+    }
+    #[test]
+    fn parse_unclosed_block_comment_suppressions() {
+        assert_eq!(
+            parse_suppression_comment("/* rome-ignore format: explanation").collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![(category!("format"), None)],
+                reason: "explanation"
+            })],
+        );
+
+        assert_eq!(
+            parse_suppression_comment("/* rome-ignore format: explanation *").collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![(category!("format"), None)],
+                reason: "explanation"
+            })],
+        );
+
+        assert_eq!(
+            parse_suppression_comment("/* rome-ignore format: explanation /").collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![(category!("format"), None)],
+                reason: "explanation"
+            })],
+        );
+    }
+
+    #[test]
+    fn parse_multiple_suppression() {
+        assert_eq!(
+            parse_suppression_comment("// rome-ignore parse(foo) parse(dog): explanation")
+                .collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![
+                    (category!("parse"), Some("foo")),
+                    (category!("parse"), Some("dog"))
+                ],
+                reason: "explanation"
+            })],
+        );
+
+        assert_eq!(
+            parse_suppression_comment("/** rome-ignore parse(bar) parse(cat): explanation */")
+                .collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![
+                    (category!("parse"), Some("bar")),
+                    (category!("parse"), Some("cat"))
+                ],
+                reason: "explanation"
+            })],
+        );
+
+        assert_eq!(
+            parse_suppression_comment(
+                "/**
+                  * rome-ignore parse(yes) parse(frog): explanation
+                  */"
+            )
+            .collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![
+                    (category!("parse"), Some("yes")),
+                    (category!("parse"), Some("frog"))
+                ],
+                reason: "explanation"
+            })],
+        );
+
+        assert_eq!(
+            parse_suppression_comment(
+                "/**
+                  * hello
+                  * rome-ignore parse(wow) parse(fish): explanation
+                  */"
+            )
+            .collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![
+                    (category!("parse"), Some("wow")),
+                    (category!("parse"), Some("fish"))
+                ],
+                reason: "explanation"
+            })],
+        );
+    }
+
+    #[test]
+    fn parse_multiple_suppression_categories() {
+        assert_eq!(
+            parse_suppression_comment("// rome-ignore format lint: explanation")
+                .collect::<Vec<_>>(),
+            vec![Ok(Suppression {
+                categories: vec![(category!("format"), None), (category!("lint"), None)],
+                reason: "explanation"
+            })],
+        );
+    }
+
+    #[test]
+    fn check_offset_from() {
+        const BASE: &str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua";
+
+        assert_eq!(offset_from(BASE, BASE), TextSize::from(0));
+
+        let (_, substr) = BASE.split_at(55);
+        assert_eq!(offset_from(BASE, substr), TextSize::from(55));
+
+        let (_, substr) = BASE.split_at(BASE.len());
+        assert_eq!(offset_from(BASE, substr), TextSize::of(BASE));
+    }
+
+    #[test]
+    fn diagnostic_missing_colon() {
+        assert_eq!(
+            parse_suppression_comment("// rome-ignore format explanation").collect::<Vec<_>>(),
+            vec![Err(SuppressionDiagnostic {
+                message: SuppressionDiagnosticKind::MissingColon,
+                span: TextRange::new(TextSize::from(22), TextSize::from(33))
+            })],
+        );
+    }
+
+    #[test]
+    fn diagnostic_missing_paren() {
+        assert_eq!(
+            parse_suppression_comment("// rome-ignore format(:").collect::<Vec<_>>(),
+            vec![Err(SuppressionDiagnostic {
+                message: SuppressionDiagnosticKind::MissingParen,
+                span: TextRange::new(TextSize::from(22), TextSize::from(23))
+            })],
+        );
+    }
+
+    #[test]
+    fn diagnostic_missing_category() {
+        assert_eq!(
+            parse_suppression_comment("// rome-ignore (value): explanation").collect::<Vec<_>>(),
+            vec![Err(SuppressionDiagnostic {
+                message: SuppressionDiagnosticKind::MissingCategory,
+                span: TextRange::new(TextSize::from(15), TextSize::from(16))
+            })],
+        );
+    }
+
+    #[test]
+    fn diagnostic_unknown_category() {
+        assert_eq!(
+            parse_suppression_comment("// rome-ignore unknown: explanation").collect::<Vec<_>>(),
+            vec![Err(SuppressionDiagnostic {
+                message: SuppressionDiagnosticKind::ParseCategory(String::from("unknown")),
+                span: TextRange::new(TextSize::from(15), TextSize::from(22))
+            })],
+        );
+    }
+}
diff --git a/justfile b/justfile
index 97a31976bfc..d3ddd54e3a3 100644
--- a/justfile
+++ b/justfile
@@ -10,12 +10,12 @@ alias l := lint
 # Installs the tools needed to develop with Rome
 install-tools:
 	cargo install cargo-binstall
-	cargo binstall cargo-insta cargo-nextest taplo-cli wasm-pack
+	cargo binstall cargo-insta cargo-nextest taplo-cli wasm-pack wasm-tools
 
 # Upgrades the tools needed to develop with Rome
 upgrade-tools:
 	cargo install cargo-binstall --force
-	cargo binstall cargo-insta cargo-nextest taplo-cli wasm-pack --force
+	cargo binstall cargo-insta cargo-nextest taplo-cli wasm-pack wasm-tools --force
 
 # Generate all files across crates and tools. You rarely want to use it locally.
 codegen:
diff --git a/website/package.json b/website/package.json
index 7585ffb5ce1..ce5e2084071 100644
--- a/website/package.json
+++ b/website/package.json
@@ -11,7 +11,7 @@
 				"build": "pnpm build:wasm && pnpm build:js",
 				"build:js": "astro build",
 				"build:wasm": "wasm-pack build --out-dir ../../npm/wasm-web --target web --release --scope rometools ../crates/rome_wasm",
-				"build:wasm-dev": "wasm-pack build --out-dir ../../npm/wasm-web --target web --dev --scope rometools ../crates/rome_wasm",
+				"build:wasm-dev": "wasm-pack build --out-dir ../../npm/wasm-web --target web --scope rometools ../crates/rome_wasm",
 				"preview": "astro preview"
 		},
 		"devDependencies": {
diff --git a/website/src/playground/PlaygroundLoader.tsx b/website/src/playground/PlaygroundLoader.tsx
index c5cb04d9141..a1c5bba0ea9 100644
--- a/website/src/playground/PlaygroundLoader.tsx
+++ b/website/src/playground/PlaygroundLoader.tsx
@@ -341,6 +341,9 @@ function initState(
 			unsafeParameterDecoratorsEnabled:
 				searchParams.get("unsafeParameterDecoratorsEnabled") === "true" ||
 				defaultPlaygroundState.settings.unsafeParameterDecoratorsEnabled,
+			allowComments:
+				searchParams.get("allowComments") === "true" ||
+				defaultPlaygroundState.settings.allowComments,
 		},
 	};
 }
diff --git a/website/src/playground/tabs/SettingsTab.tsx b/website/src/playground/tabs/SettingsTab.tsx
index 79f7c49afd5..1e1c023b133 100644
--- a/website/src/playground/tabs/SettingsTab.tsx
+++ b/website/src/playground/tabs/SettingsTab.tsx
@@ -49,6 +49,7 @@ export default function SettingsTab({
 			enabledLinting,
 			importSortingEnabled,
 			unsafeParameterDecoratorsEnabled,
+			allowComments,
 		},
 	},
 }: SettingsTabProps) {
@@ -106,6 +107,10 @@ export default function SettingsTab({
 		setPlaygroundState,
 		"unsafeParameterDecoratorsEnabled",
 	);
+	const setAllowComments = createPlaygroundSettingsSetter(
+		setPlaygroundState,
+		"allowComments",
+	);
 
 	function setCurrentFilename(newFilename: string) {
 		setPlaygroundState((state) => {
@@ -262,9 +267,11 @@ export default function SettingsTab({
 				filename={currentFile}
 				setFilename={setCurrentFilename}
 				unsafeParameterDecoratorsEnabled={unsafeParameterDecoratorsEnabled}
+				allowComments={allowComments}
 				setUnsafeParameterDecoratorsEnabled={
 					setUnsafeParameterDecoratorsEnabled
 				}
+				setAllowComments={setAllowComments}
 			/>
 		</div>
 	);
@@ -449,11 +456,15 @@ function SyntaxSettings({
 	setFilename,
 	unsafeParameterDecoratorsEnabled,
 	setUnsafeParameterDecoratorsEnabled,
+	setAllowComments,
+	allowComments,
 }: {
 	filename: string;
 	setFilename: (filename: string) => void;
 	unsafeParameterDecoratorsEnabled: boolean;
+	allowComments: boolean;
 	setUnsafeParameterDecoratorsEnabled: (value: boolean) => void;
+	setAllowComments: (value: boolean) => void;
 }) {
 	const isScript = isScriptFilename(filename);
 
@@ -536,6 +547,16 @@ function SyntaxSettings({
 						Parameter decorators enabled
 					</label>
 				</div>
+				<div className="field-row">
+					<input
+						id="allow-comments"
+						name="allow-comments"
+						type="checkbox"
+						checked={allowComments}
+						onChange={(e) => setAllowComments(e.target.checked)}
+					/>
+					<label htmlFor="allow-comments">Allow comments in JSON files</label>
+				</div>
 			</section>
 		</>
 	);
diff --git a/website/src/playground/types.ts b/website/src/playground/types.ts
index 950322262e6..ba7feabfc20 100644
--- a/website/src/playground/types.ts
+++ b/website/src/playground/types.ts
@@ -115,6 +115,7 @@ export interface PlaygroundSettings {
 	enabledLinting: boolean;
 	importSortingEnabled: boolean;
 	unsafeParameterDecoratorsEnabled: boolean;
+	allowComments: boolean;
 }
 
 export interface PlaygroundFileState {
@@ -158,6 +159,7 @@ export const defaultPlaygroundState: PlaygroundState = {
 		enabledLinting: true,
 		importSortingEnabled: true,
 		unsafeParameterDecoratorsEnabled: true,
+		allowComments: true,
 	},
 };
 
diff --git a/website/src/playground/workers/romeWorker.ts b/website/src/playground/workers/romeWorker.ts
index f083f296520..44aa1917c89 100644
--- a/website/src/playground/workers/romeWorker.ts
+++ b/website/src/playground/workers/romeWorker.ts
@@ -75,6 +75,7 @@ self.addEventListener("message", async (e) => {
 				arrowParentheses,
 				importSortingEnabled,
 				unsafeParameterDecoratorsEnabled,
+				allowComments,
 			} = e.data.settings as PlaygroundSettings;
 
 			configuration = {
@@ -115,6 +116,11 @@ self.addEventListener("message", async (e) => {
 						unsafeParameterDecoratorsEnabled,
 					},
 				},
+				json: {
+					parser: {
+						allowComments,
+					},
+				},
 			};
 
 			switch (lintRules) {