diff --git a/lib/ex_doc.ex b/lib/ex_doc.ex
index c108c3560..6951660ed 100644
--- a/lib/ex_doc.ex
+++ b/lib/ex_doc.ex
@@ -35,11 +35,16 @@ defmodule ExDoc do
   end
 
   defp find_formatter(name) do
-    [ExDoc.Formatter, String.upcase(name)]
+    [ExDoc.Formatter, format_module_name(name)]
     |> Module.concat()
     |> check_formatter_module(name)
   end
 
+  defp format_module_name("html"), do: "HTML"
+  defp format_module_name("epub"), do: "EPUB"
+  defp format_module_name("markdown"), do: "Markdown"
+  defp format_module_name(name), do: String.upcase(name)
+
   defp check_formatter_module(modname, argname) do
     if Code.ensure_loaded?(modname) do
       modname
diff --git a/lib/ex_doc/doc_ast.ex b/lib/ex_doc/doc_ast.ex
index ed84cfd2c..2d9d9976f 100644
--- a/lib/ex_doc/doc_ast.ex
+++ b/lib/ex_doc/doc_ast.ex
@@ -65,6 +65,67 @@ defmodule ExDoc.DocAST do
     Enum.map(attrs, fn {key, val} -> " #{key}=\"#{ExDoc.Utils.h(val)}\"" end)
   end
 
+  @doc """
+  Transform AST into markdown string.
+  """
+  def to_markdown(ast)
+
+  def to_markdown(binary) when is_binary(binary) do
+    ExDoc.Utils.h(binary)
+  end
+
+  def to_markdown(list) when is_list(list) do
+    Enum.map_join(list, "", &to_markdown/1)
+  end
+
+  def to_markdown({:comment, _attrs, inner, _meta}) do
+    "<!--#{inner}-->"
+  end
+
+  def to_markdown({:code, attrs, inner, _meta}) do
+    lang = attrs[:class] || ""
+
+    """
+    ```#{lang}
+    #{inner}
+    ```
+    """
+  end
+
+  def to_markdown({:a, attrs, inner, _meta}) do
+    "[#{to_markdown(inner)}](#{attrs[:href]})"
+  end
+
+  def to_markdown({:hr, _attrs, _inner, _meta}) do
+    "\n\n---\n\n"
+  end
+
+  def to_markdown({:p, _attrs, inner, _meta}) do
+    to_markdown(inner) <> "\n\n"
+  end
+
+  def to_markdown({:br, _attrs, _inner, _meta}) do
+    "\n\n"
+  end
+
+  def to_markdown({:img, attrs, _inner, _meta}) do
+    alt = attrs[:alt] || ""
+    title = attrs[:title] || ""
+    "![#{alt}](#{attrs[:src]} \"#{title}\")"
+  end
+
+  def to_markdown({tag, _attrs, _inner, _meta}) when tag in @void_elements do
+    ""
+  end
+
+  def to_markdown({_tag, _attrs, inner, %{verbatim: true}}) do
+    Enum.join(inner, "")
+  end
+
+  def to_markdown({_tag, _attrs, inner, _meta}) do
+    to_markdown(inner)
+  end
+
   ## parse markdown
 
   defp parse_markdown(markdown, opts) do
diff --git a/lib/ex_doc/formatter.ex b/lib/ex_doc/formatter.ex
index f8f4b2eee..ff86934d3 100644
--- a/lib/ex_doc/formatter.ex
+++ b/lib/ex_doc/formatter.ex
@@ -48,14 +48,14 @@ defmodule ExDoc.Formatter do
 
                 specs = Enum.map(child_node.specs, &language.autolink_spec(&1, autolink_opts))
                 child_node = %{child_node | specs: specs}
-                render_doc(child_node, language, autolink_opts, opts)
+                render_doc(child_node, ext, language, autolink_opts, opts)
               end
 
-            %{render_doc(group, language, autolink_opts, opts) | docs: docs}
+            %{render_doc(group, ext, language, autolink_opts, opts) | docs: docs}
           end
 
         %{
-          render_doc(node, language, [{:id, node.id} | autolink_opts], opts)
+          render_doc(node, ext, language, [{:id, node.id} | autolink_opts], opts)
           | docs_groups: docs_groups
         }
       end,
@@ -117,11 +117,11 @@ defmodule ExDoc.Formatter do
 
   # Helper functions
 
-  defp render_doc(%{doc: nil} = node, _language, _autolink_opts, _opts),
+  defp render_doc(%{doc: nil} = node, _ext, _language, _autolink_opts, _opts),
     do: node
 
-  defp render_doc(%{doc: doc} = node, language, autolink_opts, opts) do
-    doc = autolink_and_highlight(doc, language, autolink_opts, opts)
+  defp render_doc(%{doc: doc} = node, ext, language, autolink_opts, opts) do
+    doc = autolink_and_render(doc, ext, language, autolink_opts, opts)
     %{node | doc: doc}
   end
 
@@ -137,7 +137,13 @@ defmodule ExDoc.Formatter do
     mod_id <> "." <> id
   end
 
-  defp autolink_and_highlight(doc, language, autolink_opts, opts) do
+  defp autolink_and_render(doc, ".md", language, autolink_opts, opts) do
+    doc
+    |> language.autolink_doc(autolink_opts)
+    |> ExDoc.DocAST.highlight(language, opts)
+  end
+
+  defp autolink_and_render(doc, _html_ext, language, autolink_opts, opts) do
     doc
     |> language.autolink_doc(autolink_opts)
     |> ExDoc.DocAST.highlight(language, opts)
@@ -187,6 +193,7 @@ defmodule ExDoc.Formatter do
 
     source_file = validate_extra_string!(input_options, :source) || input
     opts = [file: source_file, line: 1]
+    ext = Keyword.fetch!(autolink_opts, :ext)
 
     {extension, source, ast} =
       case extension_name(input) do
@@ -202,7 +209,7 @@ defmodule ExDoc.Formatter do
             source
             |> Markdown.to_ast(opts)
             |> ExDoc.DocAST.add_ids_to_headers([:h2, :h3])
-            |> autolink_and_highlight(language, [file: input] ++ autolink_opts, opts)
+            |> autolink_and_render(ext, language, [file: input] ++ autolink_opts, opts)
 
           {extension, source, ast}
 
diff --git a/lib/ex_doc/formatter/epub/templates.ex b/lib/ex_doc/formatter/epub/templates.ex
index 22dd483b8..ceb3d269e 100644
--- a/lib/ex_doc/formatter/epub/templates.ex
+++ b/lib/ex_doc/formatter/epub/templates.ex
@@ -13,14 +13,14 @@ defmodule ExDoc.Formatter.EPUB.Templates do
   defp render_doc(ast), do: ast && ExDoc.DocAST.to_string(ast)
 
   @doc """
-  Generate content from the module template for a given `node`
+  Generate content from the module template for a given `node`.
   """
   def module_page(config, module_node) do
     module_template(config, module_node)
   end
 
   @doc """
-  Generated ID for static file
+  Generated ID for static file.
   """
   def static_file_to_id(static_file) do
     static_file |> Path.basename() |> text_to_id()
diff --git a/lib/ex_doc/formatter/html/templates.ex b/lib/ex_doc/formatter/html/templates.ex
index 91c4ced07..ee7e9018a 100644
--- a/lib/ex_doc/formatter/html/templates.ex
+++ b/lib/ex_doc/formatter/html/templates.ex
@@ -13,7 +13,7 @@ defmodule ExDoc.Formatter.HTML.Templates do
     ]
 
   @doc """
-  Generate content from the module template for a given `node`
+  Generate content from the module template for a given `node`.
   """
   def module_page(module_node, config) do
     module_template(config, module_node)
diff --git a/lib/ex_doc/formatter/markdown.ex b/lib/ex_doc/formatter/markdown.ex
new file mode 100644
index 000000000..e8f497da4
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown.ex
@@ -0,0 +1,179 @@
+defmodule ExDoc.Formatter.Markdown do
+  @moduledoc false
+
+  alias __MODULE__.{Templates}
+  alias ExDoc.Formatter
+  alias ExDoc.Utils
+
+  @doc """
+  Generates Markdown documentation for the given modules.
+  """
+  @spec run([ExDoc.ModuleNode.t()], [ExDoc.ModuleNode.t()], ExDoc.Config.t()) :: String.t()
+  def run(project_nodes, filtered_modules, config) when is_map(config) do
+    Utils.unset_warned()
+
+    config = normalize_config(config)
+    File.rm_rf!(config.output)
+    File.mkdir_p!(config.output)
+
+    extras = Formatter.build_extras(config, ".md")
+
+    project_nodes =
+      project_nodes
+      |> Formatter.render_all(filtered_modules, ".md", config, highlight_tag: "samp")
+
+    nodes_map = %{
+      modules: Formatter.filter_list(:module, project_nodes),
+      tasks: Formatter.filter_list(:task, project_nodes)
+    }
+
+    config = %{config | extras: extras}
+
+    generate_nav(config, nodes_map)
+    generate_extras(config)
+    generate_list(config, nodes_map.modules)
+    generate_list(config, nodes_map.tasks)
+    generate_llm_index(config, nodes_map)
+
+    config.output |> Path.join("index.md") |> Path.relative_to_cwd()
+  end
+
+  defp normalize_config(config) do
+    output =
+      config.output
+      |> Path.expand()
+      |> Path.join("markdown")
+
+    %{config | output: output}
+  end
+
+  defp normalize_output(output) do
+    output
+    |> String.replace(~r/\r\n?/, "\n")
+    |> String.replace(~r/\n{3,}/, "\n\n")
+  end
+
+  defp generate_nav(config, nodes) do
+    nodes =
+      Map.update!(nodes, :modules, fn modules ->
+        modules |> Enum.chunk_by(& &1.group) |> Enum.map(&{hd(&1).group, &1})
+      end)
+
+    content =
+      Templates.nav_template(config, nodes)
+      |> normalize_output()
+
+    File.write("#{config.output}/index.md", content)
+  end
+
+  defp generate_extras(config) do
+    for {_title, extras} <- config.extras do
+      Enum.each(extras, fn %{id: id, source: content} ->
+        output = "#{config.output}/#{id}.md"
+
+        if File.regular?(output) do
+          Utils.warn("file #{Path.relative_to_cwd(output)} already exists", [])
+        end
+
+        File.write!(output, normalize_output(content))
+      end)
+    end
+  end
+
+  defp generate_list(config, nodes) do
+    nodes
+    |> Task.async_stream(&generate_module_page(&1, config), timeout: :infinity)
+    |> Enum.map(&elem(&1, 1))
+  end
+
+  ## Helpers
+
+  defp generate_module_page(module_node, config) do
+    content =
+      Templates.module_page(config, module_node)
+      |> normalize_output()
+
+    File.write("#{config.output}/#{module_node.id}.md", content)
+  end
+
+  defp generate_llm_index(config, nodes_map) do
+    content = generate_llm_index_content(config, nodes_map)
+    File.write("#{config.output}/llms.txt", content)
+  end
+
+  defp generate_llm_index_content(config, nodes_map) do
+    project_info = """
+    # #{config.project} #{config.version}
+
+    #{config.project} documentation index for Large Language Models.
+
+    ## Modules
+
+    """
+
+    modules_info =
+      nodes_map.modules
+      |> Enum.map(fn module_node ->
+        "- **#{module_node.title}** (#{module_node.id}.md): #{module_node.doc |> ExDoc.DocAST.synopsis() |> extract_plain_text()}"
+      end)
+      |> Enum.join("\n")
+
+    tasks_info =
+      if length(nodes_map.tasks) > 0 do
+        tasks_list =
+          nodes_map.tasks
+          |> Enum.map(fn task_node ->
+            "- **#{task_node.title}** (#{task_node.id}.md): #{task_node.doc |> ExDoc.DocAST.synopsis() |> extract_plain_text()}"
+          end)
+          |> Enum.join("\n")
+
+        "\n\n## Mix Tasks\n\n" <> tasks_list
+      else
+        ""
+      end
+
+    extras_info =
+      if is_list(config.extras) and length(config.extras) > 0 do
+        extras_list =
+          config.extras
+          |> Enum.flat_map(fn
+            {_group, extras} when is_list(extras) -> extras
+            _ -> []
+          end)
+          |> Enum.map(fn extra ->
+            "- **#{extra.title}** (#{extra.id}.md): #{extra.title}"
+          end)
+          |> Enum.join("\n")
+
+        if extras_list == "" do
+          ""
+        else
+          "\n\n## Guides\n\n" <> extras_list
+        end
+      else
+        ""
+      end
+
+    project_info <> modules_info <> tasks_info <> extras_info
+  end
+
+  defp extract_plain_text(html) when is_binary(html) do
+    html
+    |> String.replace(~r/<[^>]*>/, "")
+    |> String.replace(~r/\s+/, " ")
+    |> String.trim()
+    |> case do
+      "" ->
+        "No documentation available"
+
+      text ->
+        if String.length(text) > 150 do
+          String.slice(text, 0, 150) <> "..."
+        else
+          text
+        end
+    end
+  end
+
+  defp extract_plain_text(_), do: "No documentation available"
+end
diff --git a/lib/ex_doc/formatter/markdown/templates.ex b/lib/ex_doc/formatter/markdown/templates.ex
new file mode 100644
index 000000000..ee835608b
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates.ex
@@ -0,0 +1,241 @@
+defmodule ExDoc.Formatter.Markdown.Templates do
+  @moduledoc false
+
+  require EEx
+
+  import ExDoc.Utils,
+    only: [before_closing_body_tag: 2, h: 1, text_to_id: 1]
+
+  @doc """
+  Generate content from the module template for a given `node`.
+  """
+  def module_page(config, module_node) do
+    summary =
+      for group <- module_node.docs_groups do
+        {group.title, group.docs}
+      end
+
+    module_template(config, module_node, summary)
+  end
+
+  @doc """
+  Returns the formatted title for the module page.
+  """
+  def module_type(%{type: :task} = _node), do: ""
+  def module_type(%{type: :module} = _node), do: ""
+  def module_type(%{type: type} = _node), do: "(#{type})"
+
+  @doc """
+  Formats the attribute type used to define the spec of the given `node`.
+  """
+  def format_spec_attribute(module, node) do
+    module.language.format_spec_attribute(node)
+  end
+
+  @doc """
+  Generates an ID for a static file.
+  """
+  def static_file_to_id(static_file) do
+    static_file |> Path.basename() |> text_to_id()
+  end
+
+  def node_doc(%{doc: doc}) when is_list(doc) do
+    # Handle DocAST by converting to Markdown.
+    ExDoc.DocAST.to_markdown(doc)
+  end
+
+  def node_doc(%{doc: doc}) when is_binary(doc), do: doc
+  def node_doc(%{source_doc: %{"en" => source}}) when is_binary(source), do: source
+  def node_doc(%{rendered_doc: source}) when is_binary(source), do: source
+
+  def node_doc(%{source_doc: %{"en" => source}}) when is_list(source) do
+    # Handle DocAST by converting to Markdown.
+    # For Erlang docs, we can extract the text content.
+    extract_text_from_doc_ast(source)
+  end
+
+  def node_doc(_), do: nil
+
+  @doc """
+  Get synopsis for a node, handling both DocAST and string documentation.
+  """
+  def node_synopsis(%{doc: doc}) when is_list(doc) do
+    # For DocAST, extract synopsis DocAST and convert to Markdown.
+    case extract_synopsis_ast(doc) do
+      nil -> nil
+      synopsis_ast -> ExDoc.DocAST.to_markdown(synopsis_ast)
+    end
+  end
+
+  def node_synopsis(%{doc: doc}) when is_binary(doc) do
+    synopsis(doc)
+  end
+
+  def node_synopsis(%{source_doc: %{"en" => source}}) when is_binary(source) do
+    synopsis(source)
+  end
+
+  def node_synopsis(%{rendered_doc: source}) when is_binary(source) do
+    synopsis(source)
+  end
+
+  def node_synopsis(%{source_doc: %{"en" => source}}) when is_list(source) do
+    case extract_synopsis_ast(source) do
+      nil -> nil
+      synopsis_ast -> synopsis_ast |> ExDoc.DocAST.to_markdown() |> extract_plain_text()
+    end
+  end
+
+  def node_synopsis(_), do: nil
+
+  # Extract synopsis as DocAST (similar to ExDoc.DocAST.synopsis but returns an AST instead of an HTML string).
+  defp extract_synopsis_ast({:p, _attrs, [_ | _] = inner, _meta}) do
+    inner =
+      case Enum.split(inner, -1) do
+        {pre, [post]} when is_binary(post) ->
+          pre ++ [String.trim_trailing(post, ":")]
+
+        _ ->
+          inner
+      end
+
+    {:p, [], ExDoc.DocAST.remove_ids(inner), %{}}
+  end
+
+  defp extract_synopsis_ast([head | _]), do: extract_synopsis_ast(head)
+  defp extract_synopsis_ast(_other), do: nil
+
+  defp extract_text_from_doc_ast(ast) when is_list(ast) do
+    Enum.map_join(ast, "\n\n", &extract_text_from_doc_ast/1)
+  end
+
+  defp extract_text_from_doc_ast({_tag, _attrs, content}) when is_list(content) do
+    Enum.map_join(content, "", &extract_text_from_doc_ast/1)
+  end
+
+  defp extract_text_from_doc_ast({_tag, _attrs, content, _meta}) when is_list(content) do
+    Enum.map_join(content, "", &extract_text_from_doc_ast/1)
+  end
+
+  defp extract_text_from_doc_ast(text) when is_binary(text), do: text
+  defp extract_text_from_doc_ast(_), do: ""
+
+  # Extract plain text from markdown (similar to the one in markdown.ex but here for templates)
+  defp extract_plain_text(markdown) when is_binary(markdown) do
+    markdown
+    |> String.replace(~r/<[^>]*>/, "")
+    |> String.replace(~r/\s+/, " ")
+    |> String.trim()
+    |> case do
+      "" ->
+        nil
+
+      text ->
+        text
+        |> String.slice(0, 150)
+        |> then(fn s -> if String.length(s) == 150, do: s <> "...", else: s end)
+    end
+  end
+
+  defp extract_plain_text(_), do: nil
+
+  @doc """
+  Gets the first paragraph of the documentation of a node. It strips
+  surrounding white-spaces and trailing `:`.
+
+  If `doc` is `nil`, it returns `nil`.
+  """
+  @spec synopsis(String.t()) :: String.t()
+  @spec synopsis(nil) :: nil
+  def synopsis(doc) when is_binary(doc) do
+    case :binary.split(doc, "\n\n") do
+      [left, _] -> (String.trim_trailing(left) |> String.trim_trailing(":")) <> "\n\n"
+      [all] -> all
+    end
+  end
+
+  def synopsis(_), do: nil
+
+  defp rewrite_headings(content) when is_binary(content) do
+    ~r/^(\#{1,6})\s+(.*)/m
+    |> Regex.scan(content)
+    |> Enum.reduce(content, fn [match, level, title], content ->
+      replacement = rewrite_heading(level, title)
+      String.replace(content, match, replacement, global: false)
+    end)
+  end
+
+  defp rewrite_headings(_), do: nil
+
+  defp rewrite_heading("#", title), do: do_rewrite_heading("#####", title)
+  defp rewrite_heading(_, title), do: do_rewrite_heading("######", title)
+
+  defp do_rewrite_heading(level, title) do
+    """
+    #{level} #{title}
+    """
+  end
+
+  defp enc(binary), do: URI.encode(binary) |> String.replace("/", "-")
+
+  @doc """
+  Creates a chapter which contains all the details about an individual module.
+
+  This chapter can include the following sections: *functions*, *types*, *callbacks*.
+  """
+  EEx.function_from_file(
+    :def,
+    :module_template,
+    Path.expand("templates/module_template.eex", __DIR__),
+    [:config, :module, :summary],
+    trim: true
+  )
+
+  @doc """
+  Creates the table of contents.
+  """
+  EEx.function_from_file(
+    :def,
+    :nav_template,
+    Path.expand("templates/nav_template.eex", __DIR__),
+    [:config, :nodes],
+    trim: true
+  )
+
+  EEx.function_from_file(
+    :defp,
+    :nav_item_template,
+    Path.expand("templates/nav_item_template.eex", __DIR__),
+    [:name, :nodes],
+    trim: true
+  )
+
+  EEx.function_from_file(
+    :defp,
+    :nav_grouped_item_template,
+    Path.expand("templates/nav_grouped_item_template.eex", __DIR__),
+    [:nodes],
+    trim: true
+  )
+
+  # EEx.function_from_file(
+  #   :defp,
+  #   :toc_item_template,
+  #   Path.expand("templates/toc_item_template.eex", __DIR__),
+  #   [:nodes],
+  #   trim: true
+  # )
+
+  # def media_type(_arg), do: nil
+
+  templates = [
+    detail_template: [:node, :module],
+    summary_template: [:name, :nodes]
+  ]
+
+  Enum.each(templates, fn {name, args} ->
+    filename = Path.expand("templates/#{name}.eex", __DIR__)
+    @doc false
+    EEx.function_from_file(:def, name, filename, args, trim: true)
+  end)
+end
diff --git a/lib/ex_doc/formatter/markdown/templates/detail_template.eex b/lib/ex_doc/formatter/markdown/templates/detail_template.eex
new file mode 100644
index 000000000..b68ace209
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates/detail_template.eex
@@ -0,0 +1,17 @@
+<a id="<%= enc node.id %>"></a>
+#### `<%=h node.signature %>` <%= if node.source_url do %>[🔗](<%= node.source_url %>)<% end %> <%= for annotation <- node.annotations do %>(<%= annotation %>) <% end %>
+
+<%= if deprecated = node.deprecated do %>
+> This <%= node.type %> is deprecated. <%= h(deprecated) %>.
+
+<% end %>
+<%= if node.specs != [] do %>
+<%= for spec <- node.specs do %>
+```elixir
+<%= format_spec_attribute(module, node) %> <%= spec %>
+```
+<% end %>
+<% end %>
+
+<%= rewrite_headings(node_doc(node)) %>
+
diff --git a/lib/ex_doc/formatter/markdown/templates/module_template.eex b/lib/ex_doc/formatter/markdown/templates/module_template.eex
new file mode 100644
index 000000000..12c20ab57
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates/module_template.eex
@@ -0,0 +1,35 @@
+# <%= module.title %> <%= module_type(module) %> (<%= config.project %> v<%= config.version %>)
+
+<%= for annotation <- module.annotations do %>*(<%= annotation %>)* <% end %>
+
+<%= if deprecated = module.deprecated do %>
+> This <%= module.type %> is deprecated. <%=h deprecated %>.
+
+<% end %>
+<%= if doc = node_doc(module) do %>
+<%= doc %>
+<% end %>
+
+<%= if summary != [] do %>
+## Table of Contents
+<%= for {name, nodes} <- summary, do: summary_template(name, nodes) %>
+<% end %>
+
+## Contents
+
+<%= for {name, nodes} <- summary, _key = text_to_id(name) do %>
+### <%=h to_string(name) %>
+
+<%= for node <- nodes do %>
+<%= detail_template(node, module) %>
+<% end %>
+
+<% end %>
+
+---
+
+<%= if module.source_url do %>
+[<%= String.capitalize(to_string(module.type)) %> Source Code](<%= module.source_url %>)
+<% end %>
+
+<%= before_closing_body_tag(config, :markdown) %>
diff --git a/lib/ex_doc/formatter/markdown/templates/nav_grouped_item_template.eex b/lib/ex_doc/formatter/markdown/templates/nav_grouped_item_template.eex
new file mode 100644
index 000000000..874ebdbfd
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates/nav_grouped_item_template.eex
@@ -0,0 +1,8 @@
+<%= for {title, nodes} <- nodes do %>
+<%= if title do %>
+- <%=h to_string(title) %>
+<% end %>
+<%= for node <- nodes do %>
+  - [<%=h node.title %>](<%= URI.encode node.id %>.md)
+<% end %>
+<% end %>
diff --git a/lib/ex_doc/formatter/markdown/templates/nav_item_template.eex b/lib/ex_doc/formatter/markdown/templates/nav_item_template.eex
new file mode 100644
index 000000000..449c46e22
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates/nav_item_template.eex
@@ -0,0 +1,6 @@
+<%= unless Enum.empty?(nodes) do %>
+- <%= name %>
+<%= for node <- nodes do %>
+  - [<%=h node.title %>](<%= URI.encode node.id %>.md)
+<% end %>
+<% end %>
diff --git a/lib/ex_doc/formatter/markdown/templates/nav_template.eex b/lib/ex_doc/formatter/markdown/templates/nav_template.eex
new file mode 100644
index 000000000..55434a410
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates/nav_template.eex
@@ -0,0 +1,9 @@
+# <%= config.project %> v<%= config.version %> - Documentation - Table of Contents
+
+<%= nav_grouped_item_template config.extras  %>
+<%= unless Enum.empty?(nodes.modules) do %>
+## Modules
+<%= nav_grouped_item_template nodes.modules  %>    
+<% end %>
+<%= nav_item_template "Mix Tasks", nodes.tasks %>
+<%= before_closing_body_tag(config, :markdown) %>
diff --git a/lib/ex_doc/formatter/markdown/templates/summary_template.eex b/lib/ex_doc/formatter/markdown/templates/summary_template.eex
new file mode 100644
index 000000000..05d0aeba7
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates/summary_template.eex
@@ -0,0 +1,15 @@
+### <%= name %>
+
+<%= for node <- nodes do %>
+
+#### [`<%=h node.signature %>`](#<%= enc node.id %>)
+
+<%= if deprecated = node.deprecated do %>
+> <%= h(deprecated) %>
+
+<% end %>
+<%= if synopsis_content = node_synopsis(node) do %>
+<%= synopsis_content %>
+<% end %>
+
+<% end %>
diff --git a/test/ex_doc/doc_ast_test.exs b/test/ex_doc/doc_ast_test.exs
index abbf54d0c..b55224ce6 100644
--- a/test/ex_doc/doc_ast_test.exs
+++ b/test/ex_doc/doc_ast_test.exs
@@ -47,6 +47,179 @@ defmodule ExDoc.DocASTTest do
     end
   end
 
+  describe "to_markdown/1" do
+    test "converts simple text" do
+      assert DocAST.to_markdown("hello world") == "hello world"
+    end
+
+    test "escapes HTML entities in text" do
+      assert DocAST.to_markdown("<script>alert('xss')</script>") ==
+               "&lt;script&gt;alert('xss')&lt;/script&gt;"
+
+      assert DocAST.to_markdown("Tom & Jerry") == "Tom &amp; Jerry"
+    end
+
+    test "converts lists of elements" do
+      ast = ["Hello ", "world", "!"]
+      assert DocAST.to_markdown(ast) == "Hello world!"
+    end
+
+    test "converts paragraphs" do
+      ast = {:p, [], ["Hello world"], %{}}
+      assert DocAST.to_markdown(ast) == "Hello world\n\n"
+    end
+
+    test "converts multiple paragraphs" do
+      ast = [
+        {:p, [], ["First paragraph"], %{}},
+        {:p, [], ["Second paragraph"], %{}}
+      ]
+
+      assert DocAST.to_markdown(ast) == "First paragraph\n\nSecond paragraph\n\n"
+    end
+
+    test "converts code blocks with language" do
+      ast = {:code, [class: "elixir"], "defmodule Test do\n  def hello, do: :world\nend", %{}}
+      expected = "```elixir\ndefmodule Test do\n  def hello, do: :world\nend\n```\n"
+      assert DocAST.to_markdown(ast) == expected
+    end
+
+    test "converts code blocks without language" do
+      ast = {:code, [], "some code", %{}}
+      assert DocAST.to_markdown(ast) == "```\nsome code\n```\n"
+    end
+
+    test "converts inline code with class attribute" do
+      ast = {:code, [class: "language-elixir"], "IO.puts", %{}}
+      expected = "```language-elixir\nIO.puts\n```\n"
+      assert DocAST.to_markdown(ast) == expected
+    end
+
+    test "converts links" do
+      ast = {:a, [href: "https://example.com"], ["Example"], %{}}
+      assert DocAST.to_markdown(ast) == "[Example](https://example.com)"
+    end
+
+    test "converts links with nested content" do
+      ast = {:a, [href: "/docs"], [{:code, [], ["API"], %{}}], %{}}
+      assert DocAST.to_markdown(ast) == "[```\nAPI\n```\n](/docs)"
+    end
+
+    test "converts images with alt and title" do
+      ast = {:img, [src: "image.png", alt: "Alt text", title: "Title"], [], %{}}
+      assert DocAST.to_markdown(ast) == "![Alt text](image.png \"Title\")"
+    end
+
+    test "converts images with missing attributes" do
+      ast = {:img, [src: "image.png"], [], %{}}
+      assert DocAST.to_markdown(ast) == "![](image.png \"\")"
+    end
+
+    test "converts horizontal rules" do
+      ast = {:hr, [], [], %{}}
+      assert DocAST.to_markdown(ast) == "\n\n---\n\n"
+    end
+
+    test "converts line breaks" do
+      ast = {:br, [], [], %{}}
+      assert DocAST.to_markdown(ast) == "\n\n"
+    end
+
+    test "converts comments" do
+      ast = {:comment, [], [" This is a comment "], %{}}
+      assert DocAST.to_markdown(ast) == "<!-- This is a comment -->"
+    end
+
+    test "handles void elements" do
+      void_elements = [
+        :area,
+        :base,
+        :col,
+        :embed,
+        :input,
+        :link,
+        :meta,
+        :param,
+        :source,
+        :track,
+        :wbr
+      ]
+
+      for element <- void_elements do
+        ast = {element, [], [], %{}}
+        assert DocAST.to_markdown(ast) == ""
+      end
+    end
+
+    test "handles verbatim content" do
+      ast = {:pre, [], ["  verbatim  \n  content  "], %{verbatim: true}}
+      assert DocAST.to_markdown(ast) == "  verbatim  \n  content  "
+    end
+
+    test "converts nested structures" do
+      ast = {:p, [], ["Hello ", {:strong, [], ["world"], %{}}, "!"], %{}}
+
+      result = DocAST.to_markdown(ast)
+      assert result =~ "Hello"
+      assert result =~ "world"
+      assert result =~ "!"
+      assert String.ends_with?(result, "\n\n")
+    end
+
+    test "handles unknown elements by extracting content" do
+      ast = {:custom_element, [class: "special"], ["Content"], %{}}
+      assert DocAST.to_markdown(ast) == "Content"
+    end
+
+    test "handles complex nested document" do
+      ast = [
+        {:h1, [], ["Main Title"], %{}},
+        {:p, [], ["Introduction paragraph with ", {:a, [href: "/link"], ["a link"], %{}}], %{}},
+        {:code, [class: "elixir"], "IO.puts \"Hello\"", %{}},
+        {:hr, [], [], %{}},
+        {:p, [], ["Final paragraph"], %{}}
+      ]
+
+      result = DocAST.to_markdown(ast)
+
+      assert result =~ "Main Title"
+      assert result =~ "Introduction paragraph with [a link](/link)"
+      assert result =~ "```elixir\nIO.puts \"Hello\"\n```\n"
+      assert result =~ "\n\n---\n\n"
+      assert result =~ "Final paragraph\n\n"
+    end
+
+    test "handles empty content gracefully" do
+      assert DocAST.to_markdown([]) == ""
+      assert DocAST.to_markdown({:p, [], [], %{}}) == "\n\n"
+    end
+
+    test "preserves whitespace in code blocks" do
+      code_content = "  def hello do\n    :world\n  end"
+      ast = {:code, [class: "elixir"], code_content, %{}}
+      result = DocAST.to_markdown(ast)
+
+      assert result =~ "```elixir"
+      assert String.contains?(result, code_content)
+      assert result =~ "```"
+    end
+
+    test "handles mixed content types" do
+      ast = [
+        "Plain text",
+        {:p, [], ["Paragraph text"], %{}},
+        {:code, [], "code", %{}},
+        "More plain text"
+      ]
+
+      result = DocAST.to_markdown(ast)
+      assert result =~ "Plain text"
+      assert result =~ "Paragraph text\n\n"
+      assert result =~ "```\ncode\n```\n"
+      assert result =~ "More plain text"
+    end
+  end
+
   describe "to_string/2" do
     test "simple" do
       markdown = """
@@ -161,13 +334,11 @@ defmodule ExDoc.DocASTTest do
 
   describe "highlight" do
     test "with default class" do
-      # Four spaces
       assert highlight("""
                  mix run --no-halt path/to/file.exs
              """) =~
                ~r{<pre><code class=\"makeup elixir\" translate="no">.*}
 
-      # Code block without language
       assert highlight("""
              ```
              mix run --no-halt path/to/file.exs</code></pre>
@@ -175,7 +346,6 @@ defmodule ExDoc.DocASTTest do
              """) =~
                ~r{<pre><code class=\"makeup elixir\" translate="no">.*}
 
-      # Pre IAL
       assert highlight("""
              ```
              mix run --no-halt path/to/file.exs</code></pre>
@@ -184,7 +354,6 @@ defmodule ExDoc.DocASTTest do
              """) =~
                ~r{<pre class="wrap"><code class=\"makeup elixir\" translate="no">.*}
 
-      # Code with language
       assert highlight("""
              ```html
              <foo />
@@ -192,7 +361,6 @@ defmodule ExDoc.DocASTTest do
              """) =~
                ~r{<pre><code class=\"makeup html\" translate="no">.*}
 
-      # Code with shell detection
       assert highlight("""
              ```
              $ hello
@@ -200,7 +368,6 @@ defmodule ExDoc.DocASTTest do
              """) =~
                ~r{<pre><code class=\"makeup shell\" translate="no"><span class="gp unselectable">\$.*}
 
-      # Nested in another element
       assert highlight("""
              > ```elixir
              > hello
diff --git a/test/ex_doc/formatter/markdown_test.exs b/test/ex_doc/formatter/markdown_test.exs
new file mode 100644
index 000000000..0918baafa
--- /dev/null
+++ b/test/ex_doc/formatter/markdown_test.exs
@@ -0,0 +1,404 @@
+defmodule ExDoc.Formatter.MarkdownTest do
+  use ExUnit.Case, async: false
+
+  @moduletag :tmp_dir
+
+  defp doc_config(%{tmp_dir: tmp_dir} = _context) do
+    [
+      project: "Elixir",
+      version: "1.0.1",
+      formatter: "markdown",
+      output: tmp_dir,
+      source_beam: "test/tmp/beam",
+      skip_undefined_reference_warnings_on: ["Warnings"]
+    ]
+  end
+
+  defp doc_config(context, config) when is_map(context) and is_list(config) do
+    Keyword.merge(doc_config(context), config)
+  end
+
+  defp generate_docs(config) do
+    ExDoc.generate_docs(config[:project], config[:version], config)
+  end
+
+  test "generates Markdown files in the default directory", %{tmp_dir: tmp_dir} = context do
+    generate_docs(doc_config(context))
+    assert File.regular?(tmp_dir <> "/markdown/index.md")
+    assert File.regular?(tmp_dir <> "/markdown/CompiledWithDocs.md")
+  end
+
+  test "generates headers for module pages", %{tmp_dir: tmp_dir} = context do
+    generate_docs(doc_config(context, main: "RandomError"))
+
+    content = File.read!(tmp_dir <> "/markdown/RandomError.md")
+    assert content =~ ~r{^# RandomError}m
+    assert content =~ ~r{\(Elixir v1\.0\.1\)}
+  end
+
+  test "generates all listing files", %{tmp_dir: tmp_dir} = context do
+    generate_docs(doc_config(context))
+
+    assert File.regular?(tmp_dir <> "/markdown/CompiledWithDocs.md")
+    assert File.regular?(tmp_dir <> "/markdown/CompiledWithDocs.Nested.md")
+    assert File.regular?(tmp_dir <> "/markdown/CustomBehaviourOne.md")
+    assert File.regular?(tmp_dir <> "/markdown/CustomBehaviourTwo.md")
+    assert File.regular?(tmp_dir <> "/markdown/RandomError.md")
+    assert File.regular?(tmp_dir <> "/markdown/CustomProtocol.md")
+    assert File.regular?(tmp_dir <> "/markdown/Mix.Tasks.TaskWithDocs.md")
+  end
+
+  test "generates the index file", %{tmp_dir: tmp_dir} = context do
+    generate_docs(doc_config(context))
+
+    content = File.read!(tmp_dir <> "/markdown/index.md")
+    assert content =~ ~r{^# Elixir v1\.0\.1 - Documentation - Table of Contents$}m
+    assert content =~ ~r{## Modules}
+    assert content =~ ~r{- \[CompiledWithDocs\]\(CompiledWithDocs\.md\)}
+    assert content =~ ~r{- \[CompiledWithDocs\.Nested\]\(CompiledWithDocs\.Nested\.md\)}
+  end
+
+  test "generates module with proper structure", %{tmp_dir: tmp_dir} = context do
+    generate_docs(doc_config(context))
+
+    content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+
+    # Header
+    assert content =~ ~r{^# CompiledWithDocs  \(Elixir v1\.0\.1\)}m
+    assert content =~ ~r{\*\(example_module_tag\)\*}
+
+    # Moduledoc
+    assert content =~ ~r{moduledoc}
+
+    # Table of Contents
+    assert content =~ ~r{## Table of Contents}
+    assert content =~ ~r{### Functions}
+
+    # Contents section
+    assert content =~ ~r{## Contents}
+  end
+
+  test "generates functions correctly", %{tmp_dir: tmp_dir} = context do
+    generate_docs(doc_config(context))
+
+    content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+
+    # Function in ToC
+    assert content =~ ~r{####.*\[`example\(foo, bar}
+    assert content =~ ~r{#example-2\)}
+
+    # Function details
+    assert content =~ ~r{<a id="example-2"></a>}
+    assert content =~ ~r{#### `example\(foo, bar \\\\ Baz\)`}
+    assert content =~ ~r{Some example}
+
+    # Deprecated notice
+    assert content =~ ~r{> This function is deprecated\. Use something else instead\.}
+
+    # Struct
+    assert content =~ ~r{`%CompiledWithDocs\{\}`}
+    assert content =~ ~r{Some struct}
+
+    # Since annotation
+    assert content =~ ~r{example_1\(\)}
+    assert content =~ ~r{\(since 1\.3\.0\)}
+
+    # Macro annotation
+    assert content =~ ~r{\(macro\)}
+  end
+
+  describe "generates extras" do
+    test "ignores any external url extras", %{tmp_dir: tmp_dir} = context do
+      config =
+        context
+        |> doc_config()
+        |> Keyword.put(:extras, elixir: [url: "https://elixir-lang.org"])
+
+      generate_docs(config)
+
+      refute File.exists?(tmp_dir <> "/markdown/elixir.md")
+    end
+  end
+
+  test "generates LLM index file", %{tmp_dir: tmp_dir} = context do
+    generate_docs(doc_config(context))
+
+    content = File.read!(tmp_dir <> "/markdown/llms.txt")
+
+    assert content =~ ~r{# Elixir 1\.0\.1}
+    assert content =~ ~r{Elixir documentation index for Large Language Models}
+    assert content =~ ~r{## Modules}
+    assert content =~ ~r{- \*\*CompiledWithDocs\*\* \(CompiledWithDocs\.md\):}
+  end
+
+  describe "markdown output validation" do
+    test "generates proper markdown syntax", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+
+      assert content =~ ~r/^# CompiledWithDocs/m
+      assert content =~ ~r/^## Table of Contents/m
+      assert content =~ ~r/^### Functions/m
+      assert content =~ ~r/^#### `/m
+      assert content =~ ~r/```makeup elixir/s
+      assert content =~ ~r/\[.*\]\(#.*\)/ || content =~ ~r/\[.*\]\(http.*\)/
+      refute content =~ ~r/^# .*\n^# /m
+    end
+
+    test "handles complex documentation elements", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+
+      assert content =~ ~r/#### `example\(foo, bar.*\)`/
+      assert content =~ ~r/> This function is deprecated\./
+      assert content =~ ~r/<a id="[^"]+"><\/a>/
+    end
+
+    test "generates valid navigation structure", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+      content = File.read!(tmp_dir <> "/markdown/index.md")
+
+      assert content =~ ~r/^# Elixir v1\.0\.1 - Documentation - Table of Contents$/m
+      assert content =~ ~r/- \[CompiledWithDocs\]\(CompiledWithDocs\.md\)/
+      assert content =~ ~r/- \[CompiledWithDocs\.Nested\]\(CompiledWithDocs\.Nested\.md\)/
+      assert content =~ ~r/- \[mix task_with_docs\]\(Mix\.Tasks\.TaskWithDocs\.md\)/
+      refute content =~ ~r/\]\([^)]*\s[^)]*\)/
+      refute content =~ ~r/\[[^\]]*\]\(\)/
+    end
+
+    test "generates proper markdown escaping", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+
+      assert content =~ ~r/&lt;|&gt;|&amp;/ || !String.contains?(content, "<script>")
+      assert content =~ ~r/#### `[^`]+`/
+    end
+  end
+
+  describe "configuration options" do
+    test "handles custom output directory", %{tmp_dir: tmp_dir} = context do
+      custom_output = Path.join(tmp_dir, "custom_docs")
+      config = doc_config(context, output: custom_output)
+      generate_docs(config)
+
+      assert File.regular?(custom_output <> "/markdown/index.md")
+      assert File.regular?(custom_output <> "/markdown/CompiledWithDocs.md")
+      refute File.exists?(tmp_dir <> "/markdown/index.md")
+    end
+
+    test "handles custom project name and version", %{tmp_dir: tmp_dir} = context do
+      config = doc_config(context, project: "MyProject", version: "2.0.0")
+      generate_docs(config)
+
+      content = File.read!(tmp_dir <> "/markdown/index.md")
+      assert content =~ ~r/# MyProject v2\.0\.0 - Documentation/
+
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+      assert content =~ ~r/\(MyProject v2\.0\.0\)/
+      llm_content = File.read!(tmp_dir <> "/markdown/llms.txt")
+      assert llm_content =~ ~r/# MyProject 2\.0\.0/
+    end
+
+    test "processes source_url configuration", %{tmp_dir: tmp_dir} = context do
+      config = doc_config(context, source_url: "https://github.com/example/project")
+      generate_docs(config)
+
+      assert File.regular?(tmp_dir <> "/markdown/CompiledWithDocs.md")
+      assert File.regular?(tmp_dir <> "/markdown/index.md")
+    end
+  end
+
+  describe "extras handling" do
+    test "processes markdown extras correctly", %{tmp_dir: tmp_dir} = context do
+      config = doc_config(context, extras: ["test/fixtures/README.md"])
+      generate_docs(config)
+
+      assert File.regular?(tmp_dir <> "/markdown/index.md")
+      nav_content = File.read!(tmp_dir <> "/markdown/index.md")
+      assert nav_content =~ ~r/## Modules/
+      assert File.regular?(tmp_dir <> "/markdown/llms.txt")
+    end
+
+    test "handles multiple extras with custom names", %{tmp_dir: tmp_dir} = context do
+      config =
+        doc_config(context,
+          extras: [
+            "test/fixtures/README.md",
+            {"test/fixtures/LICENSE", filename: "license-file"}
+          ]
+        )
+
+      generate_docs(config)
+
+      assert File.regular?(tmp_dir <> "/markdown/index.md")
+      assert File.regular?(tmp_dir <> "/markdown/llms.txt")
+    end
+
+    test "processes plain text files as extras", %{tmp_dir: tmp_dir} = context do
+      config = doc_config(context, extras: ["test/fixtures/PlainText.txt"])
+      generate_docs(config)
+
+      assert File.regular?(tmp_dir <> "/markdown/index.md")
+    end
+
+    test "handles extras with custom titles", %{tmp_dir: tmp_dir} = context do
+      config =
+        doc_config(context,
+          extras: [
+            {"test/fixtures/README.md", title: "Getting Started"}
+          ]
+        )
+
+      generate_docs(config)
+
+      assert File.regular?(tmp_dir <> "/markdown/index.md")
+      assert File.regular?(tmp_dir <> "/markdown/llms.txt")
+    end
+
+    test "ignores external url extras", %{tmp_dir: tmp_dir} = context do
+      config =
+        doc_config(context,
+          extras: [
+            "test/fixtures/README.md",
+            elixir: [url: "https://elixir-lang.org"]
+          ]
+        )
+
+      generate_docs(config)
+
+      refute File.exists?(tmp_dir <> "/markdown/elixir.md")
+      assert File.regular?(tmp_dir <> "/markdown/index.md")
+    end
+  end
+
+  describe "error scenarios" do
+    test "handles modules with no documentation gracefully", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+
+      assert File.regular?(tmp_dir <> "/markdown/CompiledWithoutDocs.md")
+
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithoutDocs.md")
+      assert content =~ ~r/^# CompiledWithoutDocs/
+    end
+
+    test "handles missing source beam directory", %{tmp_dir: tmp_dir} = context do
+      config = doc_config(context, source_beam: "nonexistent/path")
+
+      generate_docs(config)
+      assert File.regular?(tmp_dir <> "/markdown/index.md")
+    end
+
+    test "handles empty extras list", %{tmp_dir: tmp_dir} = context do
+      config = doc_config(context, extras: [])
+      generate_docs(config)
+
+      nav_content = File.read!(tmp_dir <> "/markdown/index.md")
+      refute nav_content =~ ~r/## Guides/
+
+      llm_content = File.read!(tmp_dir <> "/markdown/llms.txt")
+      refute llm_content =~ ~r/## Guides/
+    end
+
+    test "handles special characters in module names", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+
+      assert File.regular?(tmp_dir <> "/markdown/CompiledWithDocs.Nested.md")
+
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.Nested.md")
+      assert content =~ ~r/^# CompiledWithDocs\.Nested/
+    end
+  end
+
+  describe "llm index comprehensive tests" do
+    test "creates comprehensive llm index with all sections", %{tmp_dir: tmp_dir} = context do
+      config = doc_config(context, extras: ["test/fixtures/README.md"])
+      generate_docs(config)
+
+      content = File.read!(tmp_dir <> "/markdown/llms.txt")
+
+      assert content =~ ~r/# Elixir 1\.0\.1/
+      assert content =~ ~r/documentation index for Large Language Models/
+
+      assert content =~ ~r/## Modules/
+      assert content =~ ~r/- \*\*CompiledWithDocs\*\* \(CompiledWithDocs\.md\):/
+      assert content =~ ~r/- \*\*CustomBehaviourOne\*\*/
+
+      assert content =~ ~r/## Mix Tasks/
+      assert content =~ ~r/- \*\*mix task_with_docs\*\*/
+    end
+
+    test "handles llm index when no tasks exist", %{tmp_dir: tmp_dir} = context do
+      config = doc_config(context, source_beam: "test/fixtures/beam_no_tasks")
+      generate_docs(config)
+
+      content = File.read!(tmp_dir <> "/markdown/llms.txt")
+
+      assert content =~ ~r/## Modules/
+    end
+
+    test "truncates long descriptions in llm index", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+
+      content = File.read!(tmp_dir <> "/markdown/llms.txt")
+
+      lines = String.split(content, "\n")
+      module_lines = Enum.filter(lines, &String.starts_with?(&1, "- **"))
+
+      for line <- module_lines do
+        assert String.length(line) < 300
+      end
+    end
+  end
+
+  describe "cross-references and links" do
+    test "generates proper internal links", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+
+      assert content =~ ~r/\[`[^`]+`\]\(#[^)]+\)/
+    end
+
+    test "handles function anchors correctly", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+
+      assert content =~ ~r/<a id="[^"]+"><\/a>/
+
+      anchor_ids = Regex.scan(~r/<a id="([^"]+)"><\/a>/, content, capture: :all_but_first)
+      link_refs = Regex.scan(~r/\]\(#([^)]+)\)/, content, capture: :all_but_first)
+
+      anchor_id_list = List.flatten(anchor_ids)
+      link_ref_list = List.flatten(link_refs)
+
+      assert length(anchor_id_list) > 0
+      assert length(link_ref_list) > 0
+    end
+  end
+
+  describe "output normalization" do
+    test "normalizes line endings consistently", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+      content = File.read!(tmp_dir <> "/markdown/CompiledWithDocs.md")
+
+      refute String.contains?(content, "\r\n")
+      refute String.contains?(content, "\r")
+
+      refute String.contains?(content, "\n\n\n\n")
+    end
+
+    test "handles unicode content properly", %{tmp_dir: tmp_dir} = context do
+      generate_docs(doc_config(context))
+
+      files = [
+        tmp_dir <> "/markdown/index.md",
+        tmp_dir <> "/markdown/CompiledWithDocs.md"
+      ]
+
+      for file <- files do
+        content = File.read!(file)
+        assert String.valid?(content)
+      end
+    end
+  end
+end