diff --git a/lib/ex_doc/autolink.ex b/lib/ex_doc/autolink.ex
index 57d809e3b..32f4eb4ab 100644
--- a/lib/ex_doc/autolink.ex
+++ b/lib/ex_doc/autolink.ex
@@ -99,10 +99,13 @@ defmodule ExDoc.Autolink do
       if app in config.apps do
         path <> ext <> suffix
       else
+        #  TODO: remove this if/when hexdocs.pm starts including .md files
+        ext = ".html"
+
         config.deps
         |> Keyword.get_lazy(app, fn -> base_url <> "#{app}" end)
         |> String.trim_trailing("/")
-        |> Kernel.<>("/" <> path <> ".html" <> suffix)
+        |> Kernel.<>("/" <> path <> ext <> suffix)
       end
     else
       path <> ext <> suffix
diff --git a/lib/ex_doc/doc_ast.ex b/lib/ex_doc/doc_ast.ex
index 375c670fa..969df04f7 100644
--- a/lib/ex_doc/doc_ast.ex
+++ b/lib/ex_doc/doc_ast.ex
@@ -27,7 +27,7 @@ defmodule ExDoc.DocAST do
     meta param source track wbr)a
 
   @doc """
-  Transform AST into string.
+  Transform AST into an HTML string.
   """
   def to_string(ast, fun \\ fn _ast, string -> string end)
 
@@ -64,6 +64,70 @@ defmodule ExDoc.DocAST do
     Enum.map(attrs, fn {key, val} -> " #{key}=\"#{val}\"" end)
   end
 
+  @doc """
+  Transform AST into a markdown string.
+  """
+  def to_markdown_string(ast, fun \\ fn _ast, string -> string end)
+
+  def to_markdown_string(binary, _fun) when is_binary(binary) do
+    ExDoc.Utils.h(binary)
+  end
+
+  def to_markdown_string(list, fun) when is_list(list) do
+    result = Enum.map_join(list, "", &to_markdown_string(&1, fun))
+    fun.(list, result)
+  end
+
+  def to_markdown_string({:comment, _attrs, inner, _meta} = ast, fun) do
+    fun.(ast, "<!--#{inner}-->")
+  end
+
+  def to_markdown_string({:code, _attrs, inner, _meta} = ast, fun) do
+    result = """
+    ```
+    #{inner}
+    ```
+    """
+
+    fun.(ast, result)
+  end
+
+  def to_markdown_string({:a, attrs, inner, _meta} = ast, fun) do
+    result = "[#{inner}](#{attrs[:href]})"
+    fun.(ast, result)
+  end
+
+  def to_markdown_string({:hr, _attrs, _inner, _meta} = ast, fun) do
+    result = "\n\n---\n\n"
+    fun.(ast, result)
+  end
+
+  def to_markdown_string({tag, _attrs, _inner, _meta} = ast, fun) when tag in [:p, :br] do
+    result = "\n\n"
+    fun.(ast, result)
+  end
+
+  def to_markdown_string({:img, attrs, _inner, _meta} = ast, fun) do
+    result = "![#{attrs[:alt]}](#{attrs[:src]} \"#{attrs[:title]}\")"
+    fun.(ast, result)
+  end
+
+  # ignoring these: area base col command embed input keygen link meta param source track wbr
+  def to_markdown_string({tag, _attrs, _inner, _meta} = ast, fun) when tag in @void_elements do
+    result = ""
+    fun.(ast, result)
+  end
+
+  def to_markdown_string({_tag, _attrs, inner, %{verbatim: true}} = ast, fun) do
+    result = Enum.join(inner, "")
+    fun.(ast, result)
+  end
+
+  def to_markdown_string({_tag, _attrs, inner, _meta} = ast, fun) do
+    result = to_string(inner, fun)
+    fun.(ast, result)
+  end
+
   ## parse markdown
 
   defp parse_markdown(markdown, opts) do
diff --git a/lib/ex_doc/formatter.ex b/lib/ex_doc/formatter.ex
new file mode 100644
index 000000000..9ffdd70c6
--- /dev/null
+++ b/lib/ex_doc/formatter.ex
@@ -0,0 +1,247 @@
+defmodule ExDoc.Formatter do
+  @moduledoc false
+
+  alias ExDoc.{Markdown, GroupMatcher, Utils}
+
+  @doc """
+  Autolinks and renders all docs.
+  """
+  def render_all(project_nodes, filtered_modules, ext, config, opts) do
+    base = [
+      apps: config.apps,
+      deps: config.deps,
+      ext: ext,
+      extras: extra_paths(config),
+      skip_undefined_reference_warnings_on: config.skip_undefined_reference_warnings_on,
+      skip_code_autolink_to: config.skip_code_autolink_to,
+      filtered_modules: filtered_modules
+    ]
+
+    project_nodes
+    |> Task.async_stream(
+      fn node ->
+        language = node.language
+
+        autolink_opts =
+          [
+            current_module: node.module,
+            file: node.moduledoc_file,
+            line: node.moduledoc_line,
+            module_id: node.id,
+            language: language
+          ] ++ base
+
+        docs =
+          for child_node <- node.docs do
+            id = id(node, child_node)
+
+            autolink_opts =
+              autolink_opts ++
+                [
+                  id: id,
+                  line: child_node.doc_line,
+                  file: child_node.doc_file,
+                  current_kfa: {child_node.type, child_node.name, child_node.arity}
+                ]
+
+            specs = Enum.map(child_node.specs, &language.autolink_spec(&1, autolink_opts))
+            child_node = %{child_node | specs: specs}
+            render_doc(child_node, ext, language, autolink_opts, opts)
+          end
+
+        %{
+          render_doc(node, ext, language, [{:id, node.id} | autolink_opts], opts)
+          | docs: docs
+        }
+      end,
+      timeout: :infinity
+    )
+    |> Enum.map(&elem(&1, 1))
+  end
+
+  defp render_doc(%{doc: nil} = node, _ext, _language, _autolink_opts, _opts),
+    do: node
+
+  defp render_doc(%{doc: doc} = node, ext, language, autolink_opts, opts) do
+    rendered = autolink_and_render(doc, ext, language, autolink_opts, opts)
+    %{node | rendered_doc: rendered}
+  end
+
+  defp id(%{id: mod_id}, %{id: "c:" <> id}) do
+    "c:" <> mod_id <> "." <> id
+  end
+
+  defp id(%{id: mod_id}, %{id: "t:" <> id}) do
+    "t:" <> mod_id <> "." <> id
+  end
+
+  defp id(%{id: mod_id}, %{id: id}) do
+    mod_id <> "." <> id
+  end
+
+  defp autolink_and_render(doc, ".md", language, autolink_opts, _opts) do
+    doc
+    |> language.autolink_doc(autolink_opts)
+    |> ExDoc.DocAST.to_markdown_string()
+  end
+
+  defp autolink_and_render(doc, _html_ext, language, autolink_opts, opts) do
+    doc
+    |> language.autolink_doc(autolink_opts)
+    |> ExDoc.DocAST.to_string()
+    |> ExDoc.DocAST.highlight(language, opts)
+  end
+
+  @doc """
+  Builds extra nodes by normalizing the config entries.
+  """
+  def build_extras(config, ext) do
+    groups = config.groups_for_extras
+
+    language =
+      case config.proglang do
+        :erlang -> ExDoc.Language.Erlang
+        _ -> ExDoc.Language.Elixir
+      end
+
+    source_url_pattern = config.source_url_pattern
+
+    autolink_opts = [
+      apps: config.apps,
+      deps: config.deps,
+      ext: ext,
+      extras: extra_paths(config),
+      language: language,
+      skip_undefined_reference_warnings_on: config.skip_undefined_reference_warnings_on,
+      skip_code_autolink_to: config.skip_code_autolink_to
+    ]
+
+    extras =
+      config.extras
+      |> Task.async_stream(
+        &build_extra(&1, groups, ext, language, autolink_opts, source_url_pattern),
+        timeout: :infinity
+      )
+      |> Enum.map(&elem(&1, 1))
+
+    ids_count = Enum.reduce(extras, %{}, &Map.update(&2, &1.id, 1, fn c -> c + 1 end))
+
+    extras
+    |> Enum.map_reduce(1, fn extra, idx ->
+      if ids_count[extra.id] > 1, do: {disambiguate_id(extra, idx), idx + 1}, else: {extra, idx}
+    end)
+    |> elem(0)
+    |> Enum.sort_by(fn extra -> GroupMatcher.index(groups, extra.group) end)
+  end
+
+  defp build_extra(
+         {input, input_options},
+         groups,
+         ext,
+         language,
+         autolink_opts,
+         source_url_pattern
+       ) do
+    input = to_string(input)
+    id = input_options[:filename] || input |> filename_to_title() |> Utils.text_to_id()
+    source_file = input_options[:source] || input
+    opts = [file: source_file, line: 1]
+
+    {source, ast} =
+      case extension_name(input) do
+        extension when extension in ["", ".txt"] ->
+          source = File.read!(input)
+          ast = [{:pre, [], "\n" <> source, %{}}]
+          {source, ast}
+
+        extension when extension in [".md", ".livemd", ".cheatmd"] ->
+          source = File.read!(input)
+
+          ast =
+            source
+            |> Markdown.to_ast(opts)
+            |> sectionize(extension)
+
+          {source, ast}
+
+        _ ->
+          raise ArgumentError,
+                "file extension not recognized, allowed extension is either .cheatmd, .livemd, .md, .txt or no extension"
+      end
+
+    {title_ast, ast} =
+      case ExDoc.DocAST.extract_title(ast) do
+        {:ok, title_ast, ast} -> {title_ast, ast}
+        :error -> {nil, ast}
+      end
+
+    title_text = title_ast && ExDoc.DocAST.text_from_ast(title_ast)
+    title_html = title_ast && ExDoc.DocAST.to_string(title_ast)
+    content_html = autolink_and_render(ast, ext, language, [file: input] ++ autolink_opts, opts)
+
+    group = GroupMatcher.match_extra(groups, input)
+    title = input_options[:title] || title_text || filename_to_title(input)
+
+    source_path = source_file |> Path.relative_to(File.cwd!()) |> String.replace_leading("./", "")
+    source_url = Utils.source_url_pattern(source_url_pattern, source_path, 1)
+
+    %{
+      source: source,
+      content: content_html,
+      group: group,
+      id: id,
+      source_path: source_path,
+      source_url: source_url,
+      title: title,
+      title_content: title_html || title
+    }
+  end
+
+  defp build_extra(input, groups, ext, language, autolink_opts, source_url_pattern) do
+    build_extra({input, []}, groups, ext, language, autolink_opts, source_url_pattern)
+  end
+
+  defp extra_paths(config) do
+    Map.new(config.extras, fn
+      path when is_binary(path) ->
+        base = Path.basename(path)
+        {base, Utils.text_to_id(Path.rootname(base))}
+
+      {path, opts} ->
+        base = path |> to_string() |> Path.basename()
+        {base, opts[:filename] || Utils.text_to_id(Path.rootname(base))}
+    end)
+  end
+
+  defp disambiguate_id(extra, discriminator) do
+    Map.put(extra, :id, "#{extra.id}-#{discriminator}")
+  end
+
+  defp sectionize(ast, ".cheatmd") do
+    ExDoc.DocAST.sectionize(ast, fn
+      {:h2, _, _, _} -> true
+      {:h3, _, _, _} -> true
+      _ -> false
+    end)
+  end
+
+  defp sectionize(ast, _), do: ast
+
+  defp filename_to_title(input) do
+    input |> Path.basename() |> Path.rootname()
+  end
+
+  def filter_list(:module, nodes) do
+    Enum.filter(nodes, &(&1.type != :task))
+  end
+
+  def filter_list(type, nodes) do
+    Enum.filter(nodes, &(&1.type == type))
+  end
+
+  def extension_name(input) do
+    input
+    |> Path.extname()
+    |> String.downcase()
+  end
+end
diff --git a/lib/ex_doc/formatter/epub.ex b/lib/ex_doc/formatter/epub.ex
index 338cc497e..606b046c7 100644
--- a/lib/ex_doc/formatter/epub.ex
+++ b/lib/ex_doc/formatter/epub.ex
@@ -4,6 +4,7 @@ defmodule ExDoc.Formatter.EPUB do
   @mimetype "application/epub+zip"
   @assets_dir "OEBPS/assets"
   alias __MODULE__.{Assets, Templates}
+  alias ExDoc.Formatter
   alias ExDoc.Formatter.HTML
   alias ExDoc.Utils
 
@@ -17,16 +18,18 @@ defmodule ExDoc.Formatter.EPUB do
     File.mkdir_p!(Path.join(config.output, "OEBPS"))
 
     project_nodes =
-      HTML.render_all(project_nodes, filtered_modules, ".xhtml", config, highlight_tag: "samp")
+      Formatter.render_all(project_nodes, filtered_modules, ".xhtml", config,
+        highlight_tag: "samp"
+      )
 
     nodes_map = %{
-      modules: HTML.filter_list(:module, project_nodes),
-      tasks: HTML.filter_list(:task, project_nodes)
+      modules: Formatter.filter_list(:module, project_nodes),
+      tasks: Formatter.filter_list(:task, project_nodes)
     }
 
     extras =
       config
-      |> HTML.build_extras(".xhtml")
+      |> Formatter.build_extras(".xhtml")
       |> Enum.chunk_by(& &1.group)
       |> Enum.map(&{hd(&1).group, &1})
 
diff --git a/lib/ex_doc/formatter/html.ex b/lib/ex_doc/formatter/html.ex
index 1f07edef0..32cb19f05 100644
--- a/lib/ex_doc/formatter/html.ex
+++ b/lib/ex_doc/formatter/html.ex
@@ -2,7 +2,7 @@ defmodule ExDoc.Formatter.HTML do
   @moduledoc false
 
   alias __MODULE__.{Assets, Templates, SearchData}
-  alias ExDoc.{Markdown, GroupMatcher, Utils}
+  alias ExDoc.{Formatter, Utils}
 
   @main "api-reference"
   @assets_dir "assets"
@@ -18,8 +18,8 @@ defmodule ExDoc.Formatter.HTML do
     build = Path.join(config.output, ".build")
     output_setup(build, config)
 
-    project_nodes = render_all(project_nodes, filtered_modules, ".html", config, [])
-    extras = build_extras(config, ".html")
+    project_nodes = Formatter.render_all(project_nodes, filtered_modules, ".html", config, [])
+    extras = Formatter.build_extras(config, ".html")
 
     # Generate search early on without api reference in extras
     static_files = generate_assets(".", default_assets(config), config)
@@ -27,8 +27,8 @@ defmodule ExDoc.Formatter.HTML do
 
     # TODO: Move this categorization to the language
     nodes_map = %{
-      modules: filter_list(:module, project_nodes),
-      tasks: filter_list(:task, project_nodes)
+      modules: Formatter.filter_list(:module, project_nodes),
+      tasks: Formatter.filter_list(:task, project_nodes)
     }
 
     extras =
@@ -63,89 +63,6 @@ defmodule ExDoc.Formatter.HTML do
     %{config | main: main || @main}
   end
 
-  @doc """
-  Autolinks and renders all docs.
-  """
-  def render_all(project_nodes, filtered_modules, ext, config, opts) do
-    base = [
-      apps: config.apps,
-      deps: config.deps,
-      ext: ext,
-      extras: extra_paths(config),
-      skip_undefined_reference_warnings_on: config.skip_undefined_reference_warnings_on,
-      skip_code_autolink_to: config.skip_code_autolink_to,
-      filtered_modules: filtered_modules
-    ]
-
-    project_nodes
-    |> Task.async_stream(
-      fn node ->
-        language = node.language
-
-        autolink_opts =
-          [
-            current_module: node.module,
-            file: node.moduledoc_file,
-            line: node.moduledoc_line,
-            module_id: node.id,
-            language: language
-          ] ++ base
-
-        docs =
-          for child_node <- node.docs do
-            id = id(node, child_node)
-
-            autolink_opts =
-              autolink_opts ++
-                [
-                  id: id,
-                  line: child_node.doc_line,
-                  file: child_node.doc_file,
-                  current_kfa: {child_node.type, child_node.name, child_node.arity}
-                ]
-
-            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)
-          end
-
-        %{
-          render_doc(node, language, [{:id, node.id} | autolink_opts], opts)
-          | docs: docs
-        }
-      end,
-      timeout: :infinity
-    )
-    |> Enum.map(&elem(&1, 1))
-  end
-
-  defp render_doc(%{doc: nil} = node, _language, _autolink_opts, _opts),
-    do: node
-
-  defp render_doc(%{doc: doc} = node, language, autolink_opts, opts) do
-    rendered = autolink_and_render(doc, language, autolink_opts, opts)
-    %{node | rendered_doc: rendered}
-  end
-
-  defp id(%{id: mod_id}, %{id: "c:" <> id}) do
-    "c:" <> mod_id <> "." <> id
-  end
-
-  defp id(%{id: mod_id}, %{id: "t:" <> id}) do
-    "t:" <> mod_id <> "." <> id
-  end
-
-  defp id(%{id: mod_id}, %{id: id}) do
-    mod_id <> "." <> id
-  end
-
-  defp autolink_and_render(doc, language, autolink_opts, opts) do
-    doc
-    |> language.autolink_doc(autolink_opts)
-    |> ExDoc.DocAST.to_string()
-    |> ExDoc.DocAST.highlight(language, opts)
-  end
-
   defp output_setup(build, config) do
     if File.exists?(build) do
       build
@@ -237,7 +154,7 @@ defmodule ExDoc.Formatter.HTML do
 
   defp copy_extras(config, extras) do
     for %{source_path: source_path, id: id} when source_path != nil <- extras,
-        ext = extension_name(source_path),
+        ext = Formatter.extension_name(source_path),
         ext == ".livemd" do
       output = "#{config.output}/#{id}#{ext}"
 
@@ -320,48 +237,6 @@ defmodule ExDoc.Formatter.HTML do
     }
   end
 
-  @doc """
-  Builds extra nodes by normalizing the config entries.
-  """
-  def build_extras(config, ext) do
-    groups = config.groups_for_extras
-
-    language =
-      case config.proglang do
-        :erlang -> ExDoc.Language.Erlang
-        _ -> ExDoc.Language.Elixir
-      end
-
-    source_url_pattern = config.source_url_pattern
-
-    autolink_opts = [
-      apps: config.apps,
-      deps: config.deps,
-      ext: ext,
-      extras: extra_paths(config),
-      language: language,
-      skip_undefined_reference_warnings_on: config.skip_undefined_reference_warnings_on,
-      skip_code_autolink_to: config.skip_code_autolink_to
-    ]
-
-    extras =
-      config.extras
-      |> Task.async_stream(
-        &build_extra(&1, groups, language, autolink_opts, source_url_pattern),
-        timeout: :infinity
-      )
-      |> Enum.map(&elem(&1, 1))
-
-    ids_count = Enum.reduce(extras, %{}, &Map.update(&2, &1.id, 1, fn c -> c + 1 end))
-
-    extras
-    |> Enum.map_reduce(1, fn extra, idx ->
-      if ids_count[extra.id] > 1, do: {disambiguate_id(extra, idx), idx + 1}, else: {extra, idx}
-    end)
-    |> elem(0)
-    |> Enum.sort_by(fn extra -> GroupMatcher.index(groups, extra.group) end)
-  end
-
   def generate_redirects(config, ext) do
     config.redirects
     |> Map.new()
@@ -381,90 +256,6 @@ defmodule ExDoc.Formatter.HTML do
     end)
   end
 
-  defp disambiguate_id(extra, discriminator) do
-    Map.put(extra, :id, "#{extra.id}-#{discriminator}")
-  end
-
-  defp build_extra({input, input_options}, groups, language, autolink_opts, source_url_pattern) do
-    input = to_string(input)
-    id = input_options[:filename] || input |> filename_to_title() |> Utils.text_to_id()
-    source_file = input_options[:source] || input
-    opts = [file: source_file, line: 1]
-
-    {source, ast} =
-      case extension_name(input) do
-        extension when extension in ["", ".txt"] ->
-          source = File.read!(input)
-          ast = [{:pre, [], "\n" <> source, %{}}]
-          {source, ast}
-
-        extension when extension in [".md", ".livemd", ".cheatmd"] ->
-          source = File.read!(input)
-
-          ast =
-            source
-            |> Markdown.to_ast(opts)
-            |> sectionize(extension)
-
-          {source, ast}
-
-        _ ->
-          raise ArgumentError,
-                "file extension not recognized, allowed extension is either .cheatmd, .livemd, .md, .txt or no extension"
-      end
-
-    {title_ast, ast} =
-      case ExDoc.DocAST.extract_title(ast) do
-        {:ok, title_ast, ast} -> {title_ast, ast}
-        :error -> {nil, ast}
-      end
-
-    title_text = title_ast && ExDoc.DocAST.text_from_ast(title_ast)
-    title_html = title_ast && ExDoc.DocAST.to_string(title_ast)
-    content_html = autolink_and_render(ast, language, [file: input] ++ autolink_opts, opts)
-
-    group = GroupMatcher.match_extra(groups, input)
-    title = input_options[:title] || title_text || filename_to_title(input)
-
-    source_path = source_file |> Path.relative_to(File.cwd!()) |> String.replace_leading("./", "")
-    source_url = Utils.source_url_pattern(source_url_pattern, source_path, 1)
-
-    %{
-      source: source,
-      content: content_html,
-      group: group,
-      id: id,
-      source_path: source_path,
-      source_url: source_url,
-      title: title,
-      title_content: title_html || title
-    }
-  end
-
-  defp build_extra(input, groups, language, autolink_opts, source_url_pattern) do
-    build_extra({input, []}, groups, language, autolink_opts, source_url_pattern)
-  end
-
-  defp extension_name(input) do
-    input
-    |> Path.extname()
-    |> String.downcase()
-  end
-
-  defp sectionize(ast, ".cheatmd") do
-    ExDoc.DocAST.sectionize(ast, fn
-      {:h2, _, _, _} -> true
-      {:h3, _, _, _} -> true
-      _ -> false
-    end)
-  end
-
-  defp sectionize(ast, _), do: ast
-
-  defp filename_to_title(input) do
-    input |> Path.basename() |> Path.rootname()
-  end
-
   @doc """
   Generates the logo from config into the given directory.
   """
@@ -522,14 +313,6 @@ defmodule ExDoc.Formatter.HTML do
     end
   end
 
-  def filter_list(:module, nodes) do
-    Enum.filter(nodes, &(&1.type != :task))
-  end
-
-  def filter_list(type, nodes) do
-    Enum.filter(nodes, &(&1.type == type))
-  end
-
   defp generate_list(nodes, nodes_map, config) do
     nodes
     |> Task.async_stream(&generate_module_page(&1, nodes_map, config), timeout: :infinity)
@@ -556,16 +339,4 @@ defmodule ExDoc.Formatter.HTML do
       config
     end
   end
-
-  defp extra_paths(config) do
-    Map.new(config.extras, fn
-      path when is_binary(path) ->
-        base = Path.basename(path)
-        {base, Utils.text_to_id(Path.rootname(base))}
-
-      {path, opts} ->
-        base = path |> to_string() |> Path.basename()
-        {base, opts[:filename] || Utils.text_to_id(Path.rootname(base))}
-    end)
-  end
 end
diff --git a/lib/ex_doc/formatter/html/templates.ex b/lib/ex_doc/formatter/html/templates.ex
index 72407b672..235e441f1 100644
--- a/lib/ex_doc/formatter/html/templates.ex
+++ b/lib/ex_doc/formatter/html/templates.ex
@@ -64,7 +64,10 @@ defmodule ExDoc.Formatter.HTML.Templates do
     Regex.replace(~r|(<[^>]*) id="[^"]*"([^>]*>)|, doc, ~S"\1\2", [])
   end
 
-  defp enc(binary), do: URI.encode(binary)
+  defp presence([]), do: nil
+  defp presence(other), do: other
+
+  def enc(binary), do: URI.encode(binary)
 
   @doc """
   Create a JS object which holds all the items displayed in the sidebar area
@@ -206,6 +209,21 @@ defmodule ExDoc.Formatter.HTML.Templates do
 
   defp relative_asset([h | _], output, _pattern), do: Path.relative_to(h, output)
 
+  defp get_hex_url(config, source_path) do
+    case config.package do
+      nil ->
+        nil
+
+      package ->
+        base_url = "https://preview.hex.pm/preview/#{package}/#{config.version}"
+        if source_path, do: "#{base_url}/show/#{source_path}", else: base_url
+    end
+  end
+
+  defp get_markdown_path(node) do
+    if node && node.id, do: URI.encode(node.id), else: "index"
+  end
+
   # TODO: Move link_headings and friends to html.ex or even to autolinking code,
   # so content is built with it upfront instead of added at the template level.
 
diff --git a/lib/ex_doc/formatter/html/templates/footer_template.eex b/lib/ex_doc/formatter/html/templates/footer_template.eex
index 5488a0212..b9feb54ef 100644
--- a/lib/ex_doc/formatter/html/templates/footer_template.eex
+++ b/lib/ex_doc/formatter/html/templates/footer_template.eex
@@ -1,27 +1,43 @@
     <footer class="footer">
       <p>
-        <%= if config.package do %>
-          <span class="line">
+        <span class="line">
+
+          <%= if config.package do %>
             <a href="https://hex.pm/packages/<%= config.package %>/<%= config.version %>" class="footer-hex-package">Hex Package</a>
+          <% end %>
 
-            <a href="https://preview.hex.pm/preview/<%= config.package %>/<%= config.version %>">Hex Preview</a>
+          <%
+            hex_url = get_hex_url(config, node && (Map.get(node, :source_path) || Map.get(node, :moduledoc_file)))
+            source_url = node && node.source_url
+          %>
+          <%= if hex_url || source_url do %>
+            View Code:
+            <%= if source_url do %>
+              <a href="<%= source_url %>" title="View Source Code" class="footer-button">Source Repo</a>
+            <% end %>
 
-            <%= source_path = node && Map.get(node, :source_path); if source_path do %>
-              (<a href="https://preview.hex.pm/preview/<%= config.package %>/<%= config.version %>/show/<%= source_path %>">current file</a>)
+            <%= if hex_url do %>
+              <a href="<%= hex_url %>" class="footer-button">Hex Preview</a>
             <% end %>
-          </span>
-        <% end %>
+          <% end %>
+
+          <%= if "markdown" in config.formatters do %>
+            <a href="./markdown/<%= get_markdown_path(node) %>.md" title="Markdown version" class="footer-button">
+              View Markdown version
+            </a>
+          <% end %>
+
+          <%= if config.package do %>
+            <a href="https://repo.hex.pm/docs/<%= config.package %>-<%= config.version %>.tar.gz" title="Archive containing docs in all available formats" class="footer-button">
+              Download docs archive
+            </a>
+          <% end %>
+
 
-        <span class="line">
           <button class="a-main footer-button display-quick-switch" title="Search HexDocs packages">
             Search HexDocs
           </button>
 
-          <%= if "epub" in config.formatters do %>
-            <a href="<%= config.project %>.epub" title="ePub version">
-              Download ePub version
-            </a>
-          <% end %>
         </span>
       </p>
 
diff --git a/lib/ex_doc/formatter/html/templates/module_template.eex b/lib/ex_doc/formatter/html/templates/module_template.eex
index b509f167b..e8c7e1ad2 100644
--- a/lib/ex_doc/formatter/html/templates/module_template.eex
+++ b/lib/ex_doc/formatter/html/templates/module_template.eex
@@ -9,6 +9,7 @@
         <span class="sr-only">View Source</span>
       </a>
     <% end %>
+
     <span translate="no"><%= module.title %></span> <%= module_type(module) %>
     <small class="app-vsn" translate="no">(<%= config.project %> v<%= config.version %>)</small>
     <%= for annotation <- module.annotations do %>
diff --git a/lib/ex_doc/formatter/markdown.ex b/lib/ex_doc/formatter/markdown.ex
new file mode 100644
index 000000000..10fd19514
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown.ex
@@ -0,0 +1,102 @@
+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)
+
+    project_nodes =
+      project_nodes
+      # |> Enum.map(&elem(&1, 1))
+      |> 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)
+    }
+
+    extras =
+      config
+      |> Formatter.build_extras(".md")
+      |> Enum.chunk_by(& &1.group)
+      |> Enum.map(&{hd(&1).group, &1})
+
+    config = %{config | extras: extras}
+
+    generate_nav(config, nodes_map)
+    generate_extras(config)
+    generate_list(config, nodes_map.modules)
+    generate_list(config, nodes_map.tasks)
+
+    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|\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
+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..a34d489df
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates.ex
@@ -0,0 +1,137 @@
+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]
+
+  alias ExDoc.Formatter.HTML.Templates, as: H
+
+  @doc """
+  Generate content from the module template for a given `node`
+  """
+  def module_page(config, module_node) do
+    summary = H.module_summary(module_node)
+    module_template(config, module_node, summary)
+  end
+
+  @doc """
+  Returns the formatted title for the module page.
+  """
+  def module_type(%{type: :task}), do: ""
+  def module_type(%{type: :module}), do: ""
+  def module_type(%{type: type}), do: "(#{type})"
+
+  @doc """
+  Generated ID for static file
+  """
+  def static_file_to_id(static_file) do
+    static_file |> Path.basename() |> text_to_id()
+  end
+
+  def node_doc(%{source_doc: %{"en" => source}}), do: source
+  def node_doc(%{rendered_doc: source}), do: source
+
+  @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, ": ") <> "\n\n"
+      [all] -> all
+    end
+  end
+
+  def synopsis(_), do: nil
+
+  @heading_regex ~r/^(\#{1,6})\s+(.*)/m
+  defp rewrite_headings(content) when is_binary(content) do
+    @heading_regex
+    |> 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..7529996c8
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates/detail_template.eex
@@ -0,0 +1,15 @@
+<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 %> 
+> <%= H.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..c21285350
--- /dev/null
+++ b/lib/ex_doc/formatter/markdown/templates/module_template.eex
@@ -0,0 +1,36 @@
+# <%= 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..48f11c99a
--- /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..7d8ffcb7b
--- /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 doc = node_doc(node) do %>
+<%= synopsis(doc) %>
+<% end %>
+
+<% end %>
diff --git a/lib/ex_doc/language/elixir.ex b/lib/ex_doc/language/elixir.ex
index 2600849cc..5ed9c1743 100644
--- a/lib/ex_doc/language/elixir.ex
+++ b/lib/ex_doc/language/elixir.ex
@@ -289,7 +289,7 @@ defmodule ExDoc.Language.Elixir do
         {:local, :..}
 
       ["//", "", ""] ->
-        {:local, :"..//"}
+        {:local, :..//}
 
       ["", ""] ->
         {:local, :.}
@@ -699,7 +699,11 @@ defmodule ExDoc.Language.Elixir do
         end
 
       if url do
-        ~s[<a href="#{url}">#{ExDoc.Utils.h(call_string)}</a>]
+        if config.ext == ".md" do
+          ~s[\[#{ExDoc.Utils.h(call_string)}\](#{url})]
+        else
+          ~s[<a href="#{url}">#{ExDoc.Utils.h(call_string)}</a>]
+        end
       else
         call_string
       end <> do_typespec(rest, config)
diff --git a/lib/ex_doc/language/erlang.ex b/lib/ex_doc/language/erlang.ex
index 5ed3ded85..5d94c9239 100644
--- a/lib/ex_doc/language/erlang.ex
+++ b/lib/ex_doc/language/erlang.ex
@@ -695,7 +695,11 @@ defmodule ExDoc.Language.Erlang do
         end
 
       if url do
-        ~s|<a href="#{url}">#{string}</a>(|
+        if config.ext == ".md" do
+          ~s|[#{string}\](#{url})(|
+        else
+          ~s|<a href="#{url}">#{string}</a>(|
+        end
       else
         string <> "("
       end
diff --git a/test/ex_doc/formatter/epub/templates_test.exs b/test/ex_doc/formatter/epub/templates_test.exs
index 9b387a8e0..0580586b1 100644
--- a/test/ex_doc/formatter/epub/templates_test.exs
+++ b/test/ex_doc/formatter/epub/templates_test.exs
@@ -1,7 +1,6 @@
 defmodule ExDoc.Formatter.EPUB.TemplatesTest do
   use ExUnit.Case, async: true
 
-  alias ExDoc.Formatter.HTML
   alias ExDoc.Formatter.EPUB.Templates
 
   defp source_url do
@@ -28,7 +27,7 @@ defmodule ExDoc.Formatter.EPUB.TemplatesTest do
   defp get_module_page(names, config \\ []) do
     config = doc_config(config)
     {mods, []} = ExDoc.Retriever.docs_from_modules(names, config)
-    [mod | _] = HTML.render_all(mods, [], ".xhtml", config, highlight_tag: "samp")
+    [mod | _] = ExDoc.Formatter.render_all(mods, [], ".xhtml", config, highlight_tag: "samp")
     Templates.module_page(config, mod)
   end
 
diff --git a/test/ex_doc/formatter/html/templates_test.exs b/test/ex_doc/formatter/html/templates_test.exs
index 970e8431a..4c72d50ea 100644
--- a/test/ex_doc/formatter/html/templates_test.exs
+++ b/test/ex_doc/formatter/html/templates_test.exs
@@ -1,7 +1,6 @@
 defmodule ExDoc.Formatter.HTML.TemplatesTest do
   use ExUnit.Case, async: true
 
-  alias ExDoc.Formatter.HTML
   alias ExDoc.Formatter.HTML.Templates
 
   @moduletag :tmp_dir
@@ -32,7 +31,7 @@ defmodule ExDoc.Formatter.HTML.TemplatesTest do
   defp get_module_page(names, context, config \\ []) do
     config = doc_config(context, config)
     {mods, []} = ExDoc.Retriever.docs_from_modules(names, config)
-    [mod | _] = HTML.render_all(mods, [], ".html", config, [])
+    [mod | _] = ExDoc.Formatter.render_all(mods, [], ".html", config, [])
     Templates.module_page(mod, @empty_nodes_map, config)
   end
 
@@ -428,7 +427,7 @@ defmodule ExDoc.Formatter.HTML.TemplatesTest do
       names = [CompiledWithDocs, CompiledWithoutDocs, DuplicateHeadings]
       config = doc_config(context)
       {nodes, []} = ExDoc.Retriever.docs_from_modules(names, config)
-      nodes = HTML.render_all(nodes, [], ".html", config, [])
+      nodes = ExDoc.Formatter.render_all(nodes, [], ".html", config, [])
 
       [compiled_with_docs, compiled_without_docs, duplicate_headings] =
         create_sidebar_items(%{modules: nodes}, [])["modules"]
diff --git a/test/ex_doc/formatter/markdown/templates_test.exs b/test/ex_doc/formatter/markdown/templates_test.exs
new file mode 100644
index 000000000..0a442ed4e
--- /dev/null
+++ b/test/ex_doc/formatter/markdown/templates_test.exs
@@ -0,0 +1,122 @@
+defmodule ExDoc.Formatter.MARKDOWN.TemplatesTest do
+  use ExUnit.Case, async: true
+
+  alias ExDoc.Formatter.MARKDOWN.Templates
+
+  defp source_url do
+    "https://github.com/elixir-lang/elixir"
+  end
+
+  defp homepage_url do
+    "https://elixir-lang.org"
+  end
+
+  defp doc_config(config \\ []) do
+    default = %ExDoc.Config{
+      project: "Elixir",
+      version: "1.0.1",
+      source_url_pattern: "#{source_url()}/blob/master/%{path}#L%{line}",
+      homepage_url: homepage_url(),
+      source_url: source_url(),
+      output: "test/tmp/markdown_templates"
+    }
+
+    struct(default, config)
+  end
+
+  defp get_module_page(names, config \\ []) do
+    config = doc_config(config)
+    {mods, []} = ExDoc.Retriever.docs_from_modules(names, config)
+    [mod | _] = ExDoc.Formatter.render_all(mods, [], ".md", config, highlight_tag: "samp")
+    Templates.module_page(config, mod)
+  end
+
+  setup_all do
+    # File.mkdir_p!("test/tmp/markdown_templates")
+    # File.cp_r!("formatters/markdown", "test/tmp/markdown_templates")
+    :ok
+  end
+
+  describe "module_page/2" do
+    test "generates only the module name when there's no more info" do
+      module_node = %ExDoc.ModuleNode{
+        module: XPTOModule,
+        doc: nil,
+        id: "XPTOModule",
+        title: "XPTOModule"
+      }
+
+      content = Templates.module_page(doc_config(), module_node)
+
+      assert content =~ ~r{#\s*XPTOModule\s*}
+    end
+
+    test "outputs the functions and docstrings" do
+      content = get_module_page([CompiledWithDocs])
+
+      assert content =~ ~r{#\s*CompiledWithDocs\s*}
+
+      assert content =~ ~s{## Table of Contents}
+
+      assert content =~
+               ~r{\n## .*Example.*}ms
+
+      assert content =~
+               ~r{\n### .*Example H3 heading.*}ms
+
+      assert content =~
+               ~r{moduledoc.*Example.*CompiledWithDocs\.example.*}ms
+
+      assert content =~ ~r{Some example}ms
+      assert content =~ ~r{example_without_docs().*}ms
+      assert content =~ ~r{example_1().* \(macro\)}ms
+
+      assert content =~ ~s{example(foo, bar \\\\ Baz)}
+    end
+
+    test "outputs function groups" do
+      content =
+        get_module_page([CompiledWithDocs],
+          groups_for_docs: [
+            "Example functions": &(&1[:purpose] == :example),
+            Legacy: &is_binary(&1[:deprecated])
+          ]
+        )
+
+      assert content =~ ~r{.*Example functions}ms
+      assert content =~ ~r{.*Legacy}ms
+    end
+
+    ## BEHAVIOURS
+
+    test "outputs behavior and callbacks" do
+      content = get_module_page([CustomBehaviourOne])
+
+      assert content =~
+               ~r{# CustomBehaviourOne \(behaviour\)}m
+
+      assert content =~ ~r{Callbacks}
+
+      content = get_module_page([CustomBehaviourTwo])
+
+      assert content =~
+               ~r{# CustomBehaviourTwo \(behaviour\)}m
+
+      assert content =~ ~r{Callbacks}
+    end
+
+    ## PROTOCOLS
+
+    test "outputs the protocol type" do
+      content = get_module_page([CustomProtocol])
+      assert content =~ ~r{# CustomProtocol \(protocol\)}m
+    end
+
+    ## TASKS
+
+    test "outputs the task type" do
+      content = get_module_page([Mix.Tasks.TaskWithDocs])
+      assert content =~ ~r{#\s*mix task_with_docs}m
+    end
+  end
+end
diff --git a/test/ex_doc/formatter/markdown_test.exs b/test/ex_doc/formatter/markdown_test.exs
new file mode 100644
index 000000000..99ae3d7f4
--- /dev/null
+++ b/test/ex_doc/formatter/markdown_test.exs
@@ -0,0 +1,77 @@
+defmodule ExDoc.Formatter.MARKDOWNTest do
+  use ExUnit.Case, async: false
+
+  @moduletag :tmp_dir
+
+  @before_closing_body_tag_content_md "UNIQUE:<dont-escape>&copy;BEFORE-CLOSING-BODY-TAG-HTML</dont-escape>"
+
+  defp before_closing_body_tag(:markdown), do: @before_closing_body_tag_content_md
+
+  def before_closing_body_tag(:markdown, name), do: "#{name}"
+
+  defp doc_config(%{tmp_dir: tmp_dir} = _context) do
+    [
+      app: :elixir,
+      project: "Elixir",
+      version: "1.0.1",
+      formatter: "markdown",
+      output: tmp_dir,
+      source_beam: "test/tmp/beam",
+      extras: ["test/fixtures/README.md"],
+      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
+
+  defp generate_docs(_context, config) do
+    generate_docs(config)
+  end
+
+  test "generates a markdown index file in the default directory",
+       %{tmp_dir: tmp_dir} = context do
+    generate_docs(doc_config(context))
+    assert File.regular?(tmp_dir <> "/markdown/index.md")
+  end
+
+  test "generates a markdown file with erlang as proglang", %{tmp_dir: tmp_dir} = context do
+    config =
+      context
+      |> doc_config()
+      |> Keyword.put(:proglang, :erlang)
+      |> Keyword.update!(:skip_undefined_reference_warnings_on, &["test/fixtures/README.md" | &1])
+
+    generate_docs(config)
+    assert File.regular?(tmp_dir <> "/markdown/index.md")
+  end
+
+  test "generates a markdown file in specified output directory", %{tmp_dir: tmp_dir} = context do
+    config = doc_config(context, output: tmp_dir <> "/another_dir", main: "RandomError")
+    generate_docs(config)
+
+    assert File.regular?(tmp_dir <> "/another_dir/markdown/index.md")
+  end
+
+  test "generates the readme file", %{tmp_dir: tmp_dir} = context do
+    config = doc_config(context, main: "README")
+    generate_docs(context, config)
+
+    content = File.read!(tmp_dir <> "/markdown/readme.md")
+    assert content =~ ~r{`RandomError`\n}
+
+    assert content =~
+             ~r{\n`CustomBehaviourImpl.hello/1`\n}
+
+    assert content =~
+             ~r{\n`TypesAndSpecs.Sub`\n}
+
+    content = File.read!(tmp_dir <> "/markdown/index.md")
+    assert content =~ "Table of contents\n\n  - [README](readme.md)"
+  end
+end