diff --git a/.gitignore b/.gitignore
index 79a9324..b1189f9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@
 build/
 gradle/
 lib/
+out
diff --git a/build.gradle.kts b/build.gradle.kts
index 61ec8d0..ce2e509 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -9,7 +9,7 @@ plugins {
 }
 
 group = "com.virtuslab.dokka"
-version = "0.1.1"
+version = "0.1.3-SNAPSHOT"
 
 tasks.withType(KotlinCompile::class).all {
     val language_version: String by project
@@ -34,11 +34,12 @@ dependencies {
     implementation("org.jetbrains.dokka:dokka-base:$dokka_version")
     implementation("com.vladsch.flexmark:flexmark-all:0.42.12")
     implementation("nl.big-o:liqp:0.6.7")
-    implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
+    implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.7.2")
 
     implementation("junit:junit:4.13")
 
     dokkaHtmlPlugin(project(":"))
+    testImplementation("org.jetbrains.dokka:dokka-core:$dokka_version")
 }
 
 // Gradle metadata
@@ -83,5 +84,5 @@ publishing {
 
 // Configure dokka
 tasks.dokkaHtml {
-    pluginsConfiguration += "ExternalDocsTooKey" to "documentation"
+    pluginsConfiguration.put("ExternalDocsTooKey",  "documentation")
 }
diff --git a/documentation/_layouts/vl_html_layout.html b/documentation/_layouts/vl_html_layout.html
new file mode 100644
index 0000000..0750c7b
--- /dev/null
+++ b/documentation/_layouts/vl_html_layout.html
@@ -0,0 +1,7 @@
+<header>
+    Powered by <a href="https://www.virtuslab.com/">VirtusLab</a>
+</header>
+
+<div>
+    {{ content }}
+</div>
diff --git a/documentation/docs/static-page/links.md b/documentation/docs/static-page/links.md
new file mode 100644
index 0000000..f48706f
--- /dev/null
+++ b/documentation/docs/static-page/links.md
@@ -0,0 +1,12 @@
+---
+layout: vl_header
+title: Links
+---
+
+## Links
+
+Our side supports stadnard markdown links:
+ - TODO Using standard [urls](https://pl.wikipedia.org/wiki/Uniform_Resource_Locator)
+ - TODO To [other pages](/docs/static-page/random.html) (or [md base file](/docs/static-page/tables.md)) in our documentation that using paths relative to root od documentation e.g. `/docs/static-page/random.html` for this project
+ - TODO To [other pages](/docs/static-page/samples/random.html) (or [md base file](samples/tables.md)) in our documentation that using paths relative to this file e.g. using `random.html` (or `tables.md`)
+ - TODO To API using `[fully.quallifty.Name]`  
diff --git a/documentation/docs/static-page/random.html b/documentation/docs/static-page/random.md
similarity index 62%
rename from documentation/docs/static-page/random.html
rename to documentation/docs/static-page/random.md
index fe04218..53ae26c 100644
--- a/documentation/docs/static-page/random.html
+++ b/documentation/docs/static-page/random.md
@@ -1,6 +1,6 @@
 ---
 layout: vl_header
-title: Sample html page
+title: Sample md page
 ---
 
 Hello world!
diff --git a/documentation/docs/static-page/samples/html_template.md b/documentation/docs/static-page/samples/html_template.md
new file mode 100644
index 0000000..caebc52
--- /dev/null
+++ b/documentation/docs/static-page/samples/html_template.md
@@ -0,0 +1,6 @@
+---
+layout: vl_html_layout
+title: Use Html template
+---
+
+## Test 123
diff --git a/documentation/docs/static-page/samples/index.md b/documentation/docs/static-page/samples/index.md
new file mode 100644
index 0000000..e4eaa86
--- /dev/null
+++ b/documentation/docs/static-page/samples/index.md
@@ -0,0 +1,6 @@
+---
+layout: vl_header
+title: Samples
+---
+
+Samples for our **plugin**
diff --git a/documentation/docs/static-page/samples/no_md_nor_html.txt b/documentation/docs/static-page/samples/no_md_nor_html.txt
new file mode 100644
index 0000000..f8e130c
--- /dev/null
+++ b/documentation/docs/static-page/samples/no_md_nor_html.txt
@@ -0,0 +1 @@
+I am text file!
diff --git a/documentation/docs/static-page/samples/plainFramelessHtmlIndex/index.html b/documentation/docs/static-page/samples/plainFramelessHtmlIndex/index.html
new file mode 100644
index 0000000..0a097cc
--- /dev/null
+++ b/documentation/docs/static-page/samples/plainFramelessHtmlIndex/index.html
@@ -0,0 +1,4 @@
+---
+hasFrame: false
+---
+<h1>No frame!</h1>
diff --git a/documentation/docs/static-page/samples/plainHtmlIndexFile/index.html b/documentation/docs/static-page/samples/plainHtmlIndexFile/index.html
new file mode 100644
index 0000000..7f86bfe
--- /dev/null
+++ b/documentation/docs/static-page/samples/plainHtmlIndexFile/index.html
@@ -0,0 +1 @@
+<h1>Plain html file</h1>
diff --git a/documentation/docs/static-page/samples/plainIndexFile/index.md b/documentation/docs/static-page/samples/plainIndexFile/index.md
new file mode 100644
index 0000000..8dafe72
--- /dev/null
+++ b/documentation/docs/static-page/samples/plainIndexFile/index.md
@@ -0,0 +1 @@
+## Plain file
diff --git a/documentation/docs/static-page/samples/plain_html_file.html b/documentation/docs/static-page/samples/plain_html_file.html
new file mode 100644
index 0000000..7cbf949
--- /dev/null
+++ b/documentation/docs/static-page/samples/plain_html_file.html
@@ -0,0 +1 @@
+<h1>Plain Html file</h1>
diff --git a/documentation/docs/static-page/samples/plain_md_file.md b/documentation/docs/static-page/samples/plain_md_file.md
new file mode 100644
index 0000000..5f509bb
--- /dev/null
+++ b/documentation/docs/static-page/samples/plain_md_file.md
@@ -0,0 +1 @@
+# Plain Md file
diff --git a/documentation/docs/static-page/samples/tables.md b/documentation/docs/static-page/samples/tables.md
new file mode 100644
index 0000000..06e395a
--- /dev/null
+++ b/documentation/docs/static-page/samples/tables.md
@@ -0,0 +1,21 @@
+---
+layout: vl_html_layout
+title: Tables
+---
+
+## Tables
+
+
+Some random table (to show how we render it).
+
+## SBT Commands Cheat Sheet ##
+The basics of working with Dotty codebase are documented [here](https://dotty.epfl.ch/docs/contributing/getting-started.html) and [here](https://dotty.epfl.ch/docs/contributing/workflow.html). Below is a cheat sheet of some frequently used commands (to be used from SBT console – `sbt`).
+
+
+|                        Command                       |                                                          Description                                                          |
+| ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `dotc ../issues/Playground.scala`                    | Compile the given file – path relative to the Dotty directory. Output the compiled class files to the Dotty directory itself. |
+| `dotr Playground`                                    | Run the compiled class `Playground`. Dotty directory is on classpath by default.                                              |
+| `repl`                                               | Start REPL                                                                                                                    |
+| `testOnly dotty.tools.dotc.CompilationTests -- *pos` | Run test (method) `pos` from `CompilationTests` suite.                                                                        |
+| `testCompilation sample`                             | In all test suites, run test files containing the word `sample` in their title.                                               |
diff --git a/documentation/index.md b/documentation/index.md
index 2445cca..b5a4d39 100644
--- a/documentation/index.md
+++ b/documentation/index.md
@@ -8,7 +8,7 @@ layout: vl_header
 
 **Yes, this page was generated using dokka-site**
 
-You can learn more from out [documentation](dokka-site/index.html).
+You can learn more from our [documentation](dokka-site/index.html).
 
 ## Getting started
 
diff --git a/gradle.properties b/gradle.properties
index 8011222..42a1667 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,6 +1,6 @@
 kotlin.code.style=official
 
-kotlin_version=1.4-M3
-dokka_version=1.4.0-rc
+kotlin_version=1.4.0
+dokka_version=1.4.0
 
 language_version=1.4
diff --git a/settings.gradle.kts b/settings.gradle.kts
index a43f0bc..6d524ac 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -17,5 +17,6 @@ pluginManagement {
         mavenCentral()
         jcenter()
         gradlePluginPortal()
+        mavenLocal()
     }
 }
diff --git a/src/main/kotlin/com/virtuslab/dokka/site/StaticSitePlugin.kt b/src/main/kotlin/com/virtuslab/dokka/site/StaticSitePlugin.kt
index 469977a..4f984db 100644
--- a/src/main/kotlin/com/virtuslab/dokka/site/StaticSitePlugin.kt
+++ b/src/main/kotlin/com/virtuslab/dokka/site/StaticSitePlugin.kt
@@ -27,7 +27,7 @@ class StaticSitePlugin : DokkaPlugin() {
 
     val customRenderer by extending {
         (CoreExtensions.renderer
-                providing { ctx -> ExternalDocsToolRenderer(ctx) }
+                providing { ctx -> RendererDispatcher(ctx) }
                 override dokkaBase.htmlRenderer)
     }
 
diff --git a/src/main/kotlin/com/virtuslab/dokka/site/contentNodes.kt b/src/main/kotlin/com/virtuslab/dokka/site/contentNodes.kt
new file mode 100644
index 0000000..092eb68
--- /dev/null
+++ b/src/main/kotlin/com/virtuslab/dokka/site/contentNodes.kt
@@ -0,0 +1,26 @@
+package com.virtuslab.dokka.site
+
+import org.jetbrains.dokka.model.DisplaySourceSet
+import org.jetbrains.dokka.model.properties.PropertyContainer
+import org.jetbrains.dokka.pages.*
+
+data class PartiallyRenderedContent(
+    val page: PreResolvedPage,
+    override val children: List<ContentNode>,
+    override val dci: DCI,
+    override val sourceSets: Set<DisplaySourceSet>,
+    override val style: Set<Style> = emptySet(),
+    override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
+) : ContentNode {
+    override fun hasAnyContent(): Boolean = children.find { hasAnyContent() } != null
+
+    override fun withNewExtras(newExtras: PropertyContainer<ContentNode>): ContentNode =
+        copy(extra = extra)
+
+    override fun withSourceSets(sourceSets: Set<DisplaySourceSet>): ContentNode =
+        copy(sourceSets = sourceSets)
+
+    val allResources: List<String> by lazy {
+        page.render("").resources
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/virtuslab/dokka/site/locationProvider.kt b/src/main/kotlin/com/virtuslab/dokka/site/locationProvider.kt
index d5e1c35..59991cb 100644
--- a/src/main/kotlin/com/virtuslab/dokka/site/locationProvider.kt
+++ b/src/main/kotlin/com/virtuslab/dokka/site/locationProvider.kt
@@ -1,6 +1,6 @@
 package com.virtuslab.dokka.site
 
-import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProvider
+import org.jetbrains.dokka.base.resolvers.local.DokkaLocationProvider
 import org.jetbrains.dokka.base.resolvers.local.LocationProvider
 import org.jetbrains.dokka.base.resolvers.local.LocationProviderFactory
 import org.jetbrains.dokka.pages.PageNode
@@ -13,10 +13,17 @@ class StaticSiteLocationProviderFactory(private val ctx: DokkaContext) : Locatio
     }
 }
 
-class StaticSiteLocationProvider(ctx: DokkaContext, pageNode: RootPageNode) : DefaultLocationProvider(pageNode, ctx) {
+class StaticSiteLocationProvider(ctx: DokkaContext, pageNode: RootPageNode) : DokkaLocationProvider(pageNode, ctx) {
     override fun pathTo(node: PageNode, context: PageNode?): String =
-        if (node is BaseStaticSiteProcessor.BasePageNode && node.dri.contains(docsRootDRI))
-            "index"
+        if (node is BaseStaticSiteProcessor.StaticPageNode)
+            if (node.dri.contains(docsRootDRI)) "index"
+            else {
+                // replace title with original markdown file name
+                val original = super.pathTo(node, context)
+                val paths = original.split("/")
+                val fileName = node.loadedTemplate.file.name
+                (paths.dropLast(1) + listOf(fileName)).joinToString("/")
+            }
         else
             super.pathTo(node, context)
 }
diff --git a/src/main/kotlin/com/virtuslab/dokka/site/parser.kt b/src/main/kotlin/com/virtuslab/dokka/site/parser.kt
new file mode 100644
index 0000000..c72a598
--- /dev/null
+++ b/src/main/kotlin/com/virtuslab/dokka/site/parser.kt
@@ -0,0 +1,359 @@
+package com.virtuslab.dokka.site
+
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.intellij.markdown.ast.ASTNode
+import org.intellij.markdown.ast.CompositeASTNode
+import org.intellij.markdown.ast.LeafASTNode
+import org.intellij.markdown.ast.impl.ListItemCompositeNode
+import org.intellij.markdown.flavours.gfm.GFMElementTypes
+import org.intellij.markdown.flavours.gfm.GFMFlavourDescriptor
+import org.intellij.markdown.flavours.gfm.GFMTokenTypes
+import org.intellij.markdown.parser.MarkdownParser
+import org.jetbrains.dokka.base.parsers.factories.DocTagsFromIElementFactory
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.doc.DocTag
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import java.net.MalformedURLException
+import java.net.URL
+
+
+// TODO (#24): This is a code taken from dokka, will be removed after PR with fixes is merged into dokka
+// The dokka logic was pulled to `externalDir` callback and `linksHandler` was simplyfied
+// Bug in imagesHandler was fixed (NullPointer)
+open class ExtendableMarkdownParser(private val text: String, private val externalDir: (String) -> DRI?) {
+
+    fun parse(): DocTag {
+        val flavourDescriptor = GFMFlavourDescriptor()
+        val markdownAstRoot: ASTNode = MarkdownParser(flavourDescriptor).buildMarkdownTreeFromString(text)
+        return visitNode(markdownAstRoot)
+    }
+
+    private fun headersHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(
+            node.type,
+            visitNode(node.children.find { it.type == MarkdownTokenTypes.ATX_CONTENT }
+                ?: throw IllegalStateException("Wrong AST Tree. ATX Header does not contain expected content")).children
+        )
+
+    private fun horizontalRulesHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(MarkdownTokenTypes.HORIZONTAL_RULE)
+
+    private fun emphasisHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(
+            node.type,
+            children = node.children.evaluateChildrenWithDroppedEnclosingTokens(1)
+        )
+
+    private fun strongHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(
+            node.type,
+            children = node.children.evaluateChildrenWithDroppedEnclosingTokens(2)
+        )
+
+    private fun List<ASTNode>.evaluateChildrenWithDroppedEnclosingTokens(count: Int) =
+        drop(count).dropLast(count).evaluateChildren()
+
+    private fun blockquotesHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(
+            node.type, children = node.children
+                .filterIsInstance<CompositeASTNode>()
+                .evaluateChildren()
+        )
+
+    private fun listsHandler(node: ASTNode): DocTag {
+
+        val children = node.children.filterIsInstance<ListItemCompositeNode>().flatMap {
+            if (it.children.last().type in listOf(
+                    MarkdownElementTypes.ORDERED_LIST,
+                    MarkdownElementTypes.UNORDERED_LIST
+                )
+            ) {
+                val nestedList = it.children.last()
+                (it.children as MutableList).removeAt(it.children.lastIndex)
+                listOf(it, nestedList)
+            } else
+                listOf(it)
+        }
+
+        return DocTagsFromIElementFactory.getInstance(
+            node.type,
+            children =
+            children
+                .map {
+                    if (it.type == MarkdownElementTypes.LIST_ITEM)
+                        DocTagsFromIElementFactory.getInstance(
+                            it.type,
+                            children = it
+                                .children
+                                .filterIsInstance<CompositeASTNode>()
+                                .evaluateChildren()
+                        )
+                    else
+                        visitNode(it)
+                },
+            params =
+            if (node.type == MarkdownElementTypes.ORDERED_LIST) {
+                val listNumberNode = node.children.first().children.first()
+                mapOf(
+                    "start" to text.substring(
+                        listNumberNode.startOffset,
+                        listNumberNode.endOffset
+                    ).trim().dropLast(1)
+                )
+            } else
+                emptyMap()
+        )
+    }
+
+    private fun resolveDRI(mdLink: String): DRI? =
+        mdLink
+            .removePrefix("[")
+            .removeSuffix("]")
+            .let { link ->
+                try {
+                    URL(link)
+                    null
+                } catch (e: MalformedURLException) {
+                    externalDir(link)
+                }
+            }
+
+    private fun Collection<DeclarationDescriptor>.sorted() = sortedWith(
+        compareBy(
+            { it is ClassDescriptor },
+            { (it as? FunctionDescriptor)?.name },
+            { (it as? FunctionDescriptor)?.valueParameters?.size },
+            { (it as? FunctionDescriptor)?.valueParameters?.joinToString { it.type.toString() } }
+        )
+    )
+
+    private fun referenceLinksHandler(node: ASTNode): DocTag {
+        val linkLabel = node.children.find { it.type == MarkdownElementTypes.LINK_LABEL }
+            ?: throw IllegalStateException("Wrong AST Tree. Reference link does not contain expected content")
+        val linkText = node.children.findLast { it.type == MarkdownElementTypes.LINK_TEXT } ?: linkLabel
+
+        val linkKey = text.substring(linkLabel.startOffset, linkLabel.endOffset)
+
+        return linksHandler(linkText, linkKey)
+    }
+
+    private fun inlineLinksHandler(node: ASTNode): DocTag {
+        val linkText = node.children.find { it.type == MarkdownElementTypes.LINK_TEXT }
+            ?: throw IllegalStateException("Wrong AST Tree. Inline link does not contain expected content")
+        val linkDestination = node.children.find { it.type == MarkdownElementTypes.LINK_DESTINATION }
+            ?: throw IllegalStateException("Wrong AST Tree. Inline link does not contain expected content")
+        val linkTitle = node.children.find { it.type == MarkdownElementTypes.LINK_TITLE }
+
+        val link = text.substring(linkDestination.startOffset, linkDestination.endOffset)
+
+        return linksHandler(linkText, link, linkTitle)
+    }
+
+    private fun autoLinksHandler(node: ASTNode): DocTag {
+        val link = text.substring(node.startOffset + 1, node.endOffset - 1)
+
+        return linksHandler(node, link)
+    }
+
+    private fun linksHandler(linkText: ASTNode, link: String, linkTitle: ASTNode? = null): DocTag {
+        val dri: DRI? = resolveDRI(link)
+        val linkTextString =
+            if (linkTitle == null) link else text.substring(linkTitle.startOffset + 1, linkTitle.endOffset - 1)
+
+        val params = if (linkTitle == null)
+            mapOf("href" to link)
+        else
+            mapOf("href" to link, "title" to linkTextString)
+
+        return DocTagsFromIElementFactory.getInstance(
+            MarkdownElementTypes.INLINE_LINK,
+            params = params,
+            children = linkText.children.drop(1).dropLast(1).evaluateChildren(),
+            dri = dri
+        )
+    }
+
+    private fun imagesHandler(node: ASTNode): DocTag {
+        val linkNode =
+            node.children.last().children.find { it.type == MarkdownElementTypes.LINK_LABEL }?.children?.lastOrNull()
+        val link = linkNode?.let{ text.substring(it.startOffset, it.endOffset)} ?: "_"
+        val src = mapOf("src" to link, "href" to link)
+        return DocTagsFromIElementFactory.getInstance(
+            node.type,
+            params = src,
+            children = listOf(visitNode(node.children.last().children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!))
+        )
+    }
+
+    private fun codeSpansHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(
+            node.type,
+            children = listOf(
+                DocTagsFromIElementFactory.getInstance(
+                    MarkdownTokenTypes.TEXT,
+                    body = text.substring(node.startOffset + 1, node.endOffset - 1).replace('\n', ' ').trimIndent()
+                )
+
+            )
+        )
+
+    private fun codeFencesHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(
+            node.type,
+            children = node
+                .children
+                .dropWhile { it.type != MarkdownTokenTypes.CODE_FENCE_CONTENT }
+                .dropLastWhile { it.type != MarkdownTokenTypes.CODE_FENCE_CONTENT }
+                .map {
+                    if (it.type == MarkdownTokenTypes.EOL)
+                        LeafASTNode(MarkdownTokenTypes.HARD_LINE_BREAK, 0, 0)
+                    else
+                        it
+                }.evaluateChildren(),
+            params = node
+                .children
+                .find { it.type == MarkdownTokenTypes.FENCE_LANG }
+                ?.let { mapOf("lang" to text.substring(it.startOffset, it.endOffset)) }
+                ?: emptyMap()
+        )
+
+    private fun codeBlocksHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(node.type, children = node.children.mergeLeafASTNodes().map {
+            DocTagsFromIElementFactory.getInstance(
+                MarkdownTokenTypes.TEXT,
+                body = text.substring(it.startOffset, it.endOffset)
+            )
+        })
+
+    private fun defaultHandler(node: ASTNode): DocTag =
+        DocTagsFromIElementFactory.getInstance(
+            MarkdownElementTypes.PARAGRAPH,
+            children = node.children.evaluateChildren()
+        )
+
+    fun visitNode(node: ASTNode): DocTag =
+        when (node.type) {
+            MarkdownElementTypes.ATX_1,
+            MarkdownElementTypes.ATX_2,
+            MarkdownElementTypes.ATX_3,
+            MarkdownElementTypes.ATX_4,
+            MarkdownElementTypes.ATX_5,
+            MarkdownElementTypes.ATX_6 -> headersHandler(node)
+            MarkdownTokenTypes.HORIZONTAL_RULE -> horizontalRulesHandler(node)
+            MarkdownElementTypes.STRONG -> strongHandler(node)
+            MarkdownElementTypes.EMPH -> emphasisHandler(node)
+            MarkdownElementTypes.FULL_REFERENCE_LINK,
+            MarkdownElementTypes.SHORT_REFERENCE_LINK -> referenceLinksHandler(node)
+            MarkdownElementTypes.INLINE_LINK -> inlineLinksHandler(node)
+            MarkdownElementTypes.AUTOLINK -> autoLinksHandler(node)
+            MarkdownElementTypes.BLOCK_QUOTE -> blockquotesHandler(node)
+            MarkdownElementTypes.UNORDERED_LIST,
+            MarkdownElementTypes.ORDERED_LIST -> listsHandler(node)
+            MarkdownElementTypes.CODE_BLOCK -> codeBlocksHandler(node)
+            MarkdownElementTypes.CODE_FENCE -> codeFencesHandler(node)
+            MarkdownElementTypes.CODE_SPAN -> codeSpansHandler(node)
+            MarkdownElementTypes.IMAGE -> imagesHandler(node)
+            MarkdownTokenTypes.HARD_LINE_BREAK -> DocTagsFromIElementFactory.getInstance(node.type)
+            MarkdownTokenTypes.CODE_FENCE_CONTENT,
+            MarkdownTokenTypes.CODE_LINE -> DocTagsFromIElementFactory.getInstance(
+                MarkdownElementTypes.CODE_BLOCK,
+                body = text.substring(node.startOffset, node.endOffset)
+            )
+            MarkdownTokenTypes.TEXT -> DocTagsFromIElementFactory.getInstance(
+                MarkdownTokenTypes.TEXT,
+                body = text.substring(node.startOffset, node.endOffset).transform()
+            )
+            MarkdownElementTypes.MARKDOWN_FILE -> if (node.children.size == 1) visitNode(node.children.first()) else defaultHandler(
+                node
+            )
+            GFMElementTypes.STRIKETHROUGH -> DocTagsFromIElementFactory.getInstance(
+                GFMElementTypes.STRIKETHROUGH,
+                body = text
+                    .substring(node.startOffset, node.endOffset).transform()
+            )
+            GFMElementTypes.TABLE -> DocTagsFromIElementFactory.getInstance(
+                GFMElementTypes.TABLE,
+                children = node.children.filterTabSeparators().evaluateChildren()
+            )
+            GFMElementTypes.HEADER -> DocTagsFromIElementFactory.getInstance(
+                GFMElementTypes.HEADER,
+                children = node.children.filterTabSeparators().evaluateChildren()
+            )
+            GFMElementTypes.ROW -> DocTagsFromIElementFactory.getInstance(
+                GFMElementTypes.ROW,
+                children = node.children.filterTabSeparators().evaluateChildren()
+            )
+            else -> defaultHandler(node)
+        }
+
+    private fun List<ASTNode>.filterTabSeparators() =
+        this.filterNot { it.type == GFMTokenTypes.TABLE_SEPARATOR }
+
+    private fun List<ASTNode>.evaluateChildren(): List<DocTag> =
+        this.removeUselessTokens().mergeLeafASTNodes().map { visitNode(it) }
+
+    private fun List<ASTNode>.removeUselessTokens(): List<ASTNode> =
+        this.filterIndexed { index, node ->
+            !(node.type == MarkdownElementTypes.LINK_DEFINITION || (
+                    node.type == MarkdownTokenTypes.EOL &&
+                            this.getOrNull(index - 1)?.type == MarkdownTokenTypes.HARD_LINE_BREAK
+                    ))
+        }
+
+    private val notLeafNodes = listOf(MarkdownTokenTypes.HORIZONTAL_RULE, MarkdownTokenTypes.HARD_LINE_BREAK)
+
+    private fun List<ASTNode>.isNotLeaf(index: Int): Boolean =
+        if (index in 0..this.lastIndex)
+            (this[index] is CompositeASTNode) || this[index].type in notLeafNodes
+        else
+            false
+
+    private fun List<ASTNode>.mergeLeafASTNodes(): List<ASTNode> {
+        val children: MutableList<ASTNode> = mutableListOf()
+        var index = 0
+        while (index <= this.lastIndex) {
+            if (this.isNotLeaf(index)) {
+                children += this[index]
+            } else {
+                val startOffset = this[index].startOffset
+                val sIndex = index
+                while (index < this.lastIndex) {
+                    if (this.isNotLeaf(index + 1) || this[index + 1].startOffset != this[index].endOffset) {
+                        mergedLeafNode(this, index, startOffset, sIndex)?.run {
+                            children += this
+                        }
+                        break
+                    }
+                    index++
+                }
+                if (index == this.lastIndex) {
+                    mergedLeafNode(this, index, startOffset, sIndex)?.run {
+                        children += this
+                    }
+                }
+            }
+            index++
+        }
+        return children
+    }
+
+    private fun mergedLeafNode(nodes: List<ASTNode>, index: Int, startOffset: Int, sIndex: Int): LeafASTNode? {
+        val endOffset = nodes[index].endOffset
+        if (text.substring(startOffset, endOffset).transform().trim().isNotEmpty()) {
+            val type = if (nodes.subList(sIndex, index)
+                    .any { it.type == MarkdownTokenTypes.CODE_LINE }
+            ) MarkdownTokenTypes.CODE_LINE else MarkdownTokenTypes.TEXT
+            return LeafASTNode(type, startOffset, endOffset)
+        }
+        return null
+    }
+
+    private fun String.transform() = this
+        .replace(Regex("\n\n+"), "")        // Squashing new lines between paragraphs
+        .replace(Regex("\n"), " ")
+        .replace(Regex(" >+ +"), " ")      // Replacement used in blockquotes, get rid of garbage
+}
+
diff --git a/src/main/kotlin/com/virtuslab/dokka/site/processors.kt b/src/main/kotlin/com/virtuslab/dokka/site/processors.kt
index 4ca0380..e62a9f5 100644
--- a/src/main/kotlin/com/virtuslab/dokka/site/processors.kt
+++ b/src/main/kotlin/com/virtuslab/dokka/site/processors.kt
@@ -1,8 +1,5 @@
 package com.virtuslab.dokka.site
 
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.base.parsers.HtmlParser
-import org.jetbrains.dokka.base.parsers.MarkdownParser
 import org.jetbrains.dokka.base.renderers.html.NavigationNode
 import org.jetbrains.dokka.base.renderers.html.NavigationPage
 import org.jetbrains.dokka.base.transformers.pages.comments.DocTagToContentConverter
@@ -10,28 +7,16 @@ import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.model.doc.Text
 import org.jetbrains.dokka.model.properties.PropertyContainer
+import org.jetbrains.dokka.model.toDisplaySourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.pages.PageTransformer
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import java.io.File
 
 const val ExternalDocsTooKey = "ExternalDocsTooKey"
 
 val docsRootDRI = DRI.topLevel.copy(extra = "_top_level_index")
 
-data class PreRenderedContent(
-    val html: String,
-    override val dci: DCI,
-    override val sourceSets: Set<DokkaConfiguration.DokkaSourceSet>,
-    override val style: Set<Style> = emptySet(),
-    override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
-) : ContentNode {
-    override fun hasAnyContent(): Boolean = !html.isBlank()
-
-    override fun withNewExtras(newExtras: PropertyContainer<ContentNode>): ContentNode = copy(extra = newExtras)
-}
-
 abstract class BaseStaticSiteProcessor(cxt: DokkaContext) : PageTransformer {
 
     final override fun invoke(input: RootPageNode): RootPageNode =
@@ -43,39 +28,27 @@ abstract class BaseStaticSiteProcessor(cxt: DokkaContext) : PageTransformer {
     val root = rawRoot ?: File("unknown")
 
     protected val mySourceSet = cxt.configuration.sourceSets.toSet()
+    protected val myDisplaySourceSet = mySourceSet.map { it.toDisplaySourceSet() }.toSet()
     protected val docsFile = File(root, "docs")
 
-    protected fun File.asDri(): DRI {
-        val relativePath = root.toPath().relativize(toPath()).toString().replace(File.separatorChar, '.')
-        return DRI("_.$relativePath")
+    data class LoadedTemplate(val templateFile: TemplateFile, val children: List<LoadedTemplate>, val file: File) {
+        fun isIndexPage() = file.isFile && (file.name == "index.md" || file.name == "index.html")
+        fun relativePath(root: File): String =
+            root.toPath().relativize(file.toPath()).toString().replace(File.separatorChar, '.')
     }
 
-    abstract inner class BasePageNode(
-        file: File,
-        private val template: TemplateFile,
-        override val children: List<BasePageNode>,
-        open val resolved: ResolvedPage,
+    data class StaticPageNode(
+        override val name: String,
+        override val children: List<StaticPageNode>,
+        val loadedTemplate: LoadedTemplate,
         override val dri: Set<DRI>,
-        override val embeddedResources: List<String> = emptyList()
+        override val embeddedResources: List<String> = emptyList(),
+        override val content: ContentNode,
     ) : ContentPage {
-        override val name: String = template.name()
         override val documentable: Documentable? = null
 
-        val isIndexPage = file.name == "index.md" || file.name == "index.html"
-
-        fun title() = template.title()
-    }
-
-    inner class HtmlPageNode(
-        private val file: File,
-        private val template: TemplateFile,
-        override val children: List<BasePageNode>,
-        override val resolved: ResolvedPage,
-        override val dri: Set<DRI>,
-        override val embeddedResources: List<String> = emptyList()
-    ) : BasePageNode(file, template, children, resolved, dri, embeddedResources) {
-
-        override val content: ContentNode = PreRenderedContent(resolved.code, DCI(dri, ContentKind.Empty), mySourceSet)
+        fun title(): String = loadedTemplate.templateFile.title()
+        fun hasFrame(): Boolean = loadedTemplate.templateFile.hasFrame()
 
         override fun modified(
             name: String,
@@ -84,67 +57,23 @@ abstract class BaseStaticSiteProcessor(cxt: DokkaContext) : PageTransformer {
             embeddedResources: List<String>,
             children: List<PageNode>
         ): ContentPage =
-            HtmlPageNode(file, template, children.filterIsInstance<BasePageNode>(), resolved, dri, embeddedResources)
+            copy(
+                name = name,
+                content = content,
+                dri = dri,
+                embeddedResources = embeddedResources,
+                children = children.map { it as StaticPageNode })
 
         override fun modified(name: String, children: List<PageNode>): PageNode =
-            HtmlPageNode(file, template, children.filterIsInstance<BasePageNode>(), resolved, dri, embeddedResources)
-    }
-
-    inner class MdPageNode(
-        private val file: File,
-        private val template: TemplateFile,
-        override val children: List<BasePageNode>,
-        override val resolved: ResolvedPage,
-        override val dri: Set<DRI>,
-        override val embeddedResources: List<String> = emptyList()
-    ) : BasePageNode(file, template, children, resolved, dri, embeddedResources) {
-
-        override val content: ContentNode = resolvedPageToContent(resolved, dri)
-
-        override fun modified(
-            name: String,
-            content: ContentNode,
-            dri: Set<DRI>,
-            embeddedResources: List<String>,
-            children: List<PageNode>
-        ): ContentPage =
-            MdPageNode(file, template, children.filterIsInstance<BasePageNode>(), resolved, dri, embeddedResources)
+            copy(name = name, children = children.map { it as StaticPageNode })
 
-        override fun modified(name: String, children: List<PageNode>): PageNode =
-            MdPageNode(file, template, children.filterIsInstance<BasePageNode>(), resolved, dri, embeddedResources)
-
-        private fun resolvedPageToContent(
-            resolvedPage: ResolvedPage,
-            dri: Set<DRI>
-        ): ContentGroup {
-            val parser =
-                if (resolvedPage.isHtml) HtmlParser()
-                else MarkdownParser(logger = DokkaConsoleLogger)
-
-            val docTag = try {
-                parser.parseStringToDocNode(resolvedPage.code)
-            } catch (e: Throwable) {
-                val msg = "Error rendering (dri = $dri): ${e.message}"
-                println("ERROR: $msg") // TODO (#14): provide proper error handling
-                Text(msg, emptyList())
-            }
-
-            val contentNodes = DocTagToContentConverter.buildContent(
-                docTag,
-                DCI(dri, ContentKind.Empty),
-                mySourceSet,
-                emptySet(),
-                PropertyContainer.empty()
-            )
-
-            return ContentGroup(
-                contentNodes,
-                DCI(dri, ContentKind.Empty),
-                mySourceSet,
-                emptySet(),
-                PropertyContainer.empty()
-            )
+        fun resources() = when (content) {
+            is PartiallyRenderedContent ->
+                content.allResources
+            else ->
+                emptyList()
         }
+
     }
 }
 
@@ -152,7 +81,7 @@ class SiteResourceManager(cxt: DokkaContext) : BaseStaticSiteProcessor(cxt) {
     private fun listResources(nodes: List<PageNode>): Set<String> =
         nodes.flatMap {
             when (it) {
-                is BasePageNode -> listResources(it.children) + it.resolved.resources
+                is StaticPageNode -> listResources(it.children) + it.resources()
                 else -> emptySet()
             }
         }.toSet()
@@ -166,7 +95,7 @@ class SiteResourceManager(cxt: DokkaContext) : BaseStaticSiteProcessor(cxt) {
         }
         val modified = input.transformContentPagesTree {
             when (it) {
-                is BasePageNode -> it.modified(embeddedResources = it.embeddedResources + it.resolved.resources)
+                is StaticPageNode -> it.modified(embeddedResources = it.embeddedResources + it.resources())
                 else -> it
             }
         }
@@ -180,14 +109,15 @@ class SitePagesCreator(cxt: DokkaContext) : BaseStaticSiteProcessor(cxt) {
         val (navigationPage, rest) = input.children.partition { it is NavigationPage }
         val defaultNavigation = (navigationPage.single() as NavigationPage).root
 
-        val (indexes, children) = loadFiles().partition { it.isIndexPage }
-        if (indexes.size > 1) println("ERROR: Multiple index pages found ${children.filter { it.isIndexPage }}") // TODO (#14): provide proper error handling
+        val allFiles = docsFile.listFiles()?.toList() ?: emptyList()
+        val (indexes, children) = loadFiles(allFiles).partition { it.loadedTemplate.isIndexPage() }
+        if (indexes.size > 1) println("ERROR: Multiple index pages found $indexes}") // TODO (#14): provide proper error handling
 
-        fun toNavigationNode(c: BasePageNode): NavigationNode =
+        fun toNavigationNode(c: StaticPageNode): NavigationNode =
             NavigationNode(
-                c.title(),
+                c.loadedTemplate.templateFile.title(),
                 c.dri.first(),
-                mySourceSet,
+                myDisplaySourceSet,
                 c.children.map { toNavigationNode(it) }
             )
 
@@ -220,7 +150,7 @@ class SitePagesCreator(cxt: DokkaContext) : BaseStaticSiteProcessor(cxt) {
                                     emptyList(),
                                     it.embeddedResources
                                 )
-                            it.modified(content = indexPage.content, children = it.children + packageList)
+                            it.modified(content = indexPage.content, children = it.children + listOf(packageList))
                         } else it
                     else ->
                         it
@@ -231,8 +161,7 @@ class SitePagesCreator(cxt: DokkaContext) : BaseStaticSiteProcessor(cxt) {
         val indexFiles = listOf(File(root, "index.html"), File(root, "index.md")).filter { it.exists() }
         if (indexFiles.size > 1) println("ERROR: Multiple root index pages found: ${indexFiles.map { it.absolutePath }}") // TODO (#14): provide proper error handling
 
-        val topLevelIndexPage = indexFiles.take(1)
-            .mapNotNull { renderDocs(it, noChildren = true)?.modified(dri = setOf(docsRootDRI)) }
+        val topLevelIndexPage = loadFiles(indexFiles.take(1)).map { it.modified(dri = setOf(docsRootDRI)) }
 
         return input.modified(children = original + topLevelIndexPage + listOf(NavigationPage(mergedRoots)) + children)
     }
@@ -243,50 +172,93 @@ class SitePagesCreator(cxt: DokkaContext) : BaseStaticSiteProcessor(cxt) {
         dirs.map { loadTemplateFile(it) }.map { it.name() to it }.toMap()
     }
 
-    private fun renderDocs(from: File, noChildren: Boolean = false): BasePageNode? =
-        if (from.name.startsWith("_")) null else try {
-            val dri = setOf(from.asDri())
-
-            val children =
-                if (noChildren) emptyList() else from.listFiles()?.mapNotNull { renderDocs(it) } ?: emptyList()
-            if (children.count { it.isIndexPage } > 1)
-                println("ERROR: Multiple index pages found ${children.filter { it.isIndexPage }}") // TODO (#14): provide proper error handling
-
-            val templateFile = loadTemplateFile(
-                if (from.isDirectory) {
-                    val indexFiles = from.listFiles { file -> file.name == "index.md" || file.name == "index.html" }
-                    check(indexFiles!!.size == 1) { "ERROR: Multiple index pages found under ${from.path}" } // ensured above too
-                    indexFiles.first()
-                } else from
-            )
 
-            val resolvedPage = try {
-                if (from.isDirectory) {
-                    children.find { it.isIndexPage }?.resolved ?: EmptyResolvedPage
-                } else {
-                    val properties = templateFile.layout()
-                        ?.let { mapOf("content" to templateFile.rawCode) } ?: emptyMap()
-                    val context = RenderingContext(properties, layouts)
-                    templateFile.resolve(context)
+    private fun isValidTemplate(file: File): Boolean =
+        (file.isDirectory && !file.name.startsWith("_"))  ||
+                file.name.endsWith(".md") ||
+                file.name.endsWith(".html")
+
+
+    private fun loadTemplate(from: File): LoadedTemplate? =
+        if (!isValidTemplate(from)) null else try {
+            val (indexes, children) = (from.listFiles()?.mapNotNull { loadTemplate(it) }
+                ?: emptyList()).partition { it.isIndexPage() }
+            if (indexes.size > 1)
+                println("ERROR: Multiple index pages for $from found in ${indexes.map { it.file }}") // TODO (#14): provide proper error handling
+
+            fun loadIndexPage(): TemplateFile {
+                val indexFiles = from.listFiles { file -> file.name == "index.md" || file.name == "index.html" }
+                return when (indexFiles.size) {
+                    0 -> emptyTemplate(from)
+                    1 -> loadTemplateFile(indexFiles.first()).copy(file = from)
+                    else -> throw java.lang.RuntimeException("ERROR: Multiple index pages found under ${from.path}")
                 }
-            } catch (e: Throwable) {
-                val msg = "Error rendering $from: ${e.message}"
-                println("ERROR: $msg") // TODO (#14): provide proper error handling
-                ResolvedPage(msg)
             }
 
-            if (resolvedPage.isHtml) {
-                HtmlPageNode(from, templateFile, children.filter { !it.isIndexPage }, resolvedPage, dri)
-            } else { // isMd
-                MdPageNode(from, templateFile, children.filter { !it.isIndexPage }, resolvedPage, dri)
-            }
+            val templateFile = if (from.isDirectory) loadIndexPage() else loadTemplateFile(from)
+
+            LoadedTemplate(templateFile, children, from)
 
         } catch (e: RuntimeException) {
             e.printStackTrace() // TODO (#14): provide proper error handling
             null
         }
 
-    private fun loadFiles(): List<BasePageNode> =
-        docsFile.listFiles()?.mapNotNull { renderDocs(it) } ?: emptyList()
+    private fun parseMarkdown(page: PreResolvedPage, dri: Set<DRI>, allDirs: Map<String, DRI>): ContentNode {
+        val nodes = if (page.hasMarkdown) {
+            val parser = ExtendableMarkdownParser(page.code, allDirs::get)
+
+            val docTag = try {
+                parser.parse()
+            } catch (e: Throwable) {
+                val msg = "Error rendering (dri = $dri): ${e.message}"
+                println("ERROR: $msg") // TODO (#14): provide proper error handling
+                Text(msg, emptyList())
+            }
+
+            DocTagToContentConverter.buildContent(
+                docTag,
+                DCI(dri, ContentKind.Empty),
+                mySourceSet,
+                emptySet(),
+                PropertyContainer.empty()
+            )
+        } else emptyList()
+        return PartiallyRenderedContent(
+            page,
+            nodes,
+            DCI(dri, ContentKind.Empty),
+            myDisplaySourceSet,
+            emptySet(),
+            PropertyContainer.empty()
+        )
+    }
 
+    private fun loadFiles(files: List<File>): List<StaticPageNode> {
+        val all = files.mapNotNull { loadTemplate(it) }
+        fun flatten(it: LoadedTemplate): List<String> =
+            listOf(it.relativePath(root)) + it.children.flatMap { flatten(it) }
+
+        fun pathToDri(path: String) = DRI("_.$path")
+
+        val driMap = all.flatMap { flatten(it) }.map { it to pathToDri(it) }.toMap()
+
+        fun templateToPage(myTemplate: LoadedTemplate): StaticPageNode {
+            val dri = setOf(pathToDri(myTemplate.relativePath(root)))
+            val page = try {
+                val properties = myTemplate.templateFile.layout()
+                    ?.let { mapOf("content" to myTemplate.templateFile.rawCode) } ?: emptyMap()
+
+                myTemplate.templateFile.resolveMarkdown(RenderingContext(properties, layouts))
+            } catch (e: Throwable) {
+                val msg = "Error rendering $myTemplate: ${e.message}"
+                println("ERROR: $msg") // TODO (#14): provide proper error handling
+                PreResolvedPage("", null, true)
+            }
+            val content = parseMarkdown(page, dri, driMap)
+            val children = myTemplate.children.map { templateToPage(it) }
+            return StaticPageNode(myTemplate.templateFile.title(), children, myTemplate, dri, emptyList(), content)
+        }
+        return all.map { templateToPage(it) }
+    }
 }
diff --git a/src/main/kotlin/com/virtuslab/dokka/site/renderer.kt b/src/main/kotlin/com/virtuslab/dokka/site/renderer.kt
index edf7c3e..2a1d04e 100644
--- a/src/main/kotlin/com/virtuslab/dokka/site/renderer.kt
+++ b/src/main/kotlin/com/virtuslab/dokka/site/renderer.kt
@@ -1,70 +1,111 @@
 package com.virtuslab.dokka.site
 
-import com.vladsch.flexmark.html.HtmlRenderer
-import com.vladsch.flexmark.parser.Parser
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
-import org.jetbrains.dokka.pages.ContentPage
-import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import java.net.URI
 
-class ExternalDocsToolRenderer(context: DokkaContext) : org.jetbrains.dokka.base.renderers.html.HtmlRenderer(context) {
+
+// this will be rewritten after PR is merged to dokka
+class RendererDispatcher(context: DokkaContext) : org.jetbrains.dokka.base.renderers.html.HtmlRenderer(context) {
+
     override fun buildPageContent(context: FlowContent, page: ContentPage) {
-        context.buildNavigation(page)
-        fun FlowContent.render(txt: String) = div { unsafe { +txt } }
+        when (page) {
+            is BaseStaticSiteProcessor.StaticPageNode ->
+                if (page.hasFrame()) context.buildNavigation(page)
+            else -> context.buildNavigation(page)
+        }
+
+        fun FlowContent.render(txt: String) {
+            div { unsafe { +txt } }
+        }
         when (val content = page.content) {
-            is PreRenderedContent -> context.render(content.html)
+            is PartiallyRenderedContent ->
+                context.render(render(content, page))
             else -> content.build(context, page)
         }
     }
 
-    // TODO (#15): remove once html render has proper API
-    private fun PageNode.root(path: String) = locationProvider.resolveRoot(this) + path
-    private fun resolveLink(link: String, page: PageNode): String = if (URI(link).isAbsolute) link else page.root(link)
+    private fun render(c: PartiallyRenderedContent, p: ContentPage): String {
+        val parsed =
+            if (!c.page.hasMarkdown)
+                c.page.code
+            else {
+                val ctx = createHTML()
+                ctx.div {
+                    c.children.forEach { it.build(this, p) }
+                }
+                ctx.finalize()
+            }
 
-    // TODO (#15): change API of HTML renderer
-    override fun buildHtml(page: PageNode, resources: List<String>, content: FlowContent.() -> Unit) =
-        when (page) {
-            is BaseStaticSiteProcessor.HtmlPageNode ->
-                createHtml(page, page.resolved.code)
-            is BaseStaticSiteProcessor.MdPageNode ->
-                if (page.dri.contains(docsRootDRI)) {
-                    val parser: Parser = Parser.builder().build()
-                    val htmlRenderer = HtmlRenderer.builder(defaultMarkdownOptions).build()
-                    val htmlContent = htmlRenderer.render(parser.parse(page.resolved.code))
-                    createHtml(page, htmlContent)
-                } else super.buildHtml(page, resources, content)
-            else ->
-                super.buildHtml(page, resources, content)
+        return c.page.render(parsed).code
+    }
+
+    override fun FlowContent.buildCodeBlock(code: ContentCodeBlock, pageContext: ContentPage) {
+        pre {
+            code(code.style.joinToString(" ") { it.toString().toLowerCase() } + " language-scala") {
+                attributes["theme"] = "idea"
+                code.children.forEach { buildContentNode(it, pageContext) }
+            }
         }
+    }
+
+    private fun PageNode.root(path: String) = locationProvider.pathToRoot(this) + path
+    private fun resolveLink(link: String, page: PageNode): String = if (URI(link).isAbsolute) link else page.root(link)
 
-    private fun createHtml(page: BaseStaticSiteProcessor.BasePageNode, htmlContent: String): String {
-        return createHTML().html {
-            head {
-                meta(name = "viewport", content = "width=device-width, initial-scale=1", charset = "UTF-8")
-                title(page.name)
-                page.resolved.resources.forEach {
-                    when {
-                        it.substringBefore('?').substringAfterLast('.') == "css" -> link(
-                            rel = LinkRel.stylesheet,
-                            href = resolveLink(it, page)
-                        )
-                        it.substringBefore('?').substringAfterLast('.') == "js" -> script(
-                            type = ScriptType.textJavaScript,
-                            src = resolveLink(it, page)
-                        ) {
-                            async = true
+    override fun buildHtml(page: PageNode, resources: List<String>, content: FlowContent.() -> Unit): String =
+        if (page !is BaseStaticSiteProcessor.StaticPageNode) super.buildHtml(page, resources, content) else
+            createHTML().html {
+                head {
+                    meta(name = "viewport", content = "width=device-width, initial-scale=1", charset = "UTF-8")
+                    title(page.loadedTemplate.templateFile.title())
+                    (if (page.hasFrame()) resources else page.resources()).forEach {
+                        when {
+                            it.substringBefore('?').substringAfterLast('.') == "css" -> link(
+                                rel = LinkRel.stylesheet,
+                                href = resolveLink(it, page)
+                            )
+                            it.substringBefore('?').substringAfterLast('.') == "js" -> script(
+                                type = ScriptType.textJavaScript,
+                                src = resolveLink(it, page)
+                            ) {
+                                async = true
+                            }
+                            else -> unsafe { +it }
                         }
-                        else -> unsafe { +it }
                     }
+                    script { unsafe { +"""var pathToRoot = "${locationProvider.pathToRoot(page)}";""" } }
+                }
+                body {
+                    if (page.hasFrame()) defaultFrame(page, content) else buildPageContent(this, page)
+                }
+            }
+
+    private fun FlowContent.defaultFrame(page: PageNode, content: FlowContent.() -> Unit): Unit = div {
+        id = "container"
+        div {
+            id = "leftColumn"
+            div {
+                id = "logo"
+            }
+            if (page !is MultimoduleRootPage) {
+                div {
+                    id = "paneSearch"
                 }
-                script { unsafe { +"""var pathToRoot = "${locationProvider.resolveRoot(page)}";""" } }
             }
-            body {
-                unsafe { +htmlContent }
+            div {
+                id = "sideMenu"
             }
         }
+        div {
+            id = "main"
+            div {
+                id = "searchBar"
+            }
+            script(type = ScriptType.textJavaScript, src = page.root("scripts/pages.js")) {}
+            script(type = ScriptType.textJavaScript, src = page.root("scripts/main.js")) {}
+            content()
+        }
     }
-
-}
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/virtuslab/dokka/site/templates.kt b/src/main/kotlin/com/virtuslab/dokka/site/templates.kt
index 3aacb29..397fefb 100644
--- a/src/main/kotlin/com/virtuslab/dokka/site/templates.kt
+++ b/src/main/kotlin/com/virtuslab/dokka/site/templates.kt
@@ -15,7 +15,7 @@ import com.vladsch.flexmark.util.options.DataHolder
 import com.vladsch.flexmark.util.options.MutableDataSet
 import liqp.Template
 import java.io.File
-import java.util.HashMap
+import java.util.*
 
 val defaultMarkdownOptions: DataHolder =
     MutableDataSet()
@@ -43,22 +43,40 @@ data class RenderingContext(
     val markdownOptions: DataHolder = defaultMarkdownOptions,
     val resources: List<String> = emptyList()
 ) {
-    internal fun nest(code: String, path: String, resources: List<String>) =
+    internal fun nest(code: String, file: File, resources: List<String>) =
         copy(
-            resolving = resolving + path,
+            resolving = resolving + file.absolutePath,
             properties = properties + ("content" to code),
             resources = this.resources + resources
         )
 }
 
+data class LayoutInfo(
+    val htmlTemple: TemplateFile,
+    val ctx: RenderingContext,
+)
+
+data class PreResolvedPage(
+    val code: String,
+    val nextLayoutInfo: LayoutInfo?,
+    val hasMarkdown: Boolean,
+    val resources: List<String> = emptyList()
+) {
+    fun render(renderedMarkdown: String): ResolvedPage =
+        if (nextLayoutInfo == null) ResolvedPage(renderedMarkdown, hasMarkdown, resources) else {
+            val newCtx =
+                nextLayoutInfo.ctx.copy(properties = nextLayoutInfo.ctx.properties + ("content" to renderedMarkdown))
+            val res = nextLayoutInfo.htmlTemple.resolveToHtml(newCtx, hasMarkdown)
+            ResolvedPage(res.code, hasMarkdown, res.resources)
+        }
+}
+
 data class ResolvedPage(
     val code: String,
-    val isHtml: Boolean = true,
+    val hasMarkdown: Boolean,
     val resources: List<String> = emptyList()
 )
 
-val EmptyResolvedPage = ResolvedPage(code = "")
-
 /**
  * Data class for the template files.
  * Template file is a file `.md` or `.html` handling settings.
@@ -67,47 +85,66 @@ val EmptyResolvedPage = ResolvedPage(code = "")
  * @param rawCode The content, what is to be shown, everything but settings.
  * @param settings The config defined in the begging of the file, between the pair of `---` (e.g. layout: basic).
  */
-data class TemplateFile(val file: File, val rawCode: String, private val settings: Map<String, List<String>>) {
+data class TemplateFile(
+    val file: File,
+    val isHtml: Boolean,
+    val rawCode: String,
+    private val settings: Map<String, List<String>>
+) {
     private fun stringSetting(name: String): String? {
-        val list = settings.get(name)
+        val list = settings[name]
         list?.also { assert(it.size == 1) { "Setting $name is a list in $settings" } }
         return list?.first()?.removePrefix("\"")?.removeSuffix("\"")
     }
 
-    private fun listSetting(name: String): List<String> = settings.get(name) ?: emptyList()
+    private fun listSetting(name: String): List<String> = settings[name] ?: emptyList()
 
-    private val isHtml = file.name.endsWith(".html")
     fun name(): String = stringSetting("name") ?: file.name.removeSuffix(if (isHtml) ".html" else ".md")
     fun title(): String = stringSetting("title") ?: name()
     fun layout(): String? = stringSetting("layout")
+    fun hasFrame(): Boolean = stringSetting("hasFrame") != "false"
+
 
-    fun resolve(ctx: RenderingContext): ResolvedPage =
+    fun resolveMarkdown(ctx: RenderingContext): PreResolvedPage =
         resolveInner(
             ctx = ctx.copy(properties = HashMap(ctx.properties) + ("page" to mapOf("title" to title()))),
-            hasHtmlContent = false
+            stopAtHtml = true,
+            !isHtml // This is toplevel template
         )
 
-    private fun resolveInner(ctx: RenderingContext, hasHtmlContent: Boolean): ResolvedPage {
+    fun resolveToHtml(ctx: RenderingContext, hasMarkdown: Boolean): PreResolvedPage =
+        resolveInner(ctx, stopAtHtml = false, hasMarkdown)
+
+    private fun resolveInner(ctx: RenderingContext, stopAtHtml: Boolean, hasMarkdown: Boolean): PreResolvedPage {
         if (ctx.resolving.contains(file.absolutePath))
             throw java.lang.RuntimeException("Cycle in templates involving $file: ${ctx.resolving}")
 
-        val rendered = Template.parse(this.rawCode).render(HashMap(ctx.properties)) // Library requires mutable maps..
-        val toBeResolvedIsHtml = isHtml || hasHtmlContent
-        val code = if (!toBeResolvedIsHtml) rendered else {
-            val parser: Parser = Parser.builder().build()
-            HtmlRenderer.builder(ctx.markdownOptions).build().render(parser.parse(rendered))
-        }
-        val resources = listSetting("extraCSS") + listSetting("extraJS")
-        return layout()?.let {
-            val layoutTemplate = ctx.layouts[it] ?: throw RuntimeException("No layouts named $it in ${ctx.layouts}")
-            layoutTemplate.resolveInner(
-                ctx = ctx.nest(code, file.absolutePath, resources),
-                hasHtmlContent = toBeResolvedIsHtml
+        val layoutTemplate =
+            layout()?.let { ctx.layouts[it] ?: throw RuntimeException("No layouts named $it in ${ctx.layouts}") }
+
+        if (!stopAtHtml && !isHtml)
+            throw java.lang.RuntimeException(
+                "Markdown layout cannot be applied after .html. Rendering $file after: ${ctx.resolving}"
             )
-        } ?: ResolvedPage(code, toBeResolvedIsHtml, resources + ctx.resources)
+
+        return if (stopAtHtml && isHtml) {
+            PreResolvedPage(ctx.properties["content"].toString(), LayoutInfo(this, ctx), hasMarkdown)
+        } else {
+            val rendered =
+                Template.parse(this.rawCode).render(HashMap(ctx.properties)) // Library requires mutable maps..
+            val code = if (!isHtml) rendered else {
+                val parser: Parser = Parser.builder().build()
+                HtmlRenderer.builder(ctx.markdownOptions).build().render(parser.parse(rendered))
+            }
+            val resources = listSetting("extraCSS") + listSetting("extraJS")
+            val resolved = layoutTemplate?.resolveInner(ctx.nest(code, file, resources), stopAtHtml, hasMarkdown)
+            resolved ?: PreResolvedPage(code, null, hasMarkdown, resources + ctx.resources)
+        }
     }
 }
 
+fun emptyTemplate(file: File) = TemplateFile(file, isHtml = true, "", emptyMap())
+
 const val ConfigSeparator = "---"
 const val LineSeparator = "\n"
 
@@ -129,6 +166,7 @@ fun loadTemplateFile(file: File): TemplateFile {
 
     return TemplateFile(
         file = file,
+        file.name.endsWith(".html"),
         rawCode = content.joinToString(LineSeparator),
         settings = yamlCollector.data
     )
diff --git a/src/test/kotlin/headerTests.kt b/src/test/kotlin/headerTests.kt
index 8c986a0..3c3f71d 100644
--- a/src/test/kotlin/headerTests.kt
+++ b/src/test/kotlin/headerTests.kt
@@ -1,7 +1,9 @@
 package com.virtuslab.dokka.site
 
+import com.vladsch.flexmark.html.HtmlRenderer
+import com.vladsch.flexmark.parser.Parser
+import org.junit.Assert.assertEquals
 import org.junit.Test
-import org.junit.Assert.*
 import java.nio.file.Files
 
 class TemplateFileTests {
@@ -34,6 +36,13 @@ class TemplateFileTests {
     }
 
 
+    private fun TemplateFile.fullRender(ctx: RenderingContext): String {
+        val code = resolveMarkdown(ctx)
+        val parser: Parser = Parser.builder().build()
+        val built = HtmlRenderer.builder(ctx.markdownOptions).build().render(parser.parse(code.code))
+        return code.render(built).code.trim()
+    }
+
     @Test
     fun testParsingHeaders() {
         testTemplate(
@@ -49,6 +58,44 @@ class TemplateFileTests {
         }
     }
 
+    @Test
+    fun testLinks() {
+        val base =
+            """
+            ---
+            title: myTitle
+            name: base
+            ---
+            Ala {{ content }}. {{p2}} with [link](link/target.md)!
+            """.trimIndent()
+
+        val content =
+            """
+                ---
+                layout: base
+                name: content
+                ---
+                ma kota w **{{ p1 }}** from [here](link/here.md)
+                """.trimIndent()
+
+
+        val expected = """
+             <p>Ala <p>ma kota w <strong>paski</strong> from <a href="link/here.md">here</a></p>
+             . Hej with <a href="link/target.md">link</a>!</p>
+            """.trimIndent()
+
+        testTemplates(
+            mapOf("p1" to "paski", "p2" to "Hej"),
+            listOf(base to "html", content to "md")
+        ) {
+            assertEquals(
+                expected,
+                it.layouts.getValue("content").fullRender(it)
+            )
+        }
+    }
+
+
     @Test
     fun layout() {
         val base =
@@ -69,13 +116,19 @@ class TemplateFileTests {
                 ma kota w **{{ p1 }}**
                 """.trimIndent()
 
+
+        val expected = """
+                <p>Ala <p>ma kota w <strong>paski</strong></p>
+                . Hej!</p>
+            """.trimIndent()
+
         testTemplates(
             mapOf("p1" to "paski", "p2" to "Hej"),
             listOf(base to "html", content to "md")
         ) {
             assertEquals(
-                "<p>Ala ma kota w <strong>paski</strong>. Hej!</p>",
-                it.layouts.getValue("content").resolve(it).code.trim()
+                expected,
+                it.layouts.getValue("content").fullRender(it)
             )
         }
     }
@@ -126,12 +179,12 @@ class TemplateFileTests {
             listOf(
                 toplevel to "html",
                 basePage to "md",
-                content to "html"
+                content to "md"
             )
         ) {
             assertEquals(
                 expected,
-                it.layouts.getValue("content").resolve(it).code.trim()
+                it.layouts.getValue("content").fullRender(it)
             )
         }
     }
@@ -143,7 +196,7 @@ class TemplateFileTests {
             ---
             name: toplevel
             ---
-            # The Page
+            <h1>The Page</h1>
             {{ content }}
             """.trimIndent()
 
@@ -181,14 +234,14 @@ class TemplateFileTests {
         testTemplates(
             mapOf("pageName" to "Test page", "name" to "world!"),
             listOf(
-                toplevel to "md",
+                toplevel to "html",
                 basePage to "html",
                 content to "md"
             )
         ) {
             assertEquals(
                 expected,
-                it.layouts.getValue("content").resolve(it).code.trim()
+                it.layouts.getValue("content").fullRender(it)
             )
         }
     }
@@ -201,7 +254,7 @@ class TemplateFileTests {
             """.trimIndent(),
             ext = "md"
         ) {
-            assertEquals("# Hello there!", resolve(RenderingContext(mapOf("msg" to "there"))).code.trim())
+            assertEquals("# Hello there!", resolveMarkdown(RenderingContext(mapOf("msg" to "there"))).code.trim())
         }
     }
 
@@ -213,7 +266,7 @@ class TemplateFileTests {
             """.trimIndent(),
             ext = "md"
         ) {
-            assertEquals("# Hello there!", resolve(RenderingContext(mapOf("msg" to "there"))).code.trim())
+            assertEquals("# Hello there!", resolveMarkdown(RenderingContext(mapOf("msg" to "there"))).code.trim())
         }
     }
 }
\ No newline at end of file
diff --git a/src/test/kotlin/parserTests.kt b/src/test/kotlin/parserTests.kt
new file mode 100644
index 0000000..707a8fe
--- /dev/null
+++ b/src/test/kotlin/parserTests.kt
@@ -0,0 +1,58 @@
+package com.virtuslab.dokka.site
+
+
+import org.jetbrains.dokka.model.doc.*
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+
+class ParserTest {
+    private fun runtest(md: String, expected: DocTag) {
+        val parser = ExtendableMarkdownParser(md) { null }
+        val compiled = parser.parse()
+        assertEquals(expected, compiled)
+    }
+
+
+    @Test
+    fun simpleTest() = runtest("ala", P(listOf(Text("ala"))))
+
+    @Test
+    fun code() = runtest(
+        """
+            ```scala
+            def ala() = 123
+            ```
+        """.trimIndent(),
+        CodeBlock(listOf(Text("def ala() = 123")), mapOf("lang" to "scala"))
+    )
+
+    @Test
+    fun relativeLink() = runtest(
+        """
+            [link](ala/maKota.md)
+        """.trimIndent(),
+        P(listOf(A(listOf(Text("link")), mapOf("href" to "ala/maKota.md"))))
+    )
+
+    @Test
+    fun listTest() = runtest(
+        """
+        List:
+
+          - element 1
+          - element 2
+        """.trimIndent(),
+        P(
+            listOf(
+                P(listOf(Text("List:"))),
+                Ul(
+                    listOf(
+                        Li(listOf(P(listOf(Text("element 1"))))),
+                        Li(listOf(P(listOf(Text("element 2")))))
+                    )
+                )
+            )
+        )
+    )
+}
\ No newline at end of file