diff --git a/.github/workflows/linting.yml b/.github/workflows/linting.yml
new file mode 100644
index 0000000..e7723a0
--- /dev/null
+++ b/.github/workflows/linting.yml
@@ -0,0 +1,42 @@
+name: Linting
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - main
+
+concurrency:
+  group: ${{github.workflow}}-${{github.ref}}
+  cancel-in-progress: true
+
+jobs:
+  js:
+    name: "JavaScript"
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
+    - run: npm install
+    - run: npm exec prettier --check .
+
+  format-queries:
+    name: Queries
+    runs-on: ubuntu-latest
+    env:
+      NVIM_TAG: nightly
+      # NVIM_TAG: stable
+    steps:
+      - uses: actions/checkout@v4
+      - name: Prepare
+        run: |
+          bash ./scripts/ci-install.sh
+
+      - name: Lint
+        run: |
+          nvim --version
+          nvim --headless -c "TSInstallSync query" -c "q"
+          nvim -l scripts/format-queries.lua
+          git diff --exit-code
diff --git a/queries/glimmer/folds.scm b/queries/glimmer/folds.scm
index cfe9d35..6502455 100644
--- a/queries/glimmer/folds.scm
+++ b/queries/glimmer/folds.scm
@@ -1,4 +1,5 @@
 [
- (element_node (element_node_start))
- (block_statement)
+  (element_node
+    (element_node_start))
+  (block_statement)
 ] @fold
diff --git a/queries/glimmer/highlights.scm b/queries/glimmer/highlights.scm
index e817620..9f11468 100644
--- a/queries/glimmer/highlights.scm
+++ b/queries/glimmer/highlights.scm
@@ -1,84 +1,113 @@
 ; === Tag Names ===
-
 ; Tags that start with a lower case letter are HTML tags
 ; We'll also use this highlighting for named blocks (which start with `:`)
 ((tag_name) @tag
-  (#match? @tag "^(:)?[a-z]"))
+  (#lua-match? @tag "^:?[%l]"))
+
 ; Tags that start with a capital letter are Glimmer components
 ((tag_name) @constructor
-  (#match? @constructor "^[A-Z]"))
+  (#lua-match? @constructor "^%u"))
 
-(attribute_name) @property
+(attribute_name) @attribute
 
 (string_literal) @string
+
 (number_literal) @number
+
 (boolean_literal) @boolean
 
 (concat_statement) @string
 
 ; === Block Statements ===
-
 ; Highlight the brackets
 (block_statement_start) @tag.delimiter
+
 (block_statement_end) @tag.delimiter
 
 ; Highlight `if`/`each`/`let`
-(block_statement_start path: (identifier) @conditional)
-(block_statement_end path: (identifier) @conditional)
-((mustache_statement (identifier) @conditional)
- (#match? @conditional "else"))
+(block_statement_start
+  path: (identifier) @keyword.conditional)
 
-; == Mustache Statements ===
+(block_statement_end
+  path: (identifier) @keyword.conditional)
+
+((mustache_statement
+  (identifier) @keyword.conditional)
+  (#lua-match? @keyword.conditional "else"))
 
-; Hightlight the whole statement, to color brackets and separators
+; == Mustache Statements ===
+; Highlight the whole statement, to color brackets and separators
 (mustache_statement) @tag.delimiter
 
 ; An identifier in a mustache expression is a variable
-((mustache_statement [
-  (path_expression (identifier) @variable)
-  (identifier) @variable
+((mustache_statement
+  [
+    (path_expression
+      (identifier) @variable)
+    (identifier) @variable
   ])
-  (#not-match? @variable "yield|outlet|this|else"))
+  (#not-any-of? @variable "yield" "outlet" "this" "else"))
+
 ; As are arguments in a block statement
-(block_statement_start argument: [
-  (path_expression (identifier) @variable)
-  (identifier) @variable
+(block_statement_start
+  argument: [
+    (path_expression
+      (identifier) @variable)
+    (identifier) @variable
   ])
+
 ; As is an identifier in a block param
-(block_params (identifier) @variable)
+(block_params
+  (identifier) @variable)
+
 ; As are helper arguments
-((helper_invocation argument: [
-  (path_expression (identifier) @variable)
-  (identifier) @variable
+((helper_invocation
+  argument: [
+    (path_expression
+      (identifier) @variable)
+    (identifier) @variable
   ])
-  (#not-match? @variable "this"))
+  (#not-eq? @variable "this"))
+
 ; `this` should be highlighted as a built-in variable
 ((identifier) @variable.builtin
-  (#match? @variable.builtin "this"))
+  (#eq? @variable.builtin "this"))
 
 ; If the identifier is just "yield" or "outlet", it's a keyword
-((mustache_statement (identifier) @keyword)
-  (#match? @keyword "yield|outlet"))
+((mustache_statement
+  (identifier) @keyword)
+  (#any-of? @keyword "yield" "outlet"))
 
 ; Helpers are functions
-((helper_invocation helper: [
-  (path_expression (identifier) @function)
-  (identifier) @function
+((helper_invocation
+  helper: [
+    (path_expression
+      (identifier) @function)
+    (identifier) @function
   ])
-  (#not-match? @function "if|yield"))
-((helper_invocation helper: (identifier) @conditional)
-  (#match? @conditional "if"))
-((helper_invocation helper: (identifier) @keyword)
-  (#match? @keyword "yield"))
+  (#not-any-of? @function "if" "yield"))
+
+((helper_invocation
+  helper: (identifier) @keyword.conditional)
+  (#eq? @keyword.conditional "if"))
+
+((helper_invocation
+  helper: (identifier) @keyword)
+  (#eq? @keyword "yield"))
+
+(hash_pair
+  key: (identifier) @property)
 
-(hash_pair key: (identifier) @property)
+(comment_statement) @comment @spell
 
-(comment_statement) @comment
+(attribute_node
+  "=" @operator)
 
-(attribute_node "=" @operator)
+(block_params
+  "as" @keyword)
 
-(block_params "as" @keyword)
-(block_params "|" @operator)
+(block_params
+  "|" @operator)
 
 [
   "<"
diff --git a/queries/glimmer/indents.scm b/queries/glimmer/indents.scm
index 597a0fa..c1ef130 100644
--- a/queries/glimmer/indents.scm
+++ b/queries/glimmer/indents.scm
@@ -1,22 +1,34 @@
 [
-  (element_node (element_node_start))
+  (element_node
+    (element_node_start))
   (element_node_void)
-  (block_statement (block_statement_start))
+  (block_statement
+    (block_statement_start))
   (mustache_statement)
 ] @indent.begin
 
-(element_node (element_node_end  [">"] @indent.end))
-(element_node_void "/>" @indent.end)
+(element_node
+  (element_node_end
+    ">" @indent.end))
+
+(element_node_void
+  "/>" @indent.end)
+
 [
- ">"
- "/>"
- "</"
+  ">"
+  "/>"
+  "</"
   "{{/"
   "}}"
- ] @indent.branch
+] @indent.branch
 
 (mustache_statement
-  (helper_invocation helper: (identifier) @_identifier (#lua-match? @_identifier "else"))
-  ) @indent.branch
-(mustache_statement ((identifier) @_identifier (#lua-match? @_identifier "else"))) @indent.branch
+  (helper_invocation
+    helper: (identifier) @_identifier
+    (#eq? @_identifier "else"))) @indent.branch
+
+(mustache_statement
+  ((identifier) @_identifier
+    (#eq? @_identifier "else"))) @indent.branch
+
 (comment_statement) @indent.ignore
diff --git a/queries/glimmer/injections.scm b/queries/glimmer/injections.scm
index a9924f8..30b4386 100644
--- a/queries/glimmer/injections.scm
+++ b/queries/glimmer/injections.scm
@@ -1,29 +1,21 @@
 ; comments
 ((comment_statement) @injection.content
- (#set! injection.language "comment"))
+  (#set! injection.language "comment"))
 
 ; <style> tags
 ((element_node
   (element_node_start
     (tag_name) @_tag_name
-    (#eq? @_tag_name "style")
-  )
-  )
-  @injection.content
+    (#eq? @_tag_name "style"))) @injection.content
   (#offset! @injection.content 0 7 0 -8)
   (#set! injection.language "css")
-  (#set! injection.include-children)
-)
+  (#set! injection.include-children))
 
 ; <script> tags
 ((element_node
   (element_node_start
     (tag_name) @_tag_name
-    (#eq? @_tag_name "script")
-  )
-  )
-  @injection.content
+    (#eq? @_tag_name "script"))) @injection.content
   (#offset! @injection.content 0 8 0 -9)
   (#set! injection.language "glimmer_javascript")
-  (#set! injection.include-children)
-)
+  (#set! injection.include-children))
diff --git a/scripts/ci-install.sh b/scripts/ci-install.sh
new file mode 100755
index 0000000..4c4b5c1
--- /dev/null
+++ b/scripts/ci-install.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+set -e
+
+mkdir -p /tmp/ci-linting/
+cd /tmp/ci-linting/
+git clone https://github.com/nvim-treesitter/nvim-treesitter.git
+cd nvim-treesitter
+
+os=$(uname -s)
+if [[ $os == Linux ]]; then
+  wget https://github.com/neovim/neovim/releases/download/${NVIM_TAG}/nvim-linux64.tar.gz
+  tar -zxf nvim-linux64.tar.gz
+  sudo ln -s "$PWD"/nvim-linux64/bin/nvim /usr/local/bin
+  rm -rf "$PWD"/nvim-linux64/lib/nvim/parser
+  mkdir -p ~/.local/share/nvim/site/pack/nvim-treesitter/start
+  ln -s "$PWD" ~/.local/share/nvim/site/pack/nvim-treesitter/start
+elif [[ $os == Darwin ]]; then
+  RELEASE_NAME="nvim-macos-$(uname -m)"
+  curl -L "https://github.com/neovim/neovim/releases/download/${NVIM_TAG}/$RELEASE_NAME.tar.gz" | tar -xz
+  sudo ln -s "$PWD/$RELEASE_NAME/bin/nvim" /usr/local/bin
+  rm -rf "$PWD/$RELEASE_NAME/lib/nvim/parser"
+  mkdir -p ~/.local/share/nvim/site/pack/nvim-treesitter/start
+  ln -s "$PWD" ~/.local/share/nvim/site/pack/nvim-treesitter/start
+else
+  curl -L https://github.com/neovim/neovim/releases/download/${NVIM_TAG}/nvim-win64.zip -o nvim-win64.zip
+  unzip nvim-win64
+  mkdir -p ~/AppData/Local/nvim/pack/nvim-treesitter/start
+  mkdir -p ~/AppData/Local/nvim-data
+  cp -r "$PWD" ~/AppData/Local/nvim/pack/nvim-treesitter/start
+fi
diff --git a/scripts/format-queries.lua b/scripts/format-queries.lua
new file mode 100755
index 0000000..0f6b77f
--- /dev/null
+++ b/scripts/format-queries.lua
@@ -0,0 +1,451 @@
+#!/usr/bin/env -S nvim -l
+
+local ts = vim.treesitter
+local get_node_text = ts.get_node_text
+
+---@type string[]
+local files
+
+local arg = _G.arg[1] or "."
+if arg:match ".*%.scm$" then
+  files = { arg }
+else
+  files = vim.fn.split(vim.fn.glob(arg .. "/**/*.scm"))
+end
+
+ts.query.add_predicate("kind-eq?", function(match, _, _, pred)
+  local node = match[pred[2]]
+  if not node then
+    return true
+  end
+
+  local types = { unpack(pred, 3) }
+  return vim.tbl_contains(types, node:type())
+end, true)
+
+ts.query.add_predicate("is-start-of-line?", function(match, _, _, pred)
+  local node = match[pred[2]]
+  if not node then
+    return true
+  end
+  local start_row, start_col = node:start()
+  return vim.fn.indent(start_row + 1) == start_col
+end)
+
+--- Control the indent here. Change to \t if uses tab instead
+local indent_str = "  "
+local textwidth = 100
+
+-- Query to control the formatter
+local format_queries = [[
+;;query
+;; Ignore next node with `; format-ignore`
+(
+  (comment) @_pattern
+  .
+  (_) @format.ignore
+  (#lua-match? @_pattern "^;+%s*format%-ignore"))
+
+;; {{{
+;; Add newlines to top level nodes
+;; {{{
+;; Preserve inline comments
+(program
+  . (_)
+  (comment) @format.prepend-newline
+  (#is-start-of-line? @format.prepend-newline))
+(program
+  . (_)
+  (comment) @_comment
+  .
+  (comment) @format.prepend-newline
+  (#not-is-start-of-line? @_comment)
+  (#is-start-of-line? @format.prepend-newline))
+; Extra newline for modelines
+(program
+  (comment) @_modeline
+  .
+  (_) @format.prepend-newline
+  (#is-start-of-line? @_modeline)
+  (#contains? @_modeline "^;+%s*inherits:"))
+(program
+  (comment) @_modeline
+  .
+  (_) @format.prepend-newline
+  (#is-start-of-line? @_modeline)
+  (#contains? @_modeline "^;+%s*extends%s*$"))
+;; }}}
+;; Making sure all top-level patterns are separated
+(program
+  (_) @format.append-newline)
+(program
+  (_) @format.cancel-append .)
+(program
+  . (_)
+  [
+    (list)
+    (grouping)
+    (named_node)
+    (anonymous_node)
+    (field_definition)
+  ] @format.prepend-newline)
+
+(program
+  (comment) @_comment
+  .
+  [
+    (list)
+    (grouping)
+    (named_node)
+    (anonymous_node)
+    (field_definition)
+    (comment)
+  ] @format.cancel-prepend
+  (#is-start-of-line? @_comment)
+  (#not-lua-match? @_comment "^;+%s*inherits:")
+  (#not-lua-match? @_comment "^;+%s*extends%s*$"))
+;; }}}
+
+;; delims
+[
+  ":"
+  "."
+] @format.append-space
+(
+  "." @format.prepend-space @format.cancel-append
+  .
+  ")")
+
+;; List handler
+;; Only starts indent if 2 or more elements
+(list
+  "[" @format.indent.begin
+  "]" @format.indent.dedent)
+;; Otherwise, remove brackets
+(list
+  "[" @format.remove @format.cancel-append
+  .
+  (_) @format.cancel-append
+  .
+  "]" @format.remove)
+;; [ ... ] @capture1 @capture2
+;; Append newlines for nodes inside the list
+(list
+  (_) @format.append-newline
+  (#not-kind-eq? @format.append-newline "capture" "quantifier"))
+
+;; (_), "_" and _ handler
+;; Start indents if it's one of these patterns
+(named_node
+  [
+    "_"
+    name: (identifier)
+  ] @format.indent.begin
+  .
+  [
+    (list)              ; (foo [...])
+    (grouping)          ; (foo ((foo)))
+    (negated_field)     ; (foo !field)
+    (field_definition)  ; (foo field: (...))
+    (named_node)        ; (foo (bar))
+    (predicate)         ; (named_node (#set!))
+    (anonymous_node)
+    "."
+  ])
+;; Honoring comment's position within a node
+(named_node
+  [
+    "_"
+    name: (identifier)
+  ] @format.indent.begin
+  .
+  (comment) @_comment
+  (#is-start-of-line? @_comment))
+(named_node
+  [
+    "_"
+    name: (identifier)
+  ] @format.indent.begin @format.cancel-append
+  .
+  "."? @format.prepend-newline
+  .
+  (comment) @format.prepend-space
+  (#not-is-start-of-line? @format.prepend-space))
+
+;; Add newlines for other nodes, in case the top node is indented
+(named_node
+  [
+    (list)
+    (grouping)
+    (negated_field)
+    (field_definition)
+    (named_node)
+    (predicate)
+    (anonymous_node)
+    "."
+  ] @format.append-newline)
+
+;; Collapse closing parentheses
+(named_node
+  [
+    "_"
+    name: (identifier)
+    (_)
+  ] @format.cancel-append
+  .
+  ")"
+  (#not-kind-eq? @format.cancel-append "comment"))
+
+;; All captures should be separated with a space
+(capture) @format.prepend-space
+
+;; Workaround to just use the string's content
+(anonymous_node (string) @format.keep)
+
+; ( (_) ) handler
+(grouping
+  "("
+  .
+  [
+    (named_node)                  ; ((foo))
+    (list)                        ; ([foo] (...))
+    (anonymous_node)              ; ("foo")
+    (grouping . (_))
+  ] @format.indent.begin
+  .
+  (_))
+(grouping
+  "("
+  .
+  (grouping) @format.indent.begin
+  (predicate))
+(grouping
+  "("
+  [
+    (anonymous_node)
+    (named_node)
+    (list)
+    (predicate)
+    (grouping . (_))
+    (field_definition)
+    "."
+  ] @format.append-newline
+  (_) .)
+;; Collapsing closing parens
+(grouping
+  (_) @format.cancel-append . ")"
+  (#not-kind-eq? @format.cancel-append "comment"))
+(grouping
+  (capture) @format.prepend-space)
+;; Remove unnecessary parens
+(grouping
+  "(" @format.remove
+  .
+  (_)
+  .
+  ")" @format.remove .)
+(grouping
+  "(" @format.remove
+  .
+  [
+    (anonymous_node
+      name: (string) .)
+    (named_node
+      [
+        "_"
+        name: (identifier)
+      ] .)
+  ]
+  .
+  ")" @format.remove
+  .
+  (capture))
+
+; Separate this query to avoid capture duplication
+(predicate
+  "(" @format.indent.begin @format.cancel-append)
+(predicate
+  (parameters
+    (comment) @format.prepend-newline
+    .
+    (_) @format.cancel-prepend)
+  (#is-start-of-line? @format.prepend-newline))
+(predicate
+  (parameters
+    (_) @format.prepend-space)
+  (#set! conditional-newline))
+(predicate
+  (parameters
+    .
+    (capture)
+    . (_) @format.prepend-space)
+  (#set! lookahead-newline)
+  (#set! conditional-newline))
+;; Workaround to keep the string's content
+(string) @format.keep
+
+;; Comment related handlers
+(comment) @format.append-newline
+;; comment styling. Feel free to change in the future
+((comment) @format.replace
+  (#gsub! @format.replace "^;+(%s*.-)%s*$" ";%1"))
+;; Preserve end of line comments
+(
+  [
+    "."
+    ":"
+    (list)
+    (grouping)
+    (named_node)
+    (anonymous_node)
+    (negated_field)
+  ] @format.cancel-append
+  .
+  (quantifier)?
+  .
+  "."? @format.prepend-newline ; Make sure anchor are not eol but start of newline
+  .
+  (comment) @format.prepend-space
+  (#not-is-start-of-line? @format.prepend-space))
+]]
+
+---@param lines string[]
+---@param lines_to_append string[]
+local function append_lines(lines, lines_to_append)
+  for i = 1, #lines_to_append, 1 do
+    lines[#lines] = lines[#lines] .. lines_to_append[i]
+    if i ~= #lines_to_append then
+      lines[#lines + 1] = ""
+    end
+  end
+end
+
+---@param bufnr integer
+---@param node TSNode
+---@param lines string[]
+---@param q table<string, TSMetadata>
+---@param level integer
+local function iter(bufnr, node, lines, q, level)
+  --- Sometimes 2 queries apply append twice. This is to prevent the case from happening
+  local apply_newline = false
+  for child, _ in node:iter_children() do
+    local id = child:id()
+    repeat
+      if apply_newline then
+        apply_newline = false
+        lines[#lines + 1] = string.rep(indent_str, level)
+      end
+      if q["format.ignore"][id] then
+        local text = vim.split(get_node_text(child, bufnr):gsub("\r\n?", "\n"), "\n", { trimempty = true })
+        append_lines(lines, text)
+        break
+      elseif q["format.remove"][id] then
+        break
+      end
+      if not q["format.cancel-prepend"][id] then
+        if q["format.prepend-newline"][id] then
+          lines[#lines + 1] = string.rep(indent_str, level)
+        elseif q["format.prepend-space"][id] then
+          if not q["format.prepend-space"][id]["conditional-newline"] then
+            lines[#lines] = lines[#lines] .. " "
+          elseif child:byte_length() + 1 + #lines[#lines] > textwidth then
+            lines[#lines + 1] = string.rep(indent_str, level)
+          else
+            -- Do a rough guess of the actual byte length. If it's larger than `columns` then add a newline first
+            -- column - byte_end + byte_start
+            local _, _, byte_start = child:start()
+            local _, _, byte_end = node:end_()
+            if
+              q["format.prepend-space"][id]["lookahead-newline"]
+              and textwidth - (byte_end - byte_start) - #lines[#lines] < 0
+            then
+              lines[#lines + 1] = string.rep(indent_str, level)
+            else
+              lines[#lines] = lines[#lines] .. " "
+            end
+          end
+        end
+      end
+      if q["format.replace"][id] then
+        append_lines(lines, vim.split(q["format.replace"][id].text, "\n", { trimempty = true }))
+      elseif child:named_child_count() == 0 or q["format.keep"][id] then
+        append_lines(
+          lines,
+          vim.split(string.gsub(get_node_text(child, bufnr), "\r\n?", "\n"), "\n+", { trimempty = true })
+        )
+      else
+        iter(bufnr, child, lines, q, level)
+      end
+      if q["format.indent.begin"][id] then
+        level = level + 1
+        apply_newline = true
+        break
+      end
+      if q["format.indent.dedent"][id] then
+        if string.match(lines[#lines], "^%s*" .. get_node_text(child, bufnr)) then
+          lines[#lines] = string.sub(lines[#lines], 1 + #string.rep(indent_str, 1))
+        end
+      end
+      if q["format.indent.end"][id] then
+        level = math.max(level - 1, 0)
+        if string.match(lines[#lines], "^%s*" .. get_node_text(child, bufnr)) then
+          lines[#lines] = string.sub(lines[#lines], 1 + #string.rep(indent_str, 1))
+        end
+        break
+      end
+    until true
+    repeat
+      if q["format.cancel-append"][id] then
+        apply_newline = false
+      end
+      if not q["format.cancel-append"][id] then
+        if q["format.append-newline"][id] then
+          apply_newline = true
+        elseif q["format.append-space"][id] then
+          lines[#lines] = lines[#lines] .. " "
+        end
+      end
+    until true
+  end
+end
+
+---@param bufnr integer
+---@param queries string
+local function format(bufnr, queries)
+  local lines = { "" }
+  -- stylua: ignore
+  local map = {
+    ['format.ignore'] = {},           -- Ignore the node and its children
+    ['format.indent.begin'] = {},     -- +1 shiftwidth for all nodes after this
+    ['format.indent.end'] = {},       -- -1 shiftwidth for all nodes after this
+    ['format.indent.dedent'] = {},    -- -1 shiftwidth for this line only
+    ['format.prepend-space'] = {},    -- Prepend a space before inserting the node
+    ['format.prepend-newline'] = {},  -- Prepend a \n before inserting the node
+    ['format.append-space'] = {},     -- Append a space after inserting the node
+    ['format.append-newline'] = {},   -- Append a newline after inserting the node
+    ['format.cancel-append'] = {},    -- Cancel any `@format.append-*` applied to the node
+    ['format.cancel-prepend'] = {},   -- Cancel any `@format.prepend-*` applied to the node
+    ['format.keep'] = {},             -- String content is not exposed as a syntax node. This is a workaround for it
+    ['format.replace'] = {},          -- Dedicated capture used to store results of `(#gsub!)`
+    ['format.remove'] = {},           -- Do not add the syntax node to the result, i.e. brackets [], parens ()
+  }
+  local root = ts.get_parser(bufnr, "query"):parse(true)[1]:root()
+  local query = ts.query.parse("query", queries)
+  for id, node, metadata in query:iter_captures(root, bufnr) do
+    if query.captures[id]:sub(1, 1) ~= "_" then
+      map[query.captures[id]][node:id()] = metadata and (metadata[id] and metadata[id] or metadata) or {}
+    end
+  end
+
+  iter(bufnr, root, lines, map, 0)
+  vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
+end
+
+for _, file in ipairs(files) do
+  local buf = vim.fn.bufadd(file)
+  vim.fn.bufload(file)
+  vim.api.nvim_set_current_buf(buf)
+  format(buf, format_queries)
+end
+
+vim.cmd "silent wa!"