diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index d55e8f1..69364f3 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -52,11 +52,11 @@
     - end_section install_r_packages
 
   script:
-    - start_section installing "Installing posterdown (ids)"
+    - start_section installing "Installing posterdown.ids"
     - R -e 'devtools::install()'
     - end_section installing
     - start_section render "Generating demo artifacts"
-    - R_CACHE_ROOTPATH=./cache R -e "require(rmarkdown); render('inst/rmarkdown/templates/posterdown_ids/skeleton/skeleton.Rmd', output_format='posterdown::posterdown_ids', output_dir='target')"
+    - R_CACHE_ROOTPATH=./cache R -e "require(rmarkdown); render('inst/rmarkdown/templates/posterdown_ids/skeleton/skeleton.Rmd', output_format='posterdown.ids::posterdown_ids', output_dir='target')"
     - ./ci/html2pdf target/skeleton.html target/skeleton.pdf 1
     - inkscape -b white --pdf-poppler -o target/skeleton.svg target/skeleton.pdf || true
     - scour -i target/skeleton.svg -o target/skeleton_optimized.svg --enable-viewboxing --enable-id-stripping --shorten-ids --indent=none
diff --git a/DESCRIPTION b/DESCRIPTION
index 611947a..5c50c3e 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,8 +1,13 @@
-Package: posterdown
-Title: Generate PDF Conference Posters Using R Markdown
+Package: posterdown.ids
+Title: Generate IDS CD compliant PDF Conference Posters Using R Markdown
 Version: 2.0
 Authors@R: 
-    c(person(given = "Brent",
+    c(person(given = "Marc",
+             family = "Kupietz",
+             role = c("aut"),
+             comment = c(ORCID = "0000-0001-8997-8256"),
+             email = "kupietz@ids-mannheim.de"),
+      person(given = "Brent",
              family = "Thorne",
              role = c("aut", "cre"),
              email = "brent.thorne18@gmail.com",
@@ -30,5 +35,5 @@
 Encoding: UTF-8
 LazyData: true
 VignetteBuilder: knitr
-RoxygenNote: 7.2.3
+RoxygenNote: 7.3.1
 Roxygen: list(markdown = TRUE)
diff --git a/LICENSE b/LICENSE
index a3a2c22..2288946 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,2 +1,5 @@
 YEAR: 2019
 COPYRIGHT HOLDER: William Brent Thorne
+YEAR: 2024
+COPYRIGHT HOLDER: Marc Kupietz
+
diff --git a/NAMESPACE b/NAMESPACE
index daf7202..5a4dbad 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -1,8 +1,5 @@
 # Generated by roxygen2: do not edit by hand
 
-export(posterdown_betterland)
-export(posterdown_betterport)
-export(posterdown_html)
 export(posterdown_ids)
 export(qrlink)
 importFrom(qrcode,add_logo)
diff --git a/R/posterdown.R b/R/posterdown.R
index b50d351..e226c95 100644
--- a/R/posterdown.R
+++ b/R/posterdown.R
@@ -1,15 +1,12 @@
-#' posterdown package
+#' posterdown.ids package
 #'
 #' This package creates posters for conferences
 #'
 #' @author Brent Thorne
+#' @author Marc Kupietz
 #'
-#' @section poster_html:
-#' Creates an R Markdown template for a PDF poster document via HTML
-#' @section poster_betterland:
-#' Creates an R Markdown template for a PDF poster document via HTML
-#' @section poster_betterport:
-#' Creates an R Markdown template for a PDF poster document via HTML
+#' @section posterdown_ids:
+#' Creates an R Markdown template for a IDS CD compliant PDF poster document via HTML
 #' @docType package
 #' @name posterdown
 NULL
diff --git a/R/posterdown_html.R b/R/posterdown_html.R
index 8e54155..a321229 100644
--- a/R/posterdown_html.R
+++ b/R/posterdown_html.R
@@ -1,24 +1,3 @@
-#' Posterdown HTML format (using pagedown::poster_relaxed)
-#'
-#' @inheritParams pagedown::poster_relaxed
-#' @param ... Additional arguments to `rmarkdown::html_document`
-#'
-#' @return R Markdown output format to pass to
-#'   [rmarkdown::render()]
-#'
-#'@examples
-#'\donttest{
-#'file <- file.path(tempdir(),"foo.rmd")
-#'rmarkdown::draft(file, template="posterdown_html", package="posterdown")
-#'}
-#'
-#' @export
-posterdown_html <- function(...,
-	template = find_resource("posterdown_html", "template.html"),
-	css = NULL) {
-	pagedown::poster_relaxed(..., css = css, template = template)
-}
-
 #' Posterdown IDS-CD based on HTML format (using pagedown::poster_relaxed)
 #'
 #' @inheritParams pagedown::poster_relaxed
@@ -30,12 +9,12 @@
 #'@examples
 #'\donttest{
 #'file <- file.path(tempdir(),"foo.rmd")
-#'rmarkdown::draft(file, template="posterdown_ids", package="posterdown")
+#'rmarkdown::draft(file, template="posterdown_ids", package="posterdown.ids")
 #'}
 #'
-#' @description The output format `poster_ids()` mimics the IDS Mannheim
+#' @description The output format `posterdown_ids()` mimics the IDS Mannheim
 #' corporate design posters.
-#' @rdname posterdown_html
+#' @rdname posterdown_ids
 #' @export
 posterdown_ids <- function(...,
                             template = find_resource("posterdown_ids", "template.html"),
@@ -43,25 +22,6 @@
   pagedown::poster_relaxed(..., css = css, template = template)
 }
 
-#' @description The output format `poster_betterland()` mimics the style of the
-#' BetterPoster movement from twitter.
-#' @rdname posterdown_html
-#' @export
-posterdown_betterland <- function(...,
-                            template = find_resource("posterdown_betterland", "template.html"),
-                            css = NULL) {
-  pagedown::poster_relaxed(..., css = css, template = template)
-}
-
-#' @description The output format `poster_betterport()` mimics the style of the
-#' BetterPoster movement from twitter.
-#' @rdname posterdown_html
-#' @export
-posterdown_betterport <- function(...,
-                                  template = find_resource("posterdown_betterport", "template.html"),
-                                  css = NULL) {
-  pagedown::poster_relaxed(..., css = css, template = template)
-}
 
 #' @description Print html code for a linked qr code to the given url
 #' @importFrom qrcode add_logo qr_code generate_svg
diff --git a/README.md b/README.md
index 83032db..93326d0 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@
 ```markdown
 ---
 output: 
-  posterdown::posterdown_ids
+  posterdown.ids::posterdown_ids
 ---
 ```
 
@@ -27,14 +27,14 @@
 
 ### Additional metadata / customization for IDS version, e.g.:
 ```markdown
-subtitle: Using RMarkdown and `posterdown::posterdown_ids`
+subtitle: Using RMarkdown and `posterdown.ids::posterdown_ids`
 contact:
     name: Marc Kupietz
     department: Digital Linguistics
     email: kupietz@ids-mannheim.de
     website: "http://korap.ids-mannheim.de/instance/icc"
     qrlink: >
-      `r posterdown::qrlink('https://gitlab.ids-mannheim.de/ids/posterdown')`
+      `r posterdown.ids::qrlink('https://gitlab.ids-mannheim.de/ids/posterdown')`
 ```
 
 
diff --git a/inst/rmarkdown/templates/posterdown_betterland/resources/template.html b/inst/rmarkdown/templates/posterdown_betterland/resources/template.html
deleted file mode 100644
index 40f5efb..0000000
--- a/inst/rmarkdown/templates/posterdown_betterland/resources/template.html
+++ /dev/null
@@ -1,418 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"$if(lang)$ lang="$lang$" xml:lang="$lang$"$endif$>
-<head>
-<meta charset="utf-8" />
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="pandoc" />
-<meta name="viewport" content="width=device-width, initial-scale=1">
-
-$for(author-meta)$<meta name="author" content="$author-meta$" />$endfor$
-$if(date-meta)$<meta name="date" content="$date-meta$" />$endif$
-<title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
-
-$for(header-includes)$
-$header-includes$
-$endfor$
-
-$if(highlightjs)$
-<link rel="stylesheet" href="$highlightjs$/$if(highlightjs-theme)$$highlightjs-theme$$else$default$endif$.css" $if(html5)$$else$type="text/css" $endif$/>
-<script src="$highlightjs$/highlight.js"></script>
-<script type="text/javascript">hljs.configure({languages: []}); hljs.initHighlightingOnLoad();</script>
-$endif$
-
-$if(highlighting-css)$<style type="text/css">$highlighting-css$</style>$endif$
-
-$for(css)$
-<link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$/>
-$endfor$
-
-<!--
-Font-awesome icons ie github or twitter
--->
-<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.1/css/all.css" integrity="sha384-50oBUHEmvpQ+1lW4y57PTFmhCaXp0ML5d60M1M7uH2+nqUivzIebhndOJK28anvf" crossorigin="anonymous">
-<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.1/css/brands.css" integrity="sha384-n9+6/aSqa9lBidZMRCQHTHKJscPq6NW4pCQBiMmHdUCvPN8ZOg2zJJTkC7WIezWv" crossorigin="anonymous">
-
-<!--
-Google fonts api stuff
--->
-<link href='https://fonts.googleapis.com/css?family=$if(main_fontfamily)$$main_fontfamily$$else$Special Elite$endif$' rel='stylesheet'>
-<link href='https://fonts.googleapis.com/css?family=$if(font_family)$$font_family$$else$Rasa$endif$' rel='stylesheet'>
-
-<!--
-Here are the required style attributes for css to make this poster work :)
--->
-<style>
-@page {
-size: $if(poster_width)$$poster_width$$else$46in$endif$ $if(poster_height)$$poster_height$$else$32in$endif$;
-margin: 0;
-padding: 0;
-background-color: $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$;
-}
-body {
-margin: 0px;
-padding: 0px;
-width: $if(poster_width)$$poster_width$$else$46in$endif$;
-height: $if(poster_height)$$poster_height$$else$32in$endif$;
-text-align: justify;
-font-size: $if(body_textsize)$$body_textsize$$else$45px$endif$;
-background-color: $if(body_bgcol)$$body_bgcol$$else$#FFFFFF$endif$;
-color: $if(body_textcol)$$body_textcol$$else$#000000$endif$;
-}
-/* RMarkdown Class Styles */
-/* center align leaflet map,
-from https://stackoverflow.com/questions/52112119/center-leaflet-in-a-rmarkdown-document */
-.html-widget {
-margin: auto;
-position: sticky;
-margin-top: 2cm;
-margin-bottom: 2cm;
-}
-.leaflet.html-widget.html-widget-static-bound.leaflet-container.leaflet-touch.leaflet-fade-anim.leaflet-grab.leaflet-touch-drag.leaflet-touch-zoom {
-position: sticky;
-width: 100%;
-}
-pre.sourceCode.r, pre.sourceCode.python {
-background-color: #ffffff20;
-border: solid $if(secondary_colour)$$secondary_colour$$else$#008080$endif$ 1mm;
-border-radius: 0.5em;
-padding: 4mm;
-margin: auto;
-margin-top: 1em;
-margin-bottom: 1em;
-/* align-items: center; */
-}
-div.sourceCode {
-background-color: transparent;
-width: $if(codechunk_width)$$codechunk_width$$else$85%$endif$;
-margin-left: auto;
-margin-right: auto;
-}
-code.sourceCode.r, code.sourceCode.python {
-background-color: transparent;
-font-size: $if(codechunk_textsize)$$codechunk_textsize$$else$20pt$endif$;
-border-radius: 2mm;
-}
-code {
-font-size: 25pt;
-font-family: monospace;
-background-color: $if(secondary_colour)$$secondary_colour$24$else$#00808024$endif$;
-color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-padding: 1.2mm;
-line-height: 1;
-border-radius: 2mm;
-}
-caption {
-margin-bottom: 10px;
-font-size: $if(caption_textsize)$$caption_textsize$$else$20pt$endif$;
-font-style: italic;
-}
-
-tbody tr:nth-child(odd) {
-    background-color: $if(primary_colour)$$primary_colour$$else$#0b4545$endif$20;
-}
-.table>thead>tr>th, .table>tbody>tr>th, .table>tfoot>tr>th, .table>thead>tr>td, .table>tbody>tr>td, .table>tfoot>tr>td{
-  border-spacing: 0;
-  font-size: 40%;
-  border-style: none;
-  padding-top: 15px;
-  padding-bottom: 15px;
-  padding-right: 1em;
-  padding-left: 1em;
-  line-height: 1em;
-}
-table {
-  margin: auto;
-}
-th {
-  padding-left: 5mm;
-  padding-right: 5mm;
-}
-.caption {
-font-size: $if(caption_textzie)$$caption_textsize$$else$20pt$endif$;
-font-style: italic;
-padding-top: 0;
-}
-.references {
-font-size: $if(reference_textsize)$$reference_textsize$$else$20px$endif$;
-line-height: 90%;
-}
-/* Create three unequal columns that floats next to each other */
-.column {
-float: left;
-padding: 0px;
-}
-.outer {
-width: $if(poster_width)$$poster_width$$else$46in$endif$;
-height: $if(poster_height)$$poster_height$$else$32in$endif$;
--webkit-column-count: 2; /* Chrome, Safari, Opera */
--moz-column-count: 2; /* Firefox */
-column-count: 2;
--webkit-column-fill: auto;
--moz-column-fill: auto;
-column-fill: auto;
--webkit-column-rule-width: $if(main_width)$$main_width$$else$0.5$endif$;
--moz-column-rule-width: $if(main_width)$$main_width$$else$0.5$endif$;
-column-rule-width: $if(main_width)$$main_width$$else$0.5$endif$;
--webkit-column-rule-style: solid;
--moz-column-rule-style: solid;
-column-rule-style: solid;
--webkit-column-rule-color: black;
--moz-column-rule-color: black;
-column-rule-color: black;
-$if(main_width)$
--webkit-column-gap: calc($main_width$ * 100%);
-$else$
--webkit-column-gap: 50%;
-$endif$
-background-color: $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$;
-font-family: $if(font_family)$$font_family$$else$Rasa$endif$;
-color: $if(body_textcol)$$body_textcol$$else$#000000$endif$;
-}
-span.citation {
-  color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-  font-weight: bold;
-}
-a {
-text-decoration: none;
-color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-}
-#title {
-font-size: $if(title_textsize)$$title_textsize$$else$125pt$endif$;
-text-align: left;
-margin: 0;
-line-height: 90%;
-border-bottom: 0;
-}
-#author {
-color: $if(author_textcol)$$author_textcol$$else$$if(primary_colour)$$primary_colour$$else$#0b4545$endif$$endif$;
-margin: 0;
-text-align: left;
-line-height: 65%;
-font-size: $if(author_textsize)$$author_textsize$$else$1.17em$endif$;
-}
-#affiliation {
-padding-top: 1em;
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-style: italic;
-font-size: $if(affiliation_textsize)$$affiliation_textsize$$else$25px$endif$;
-margin: 0;
-}
-sup {
-color: $if(accent_colour)$$accent_colour$$else$#cc0000$endif$;
-}
-.affiliation sup {
-font-size: 20px;
-}
-.author sup {
-font-size: 30px;
-}
-.author_extra {
-color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-margin: 0;
-line-height: 85%;
-font-size: $if(authorextra_textsize)$$authorextra_textsize$$else$35px$endif$;
-}
-.outer h1 {
-text-align: center;
-margin-top: 0.5in;
-margin-bottom: 0.5in;
-}
-.outer h2 {
-text-align: center;
-}
-.outer p {
-color: $if(body_textcol)$$body_textcol$$else$#000000$endif$;
-}
-.outer ol {
-text-align: left;
-}
-.main {
-width: calc($if(poster_width)$$poster_width$$else$46in$endif$ * $if(main_width)$$main_width$$else$0.5$endif$);
-height: $if(poster_height)$$poster_height$$else$32in$endif$;
-position: absolute;
-$if(main_width)$
-margin-left: calc($if(poster_width)$$poster_width$$else$46in$endif$ * ((1 - $main_width$) / 2));
-$else$
-margin-left: calc($if(poster_width)$$poster_width$$else$46in$endif$ * 0.25);
-$endif$
-background-color: $if(primary_colour)$$primary_colour$$else$#0b4545$endif$;
-color: $if(main_textcol)$$main_textcol$$else$#FFFFFF90$endif$;
-font-family: $if(main_fontfamily)$$main_fontfamily$$else$Special Elite$endif$;
-$if(main_image)$
-background-image: url($main_image$);
-background-position: center; /* Center the image */
-background-repeat: no-repeat; /* Do not repeat the image */
-background-size: cover; /* Resize the background image to cover the entire container */
-$else$
-background-image: linear-gradient($if(primary_colour)$$primary_colour$$else$#0b4545$endif$ 50%, $if(secondary_colour)$$secondary_colour$$else$#008080$endif$);
-}
-$endif$
-.main strong {
-color: $if(mainstrong_fontcol)$$mainstrong_fontcol$$else$#FFFFFF$endif$;
-}
-img.main-img-left {
-width: $if(mainimage_leftsize)$$mainimage_leftsize$$else$20%$endif$;
-left: 0.5in;
-bottom: 0.2in;
-position: absolute;
-}
-img.main-img-right {
-width: $if(mainimage_rightsize)$$mainimage_rightsize$$else$18%$endif$;
-right: 0.5in;
-bottom: 0.2in;
-position: absolute;
-}
-.main p {
-padding-top: 20%;
-font-size: $if(main_textsize)$$main_textsize$$else$170px$endif$;
-text-align: left;
-}
-.fab {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 25px;
-}
-.twitter, i {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 35px;
-text-decoration: none;
-}
-a.email {
-text-decoration: none;
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 35px;
-}
-.envelope {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 5px;
-text-decoration: none;
-}
-.globe {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 5px;
-text-decoration: none;
-}
-.github > .fab {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 40px;
-text-decoration: none;
-}
-.globetext {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 35px;
-text-decoration: none;
-}
-.poster_wrap {
-width: $if(poster_width)$$poster_width$$else$46in$endif$;
-height: $if(poster_height)$$poster_height$$else$32in$endif$;
-padding: 0cm;
-background-color: $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$;
-}
-span > #tab:mytable {
-  font-weight: bold;
-}
-.section {
-  padding-left: $if(column_padding)$$column_padding$$else$10mm$endif$;
-  padding-right: $if(column_padding)$$column_padding$$else$10mm$endif$;
-}
-.main p {
-  padding-left: $if(main_padding)$$column_padding$$else$30mm$endif$;
-  padding-right: $if(main_padding)$$column_padding$$else$30mm$endif$;
-}
-.main_pic {
-  width: $if(main_picwidth)$$main_picwidth$$else$50%$endif$;
-  display: block;
-  margin-left: auto;
-  margin-right: auto;
-}
-.orcid img {
-  width: 3%;
-}
-</style>
-$if(custom_css)$
-<link rel="stylesheet" href=$custom_css$>
-$else$$endif$
-</head>
-<body>
-
-$for(include-before)$
-$include-before$
-$endfor$
-
-<div class="poster_wrap">
-<div class="column outer">
-<br>
-<div class="title section">
-$if(title)$
-<h1 id="title">$title$</h1>
-<br>
-$else$$endif$
-$if(author)$
-<h3 id="author" class="author">
-
-$for(author)$
-$if(author.main)$
-$author.name$<sup> $author.affil$$if(author.orcid)$, <a class="orcid" href="https://orcid.org/$author.orcid$"><img src="https://raw.githubusercontent.com/brentthorne/posterdown/master/images/orcid.jpg"></a>$else$$endif$</sup><br>
-$if(author.twitter)$<a class="twitter" href="https://mobile.twitter.com/$author.twitter$"><i class="fab fa-twitter"></i>&nbsp;@$author.twitter$</a> <br>
-$else$$endif$
-$if(author.email)$
-<a class='envelope'><i class="fas fa-envelope"></i></a> $author.email$ <br>
-$else$$endif$
-$if(author.website)$
-<a class='globe'><i class="fas fa-globe"></i></a> <a class='globetext'> $author.website$</a> <br>
-$else$$endif$
-$if(author.github)$
-<a class='github'><i class="fab fa-github"></i></a><a class='globetext' href="https://github.com/$author.github$"> &nbsp;@$author.github$</a>
-$else$$endif$
-$else$$endif$
-$sep$ $endfor$
-</h3>
-$else$$endif$
-
-$if(author)$
-<h5 id="author_extra" class="author_extra">
-$for(author)$
-$if(author.main)$
-$else$
-$author.name$<sup>$author.affil$$if(author.orcid)$, <a class="orcid" href="https://orcid.org/$author.orcid$"><img src="https://raw.githubusercontent.com/brentthorne/posterdown/master/images/orcid.jpg"></a>$else$$endif$</sup>
-$endif$
-$sep$ $endfor$
-</h5>
-$else$$endif$
-
-<p id="affiliation" class="affiliation">
-$for(affiliation)$<sup>$affiliation.num$</sup> $affiliation.address$$sep$<br> $endfor$
-</p>
-
-</div>
-$body$
-
-</div>
-<div class="main">
-<p>$for(main_findings)$$main_findings$$sep$<br><br> $endfor$</p>
-$if(logoleft_name)$$logoleft_name$$else$$endif$
-$if(logoright_name)$$logoright_name$$else$$endif$
-</div>
-</div>
-
-$if(math)$
-<!-- dynamically load mathjax for compatibility with self-contained -->
-<script>
-(function () {
-var script = document.createElement("script");
-script.type = "text/javascript";
-var src = "$if(mathjax)$$mathjax$$endif$";
-if (src === "" || src === "true") src = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-MML-AM_CHTML";
-if (location.protocol !== "file:" && /^https?:/.test(src))
-src = src.replace(/^https?:/, '');
-script.src = src;
-document.getElementsByTagName("head")[0].appendChild(script);
-})();
-</script>
-$endif$
-
-$for(include-after)$
-$include-after$
-$endfor$
-
-</body>
-</html>
diff --git a/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.Rmd
deleted file mode 100644
index 44eeba2..0000000
--- a/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.Rmd
+++ /dev/null
@@ -1,113 +0,0 @@
----
-title: A Better Reproducible Poster Title
-author:
-  - name: Brent Thorne
-    affil: 1
-    twitter: brentthorne18
-    email: brentthorne18@gmail.com
-    orcid: 0000-0002-1099-3857
-    main: true
-affiliation:
-  - num: 1
-    address: Department of Earth Sceicnes, Brock University
-main_findings:
-  - "Make **better posters** with RMarkdown + **posterdown**."
-  - '![](https://raw.githubusercontent.com/brentthorne/posterdown/master/images/betterhexlogo.png){.main_pic}'
-logoleft_name: '![](https://raw.githubusercontent.com/brentthorne/posterdown/master/images/qr-code-black.png){.main-img-left}'
-logoright_name: '![](https://raw.githubusercontent.com/brentthorne/posterdown/master/images/betterhexlogo.png){.main-img-right}'
-output: 
-  posterdown::posterdown_betterland:
-    self_contained: false
-    pandoc_args: --mathjax
-    highlight: haddock
-    number_sections: false
-link-citations: true
-bibliography: packages.bib
----
-
-```{r, include=FALSE}
-knitr::opts_chunk$set(results = 'asis',
-                      echo = FALSE,
-                      warning = FALSE,
-                      tidy = FALSE,
-                      message = FALSE,
-                      fig.align = 'center',
-                      out.width = "100%")
-options(knitr.table.format = "html") 
-```
-
-```{r myplot, include=FALSE}
-svg('myplot.svg')
-plot(iris$Sepal.Length, iris$Sepal.Width)
-dev.off()
-```
-
-# Introduction
-
-This is the `posterdown_betterland` template for the {posterdown} package! I was inspired by the twitter thread of [Mike Morrison](https://mobile.twitter.com/mikemorrison/status/1110191245035479041) and wanted to apply the `#betterposter` concept to the reproducible (yet simple to use) functionality of the {posterdown} package [@R-posterdown]. If you're not an R user don't sweat as you do **NOT** need to use it at all! Feel free to use only the Markdown functionality of this package :)
-
-```{r, include=FALSE}
-knitr::write_bib(c('posterdown', 'rmarkdown','pagedown'), 'packages.bib')
-```
-
-## Objectives
-
-1. Pick a template layout.
-2. Write/ create your poster content distraction free.
-3. Let posterdown do its thing!
-
-# Methods
-
-I will show here how to include poster elements that may be useful, such as an equation using mathjax:
-
-$$
-E = mc^2
-$$
-
-To reference a citation you can add your `.bib` file to the working directory and name it in the YAML metadata or generate an automated one as done here, then you only need to reference the label value in the `.bib` file. For example this package is built on top of the wonderful {pagedown} package and I will cite it at the end of this sentance using this in the rmd `[@R-pagedown]` [@R-pagedown].
-
-To get a better understanding of how to include features like these please refer to the {posterdown} [wiki](https://github.com/posterdown/wiki).
-
-**_Now on to the results!_**
-
-<br>
-
-# Results
-
-Here you may have some figures to show off, bellow I have made a scatterplot with the infamous Iris dataset and I can even reference to the figure automatically like this, `Figure \@ref(fig:irisfigure)`, Figure \@ref(fig:irisfigure).
-
-```{r, irisfigure, fig.cap='Here is a caption for the figure. This can be added by using the "fig.cap" option in the r code chunk options, see this [link](https://yihui.name/knitr/options/#plots) from the legend himself, [Yihui Xie](https://twitter.com/xieyihui).', out.width="80%"}
-par(mar=c(2,2,0,1))
-plot(x = iris$Sepal.Length, y = iris$Sepal.Width,
-     col = iris$Species, pch = 19, xlab = "Sepal Length",
-     ylab = "Sepal Width")
-```
-
-Maybe you want to show off some of that fancy code you spent so much time on to make that figure, well you can do that too! Just use the `echo=TRUE` option in the r code chunk options, Figure \@ref(fig:myprettycode)!
-
-```{r myprettycode, echo=FALSE,collapse=TRUE, fig.cap='Boxplots, so hot right now!', fig.height=3.5, out.width="80%"}
-#trim whitespace
-par(mar=c(2,2,0,0))
-#plot boxplots
-boxplot(iris$Sepal.Width~iris$Species,
-        col = "#008080", 
-        border = "#0b4545",
-        ylab = "Sepal Width (cm)",
-        xlab = "Species")
-```
-
-How about a neat table of data? See, Table \@ref(tab:iristable):
-
-```{r, iristable}
-knitr::kable(
-  iris[1:8,1:5], format = "html",
-  caption = "A table made with the **knitr::kable** function.",
-  align = "c", col.names = c("Sepal <br> Length",
-                             "Sepal <br> Width",
-                             "Petal <br> Length",
-                             "Petal <br> Width",
-                             "Species"),
-  escape = FALSE)
-```
-
-# References
diff --git a/inst/rmarkdown/templates/posterdown_betterland/template.yaml b/inst/rmarkdown/templates/posterdown_betterland/template.yaml
deleted file mode 100644
index 0406c1f..0000000
--- a/inst/rmarkdown/templates/posterdown_betterland/template.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-name: Posterdown Betterland
-description: >
- Template for creating R Markdown based PDF posters via HTML, CSS and the Better Poster Style
-create_dir: false
diff --git a/inst/rmarkdown/templates/posterdown_betterport/resources/template.html b/inst/rmarkdown/templates/posterdown_betterport/resources/template.html
deleted file mode 100644
index 81735d3..0000000
--- a/inst/rmarkdown/templates/posterdown_betterport/resources/template.html
+++ /dev/null
@@ -1,469 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"$if(lang)$ lang="$lang$" xml:lang="$lang$"$endif$>
-<head>
-<meta charset="utf-8" />
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="pandoc" />
-<meta name="viewport" content="width=device-width, initial-scale=1">
-
-$for(author-meta)$<meta name="author" content="$author-meta$" />$endfor$
-$if(date-meta)$<meta name="date" content="$date-meta$" />$endif$
-<title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
-
-$for(header-includes)$
-$header-includes$
-$endfor$
-
-$if(highlightjs)$
-<link rel="stylesheet" href="$highlightjs$/$if(highlightjs-theme)$$highlightjs-theme$$else$default$endif$.css" $if(html5)$$else$type="text/css" $endif$/>
-<script src="$highlightjs$/highlight.js"></script>
-<script type="text/javascript">hljs.configure({languages: []}); hljs.initHighlightingOnLoad();</script>
-$endif$
-
-$if(highlighting-css)$<style type="text/css">$highlighting-css$</style>$endif$
-
-$for(css)$
-<link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$/>
-$endfor$
-
-<!--
-Font-awesome icons ie github or twitter
--->
-<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.1/css/all.css" integrity="sha384-50oBUHEmvpQ+1lW4y57PTFmhCaXp0ML5d60M1M7uH2+nqUivzIebhndOJK28anvf" crossorigin="anonymous">
-<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.1/css/brands.css" integrity="sha384-n9+6/aSqa9lBidZMRCQHTHKJscPq6NW4pCQBiMmHdUCvPN8ZOg2zJJTkC7WIezWv" crossorigin="anonymous">
-
-<!--
-Google fonts api stuff
--->
-<link href='https://fonts.googleapis.com/css?family=$if(main_fontfamily)$$main_fontfamily$$else$Special Elite$endif$' rel='stylesheet'>
-<link href='https://fonts.googleapis.com/css?family=$if(font_family)$$font_family$$else$Rasa$endif$' rel='stylesheet'>
-
-<!--
-Here are the required style attributes for css to make this poster work :)
--->
-<style>
-@page {
-size: $if(poster_width)$$poster_width$$else$36in$endif$ $if(poster_height)$$poster_height$$else$48in$endif$;
-margin: 0;
-padding: 0;
-}
-body {
-margin: 0px;
-padding: 0px;
-width: $if(poster_width)$$poster_width$$else$36in$endif$;
-height: $if(poster_height)$$poster_height$$else$48in$endif$;
-text-align: justify;
-font-size: $if(body_textsize)$$body_textsize$$else$45px$endif$;
-line-height: 1.05;
-}
-/* RMarkdown Class Styles */
-/* center align leaflet map,
-from https://stackoverflow.com/questions/52112119/center-leaflet-in-a-rmarkdown-document */
-.html-widget {
-margin: auto;
-position: sticky;
-margin-top: 2cm;
-margin-bottom: 2cm;
-}
-.leaflet.html-widget.html-widget-static-bound.leaflet-container.leaflet-touch.leaflet-fade-anim.leaflet-grab.leaflet-touch-drag.leaflet-touch-zoom {
-position: sticky;
-width: 100%;
-}
-pre.sourceCode.r, pre.sourceCode.python {
-background-color: #ffffff20;
-border: solid $if(secondary_colour)$$secondary_colour$$else$#008080$endif$ 1mm;
-border-radius: 0.5em;
-padding: 4mm;
-margin: auto;
-margin-top: 1em;
-margin-bottom: 1em;
-/* align-items: center; */
-}
-div.sourceCode {
-background-color: transparent;
-width: $if(codechunk_width)$$codechunk_width$$else$85%$endif$;
-margin-left: auto;
-margin-right: auto;
-}
-code.sourceCode.r, code.sourceCode.python {
-background-color: transparent;
-font-size: $if(codechunk_textsize)$$codechunk_textsize$$else$20pt$endif$;
-border-radius: 2mm;
-}
-code {
-font-size: 25pt;
-font-family: monospace;
-background-color: $if(secondary_colour)$$secondary_colour$24$else$#00808024$endif$;
-color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-padding: 1.2mm;
-line-height: 1;
-border-radius: 2mm;
-}
-caption {
-margin-bottom: 10px;
-font-size: $if(caption_textsize)$$caption_textsize$$else$20pt$endif$;
-font-style: italic;
-}
-
-tbody tr:nth-child(odd) {
-    background-color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$20;
-}
-.table>thead>tr>th, .table>tbody>tr>th, .table>tfoot>tr>th, .table>thead>tr>td, .table>tbody>tr>td, .table>tfoot>tr>td{
-  border-spacing: 0;
-  font-size: 40%;
-  border-style: none;
-  padding-top: 15px;
-  padding-bottom: 15px;
-  padding-right: 1em;
-  padding-left: 1em;
-  line-height: 1em;
-}
-table {
-  margin: auto;
-}
-th {
-  padding-left: 5mm;
-  padding-right: 5mm;
-}
-.caption {
-font-size: $if(caption_textsize)$$caption_textsize$$else$20pt$endif$;
-font-style: italic;
-padding-top: 0;
-}
-.references {
-font-size: $if(reference_textsize)$$reference_textsize$$else$20px$endif$;
-line-height: 90%;
-}
-/* Create three unequal columns that floats next to each other */
-.column {
-float: left;
-padding: 0px;
-}
-.outer {
-width: $if(poster_width)$$poster_width$$else$36in$endif$;
-height: calc($if(poster_height)$$poster_height$$else$48in$endif$ * $if(main_topsize)$ (1 - $main_topsize$ - $main_bottomsize$ - 0.01) $else$ 0.6325 $endif$);
--webkit-column-count: $if(column_numbers)$$column_numbers$$else$3$endif$; /* Chrome, Safari, Opera */
--moz-column-count: $if(column_numbers)$$column_numbers$$else$3$endif$; /* Firefox */
-column-count: $if(column_numbers)$$column_numbers$$else$3$endif$;
--webkit-column-fill: auto;
--moz-column-fill: auto;
-column-fill: auto;
-column-gap: 0;
-padding-left: 0cm;
-padding-right: 0cm;
-/* -webkit-column-rule-width: 50%;
--moz-column-rule-width: 50%;
-column-rule-width: 50%; */
--webkit-column-rule-style: none;
--moz-column-rule-style: none;
-column-rule-style: none;
--webkit-column-rule-color: black;
--moz-column-rule-color: black;
-column-rule-color: black;
-background-color: $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$;
-font-family: $if(font_family)$$font_family$$else$Rasa$endif$;
-margin-top: calc($if(poster_height)$$poster_height$$else$48in$endif$ * $if(main_topsize)$ $main_topsize$ $else$ 0.25 $endif$);
-padding-top: 1em;
-padding-bottom: 1em;
-}
-span.citation {
-  color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-  font-weight: bold;
-}
-a {
-text-decoration: none;
-color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-}
-#title {
-font-size: $if(title_textsize)$$title_textsize$$else$125pt$endif$;
-text-align: left;
-margin: 0;
-line-height: 98%;
-border-bottom: 0;
-font-weight: normal;
-background: 0;
-}
-#author {
-color:$if(author_textcol)$$author_textcol$$else$$if(primary_colour)$$primary_colour$$else$#0b4545$endif$$endif$;
-margin: 0;
-line-height: 85%;
-font-size: $if(author_textsize)$$author_textsize$$else$1.17em$endif$;
-}
-#affiliation {
-padding-top: 0.1em;
-color: $affiliation_textcol$;
-font-style: italic;
-font-size: $if(affiliation_textsize)$$affiliation_textsize$$else$25px$endif$;
-margin: 0;
-}
-sup {
-color: $if(accent_colour)$$accent_colour$$else$#cc0000$endif$;
-}
-.affiliation sup {
-font-size: 20px;
-}
-.author {
-text-align: left;
-}
-.author sup {
-font-size: 30px;
-}
-.author_extra {
-color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-margin: 0;
-line-height: 85%;
-font-size: $if(authorextra_textsize)$$authorextra_textsize$$else$35px$endif$;
-text-align: left;
-}
-.outer h1, h2, h3, h4, h5, h6 {
-text-align: center;
-margin: 0;
-font-weight: bold;
-}
-.section h1 {
-  text-align:center;
-  padding-bottom:5px;
-  background:
-    linear-gradient(
-      to left,
-      $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$ 1%,
-      $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$ 20%,
-      $if(primary_colour)$$primary_colour$$else$#0b4545$endif$75 33%,
-      $if(primary_colour)$$primary_colour$$else$#0b4545$endif$ 50%,
-      $if(primary_colour)$$primary_colour$$else$#0b4545$endif$75 66%,
-      $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$ 80%,
-      $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$ 99%
-    )
-    left
-    bottom
-    $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$
-    no-repeat;
-  background-size:100% 5px ;
-  margin-top: 0.5em;
-  margin-bottom: 0.5em;
-}
-.outer h2 {
-text-align: center;
-}
-.outer p, .level2 {
-color: $if(body_textcol)$$body_textcol$$else$#000000$endif$;
-}
-.outer ol {
-padding-left: 8%;
-padding-right: 8%;
-text-align: left;
-}
-.main {
-width: $if(poster_width)$$poster_width$$else$36in$endif$;
-height: calc($if(poster_height)$$poster_height$$else$48in$endif$ * $if(main_topsize)$$main_topsize$$else$0.25$endif$);
-position: absolute;
-background-color: $if(primary_colour)$$primary_colour$$else$#0b4545$endif$;
-color: $if(main_textcol)$$main_textcol$$else$#ffffff$endif$$if(main_textalpha)$$main_textalpha$$else$90$endif$;
-font-family: $if(main_fontfamily)$$main_fontfamily$$else$Special Elite$endif$;
-background-image: linear-gradient($if(primary_colour)$$primary_colour$$else$#0b4545$endif$ 50%,$if(secondary_colour)$$secondary_colour$$else$#008080$endif$);
-}
-.main strong {
-color: $if(main_textcol)$$main_textcol$$else$#ffffff$endif$;
-}
-.main strong > sup {
-color: $if(main_textcol)$$main_textcol$$else$#ffffff$endif$;
-}
-.main sup {
-color: $if(main_textcol)$$main_textcol$$else$#ffffff$endif$$if(main_textalpha)$$main_textalpha$$else$90$endif$;
-}
-#main-img-left {
-width: 10%;
-left: 0.5in;
-bottom: 0.2in;
-position: absolute;
-}
-#main-img-center {
-width: 10%;
-left: calc($if(poster_width)$$poster_width$$else$36in$endif$ * 0.45);
-bottom: 0.5in;
-position: absolute;
-}
-#main-img-right {
-width: 10%;
-right: 0.5in;
-bottom: 0.2in;
-position: absolute;
-}
-.main p {
-font-size: $if(main_textsize)$$main_textsize$$else$150px$endif$;
-font-family: $if(main_fontfamily)$$main_fontfamily$$else$Special Elite$endif$;
-text-align: $if(main_textalign)$$main_textalign$$else$center$endif$;
-margin: 0;
-position: absolute;
-top: 50%;
--ms-transform: translateY(-50%);
-transform: translateY(-50%);
-margin-left: 1em;
-}
-.fab {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 25px;
-}
-.twitter, i {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 35px;
-text-decoration: none;
-}
-a.email {
-text-decoration: none;
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 35px;
-}
-.envelope {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 5px;
-text-decoration: none;
-}
-.globe {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 5px;
-text-decoration: none;
-}
-.globetext {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#00000060$endif$;
-font-size: 35px;
-text-decoration: none;
-}
-.poster_wrap {
-width: $if(poster_width)$$poster_width$$else$36in$endif$;
-height: $if(poster_height)$$poster_height$$else$48in$endif$;
-padding: 0cm;
-}
-.main_bottom {
-width: $if(poster_width)$$poster_width$$else$36in$endif$;
-height: calc($if(poster_height)$$poster_height$$else$48in$endif$ * $if(main_bottomsize)$$main_bottomsize$$else$0.1$endif$);
-margin-top: calc($if(poster_height)$$poster_height$$else$48in$endif$ * $if(main_bottomsize)$(1 - $main_bottomsize$)$else$0.9$endif$);
-position: absolute;
-background-color: $if(primary_colour)$$primary_colour$$else$#0b4545$endif$;
-background-image: linear-gradient($if(secondary_colour)$$secondary_colour$$else$#008080$endif$ 10%, $if(primary_colour)$$primary_colour$$else$#0b4545$endif$);
-}
-.section {
-  padding-left: $if(column_padding)$$column_padding$$else$10mm$endif$;
-  padding-right: $if(column_padding)$$column_padding$$else$10mm$endif$;
-}
-span > #tab:mytable {
-  font-weight: bold;
-}
-.orcid img {
-  width: 3%;
-}
-.emphasis {
-  background-color: #008080;
-  color: #ffffff;
-  border: solid #0b2045 3mm;
-  margin: 1em;
-  padding-left: 0;
-  padding-right: 0;
-}
-.emphasis h1 {
-  font-weight: bold;
-  background: none;
-  background-color: #0b2045;
-  padding-bottom: 5mm;
-  padding-top: 1mm;
-  margin-top: -1mm;
-  margin-right: -1mm;
-  margin-left: -1mm;
-}
-.emphasis blockquote {
-  border: 0;
-}
-.emphasis ol {
-  padding: 0;
-  padding-left: 8%;
-  font-size: 100%;
-  font-weight: bold;
-}
-.emphasis p {
-  color: #ffffff;
-}
-</style>
-$if(custom_css)$
-<link rel="stylesheet" href=$custom_css$>
-$else$$endif$
-</head>
-<body>
-
-$for(include-before)$
-$include-before$
-$endfor$
-
-<div class="poster_wrap">
-
-<div class="column outer">
-<div class="section">
-$if(title)$<h1 id="title">$title$</h1><br>$else$$endif$
-$if(author)$<h3 id="author" class="author">
-
-$for(author)$
-$if(author.main)$
-$author.name$<sup> $author.affil$$if(author.orcid)$, <a class="orcid" href="https://orcid.org/$author.orcid$"><img src="https://raw.githubusercontent.com/brentthorne/posterdown/master/images/orcid.jpg"></a>$else$$endif$</sup><br>
-$if(author.twitter)$<a class="twitter" href="https://mobile.twitter.com/$author.twitter$"><i class="fab fa-twitter"></i>&nbsp;&nbsp;@$author.twitter$</a><br>
-$else$$endif$
-$if(author.email)$
-<a class='envelope'><i class="fas fa-envelope"></i></a> $author.email$ <br>
-$else$$endif$
-$if(author.website)$
-<a class='globe'><i class="fas fa-globe"></i></a> <a class='globetext' href="$author.website$">$author.website$</a> <br>
-$else$$endif$
-$else$$endif$
-$sep$ $endfor$
-</h3>
-
-<h5 id="author_extra", class="author_extra">
-$for(author)$
-$if(author.main)$
-$else$
-$author.name$<sup>$author.affil$$if(author.orcid)$, <a class="orcid" href="https://orcid.org/$author.orcid$"><img src="https://raw.githubusercontent.com/brentthorne/posterdown/master/images/orcid.jpg"></a>$else$$endif$</sup>
-$endif$
-$sep$ $endfor$
-</h5>
-$else$$endif$
-
-$if(affiliation)$
-<p id="affiliation" class="affiliation">
-$for(affiliation)$<sup>$affiliation.num$</sup> $affiliation.address$$sep$<br> $endfor$
-</p>
-$else$$endif$
-</div>
-
-$body$
-
-</div>
-<div class="main">
-<p>$for(main_findings)$$main_findings$$sep$<br><br> $endfor$</p>
-</div>
-<div class="main_bottom">
-<img id="main-img-left" src=$if(logoleft_name)$$logoleft_name$$else$$endif$>
-<img id="main-img-center" src=$if(logocenter_name)$$logocenter_name$$else$$endif$>
-<img id="main-img-right" src=$if(logoright_name)$$logoright_name$$else$$endif$>
-</div>
-</div>
-
-$if(math)$
-<!-- dynamically load mathjax for compatibility with self-contained -->
-<script>
-(function () {
-var script = document.createElement("script");
-script.type = "text/javascript";
-var src = "$if(mathjax)$$mathjax$$endif$";
-if (src === "" || src === "true") src = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-MML-AM_CHTML";
-if (location.protocol !== "file:" && /^https?:/.test(src))
-src = src.replace(/^https?:/, '');
-script.src = src;
-document.getElementsByTagName("head")[0].appendChild(script);
-})();
-</script>
-$endif$
-
-$for(include-after)$
-$include-after$
-$endfor$
-
-</body>
-</html>
diff --git a/inst/rmarkdown/templates/posterdown_betterport/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/posterdown_betterport/skeleton/skeleton.Rmd
deleted file mode 100644
index d9a7dad..0000000
--- a/inst/rmarkdown/templates/posterdown_betterport/skeleton/skeleton.Rmd
+++ /dev/null
@@ -1,124 +0,0 @@
----
-main_topsize: 0.2 #percent coverage of the poster
-main_bottomsize: 0.1
-#ESSENTIALS
-title: '**A Better Reproducible Poster Title**'
-author:
-  - name: '**W. Brent Thorne**'
-    affil: 1
-    main: true
-    orcid: '0000-0002-1099-3857'
-    twitter: brentthorne18 
-    email: bthorne2@brocku.ca
-  - name: Another G. Contributor
-    affil: 2
-    main: true
-    email: 'ag.con@posterdown.net'
-  - name: Person Three
-    affil: 3
-  - name: Person Four
-    affil: 2
-  - name: Person Five
-    affil: 3
-  - name: Person Six
-    affil: 3
-  - name: A. Seventh Author
-    affil: 2
-affiliation:
-  - num: 1
-    address: Department of Earth Science, Brock University
-  - num: 2
-    address: Department of Graphics and Layouts, University of Posters; Canada
-  - num: 3
-    address: Another Institute of a place where work gets done, Earth, Milky Way
-main_findings:
-  - "Make **better posters** with RMarkdown + **posterdown**."
-logoleft_name: https&#58;//raw.githubusercontent.com/brentthorne/posterdown/master/images/betterhexlogo.png
-logoright_name: https&#58;//raw.githubusercontent.com/brentthorne/posterdown/master/images/betterhexlogo.png
-logocenter_name: https&#58;//raw.githubusercontent.com/brentthorne/posterdown/master/images/qr-code-black.png
-output: 
-  posterdown::posterdown_betterport:
-    self_contained: false
-    pandoc_args: --mathjax
-    number_sections: false
-bibliography: packages.bib
-link-citations: true
----
-
-```{r, include=FALSE}
-knitr::opts_chunk$set(echo = FALSE,
-                      warning = FALSE,
-                      tidy = FALSE,
-                      message = FALSE,
-                      fig.align = 'center',
-                      out.width = "100%")
-options(knitr.table.format = "html") 
-```
-
-# Introduction
-
-This is the `posterdown_betterport` template for the {posterdown} package! I was inspired by the twitter thread of [Mike Morrison](https://mobile.twitter.com/mikemorrison/status/1110191245035479041) and wanted to apply the `#betterposter` concept to the reproducible (yet simple to use) functionality of the {posterdown} package [@R-posterdown]. If you're not an R user don't sweat as you do **NOT** need to use it at all! Feel free to use only the Markdown functionality of this package :)
-
-```{r, include=FALSE}
-knitr::write_bib(c('posterdown', 'rmarkdown','pagedown'), 'packages.bib')
-```
-
-## Objectives
-
-1. Pick a template layout.
-2. Write/ create your poster content distraction free.
-3. Let posterdown do its thing!
-
-# Methods
-
-I will show here how to include poster elements that may be useful, such as an equation using mathjax:
-
-$$
-E = mc^2
-$$
-
-To reference a citation you can add your `.bib` file to the working directory and name it in the YAML metadata or generate an automated one as done here, then you only need to reference the label value in the `.bib` file. For example this package is built on top of the wonderful {pagedown} package and I will cite it at the end of this sentance using this in the rmd `[@R-pagedown]` [@R-pagedown].
-
-To get a better understanding of how to include features like these please refer to the {posterdown} [wiki](https://github.com/posterdown/wiki).
-
-**_Now on to the results!_**
-
-# Results
-
-Here you may have some figures to show off, bellow I have made a scatterplot with the infamous Iris dataset and I can even reference to the figure automatically like this, `Figure \@ref(fig:irisfigure)`, Figure \@ref(fig:irisfigure).
-
-```{r, irisfigure, fig.cap='Here is a caption for the figure. This can be added by using the "fig.cap" option in the r code chunk options, see this [link](https://yihui.name/knitr/options/#plots) from the legend himself, [Yihui Xie](https://twitter.com/xieyihui).', out.width="80%"}
-par(mar=c(2,2,0,1))
-plot(x = iris$Sepal.Length, y = iris$Sepal.Width,
-     col = iris$Species, pch = 19, xlab = "Sepal Length",
-     ylab = "Sepal Width")
-```
-
-Maybe you want to show off some of that fancy code you spent so much time on to make that figure, well you can do that too! Just use the `echo=TRUE` option in the r code chunk options, Figure \@ref(fig:myprettycode)!
-
-```{r myprettycode, echo=TRUE, fig.cap='Boxplots, so hot right now!', fig.height=6, out.width="80%"}
-#trim whitespace
-par(mar=c(2,2,0,0))
-#plot boxplots
-boxplot(iris$Sepal.Width~iris$Species,
-        col = "#008080", 
-        border = "#0b4545",
-        ylab = "Sepal Width (cm)",
-        xlab = "Species")
-```
-
-How about a neat table of data? See, Table \@ref(tab:iristable):
-
-```{r, iristable}
-knitr::kable(
-  iris[1:15,1:5], format = "html",
-  caption = "A table made with the **knitr::kable** function.",
-  align = "c", col.names = c("Sepal <br> Length",
-                             "Sepal <br> Width",
-                             "Petal <br> Length",
-                             "Petal <br> Width",
-                             "Species"),
-  escape = FALSE)
-```
-
-# References
diff --git a/inst/rmarkdown/templates/posterdown_betterport/template.yaml b/inst/rmarkdown/templates/posterdown_betterport/template.yaml
deleted file mode 100644
index d80bd28..0000000
--- a/inst/rmarkdown/templates/posterdown_betterport/template.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-name: Posterdown HTML Betterport
-description: >
- Template for creating R Markdown based PDF posters via HTML, CSS and the Better Poster Style
-create_dir: false
diff --git a/inst/rmarkdown/templates/posterdown_html/resources/template.html b/inst/rmarkdown/templates/posterdown_html/resources/template.html
deleted file mode 100644
index f22b870..0000000
--- a/inst/rmarkdown/templates/posterdown_html/resources/template.html
+++ /dev/null
@@ -1,373 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml"$if(lang)$ lang="$lang$" xml:lang="$lang$"$endif$>
-<head>
-<meta charset="utf-8" />
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
-<meta name="generator" content="pandoc" />
-<meta name="viewport" content="width=device-width, initial-scale=1">
-
-
-<!--
-Font-awesome icons ie github or twitter
--->
-<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.1/css/all.css" integrity="sha384-50oBUHEmvpQ+1lW4y57PTFmhCaXp0ML5d60M1M7uH2+nqUivzIebhndOJK28anvf" crossorigin="anonymous">
-<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.1/css/brands.css" integrity="sha384-n9+6/aSqa9lBidZMRCQHTHKJscPq6NW4pCQBiMmHdUCvPN8ZOg2zJJTkC7WIezWv" crossorigin="anonymous">
-
-<!--
-Google fonts api stuff
--->
-$if(font_family)$
-<link href='https://fonts.googleapis.com/css?family=$font_family$' rel='stylesheet'>
-$endif$
-$if(titletext_fontfamily)$
-<link href='https://fonts.googleapis.com/css?family=$titletext_fontfamily$' rel='stylesheet'>
-$endif$
-
-$for(author-meta)$<meta name="author" content="$author-meta$" />$endfor$
-$if(date-meta)$<meta name="date" content="$date-meta$" />$endif$
-<title>$if(title-prefix)$$title-prefix$ - $endif$$pagetitle$</title>
-
-$for(header-includes)$
-$header-includes$
-$endfor$
-
-$if(highlightjs)$
-<link rel="stylesheet" href="$highlightjs$/$if(highlightjs-theme)$$highlightjs-theme$$else$default$endif$.css" $if(html5)$$else$type="text/css" $endif$/>
-<script src="$highlightjs$/highlight.js"></script>
-<script type="text/javascript">hljs.configure({languages: []}); hljs.initHighlightingOnLoad();</script>
-$endif$
-
-$if(highlighting-css)$<style type="text/css">$highlighting-css$</style>$endif$
-$for(css)$
-<link rel="stylesheet" href="$css$" $if(html5)$$else$type="text/css" $endif$/>
-$endfor$
-
-<style>
-@page {
-size: $if(poster_width)$$poster_width$$else$45in$endif$ $if(poster_height)$$poster_height$$else$38in$endif$;
-margin: 0;
-padding: 0;
-}
-body {
-margin: 0;
-font-size: $if(body_textsize)$$body_textsize$$else$45px$endif$;
-width: $if(poster_width)$$poster_width$$else$45in$endif$;
-height: $if(poster_height)$$poster_height$$else$38in$endif$;
-padding: 0;
-text-align: justify;
-font-family: $if(font_family)$$font_family$$else$Palatino$endif$;
-}
-.poster_wrap {
-width: $if(poster_width)$$poster_width$$else$45in$endif$;
-height: $if(poster_height)$$poster_height$$else$38in$endif$;
-padding: 0cm;
-}
-.title_container {
-width: $if(titlebox_borderwidth)$calc(100% - $titlebox_borderwidth$ - $titlebox_borderwidth$)$else$100%$endif$;
-height: $if(titlebox_borderwidth)$calc($if(titlebox_height)$$titlebox_height$$else$15%$endif$ - $titlebox_borderwidth$ - $titlebox_borderwidth$)$else$$if(titlebox_height)$$titlebox_height$$else$15%$endif$$endif$;
-overflow: hidden;
-background-color: $if(primary_colour)$$primary_colour$$else$#0b4545$endif$;
-border: $if(titlebox_borderwidth)$$titlebox_borderwidth$$else$0$endif$ solid $if(titlebox_bordercol)$$titlebox_bordercol$$else$$if(primary_colour)$$primary_colour$$else$#0b4545$endif$
-$endif$;
-}
-.logo_left {
-float: left;
-width: 10%;
-height: 100%;
-background-color: $if(primary_colour)$$primary_colour$$else$#0b4545$endif$;
-display: flex;
-align-items: center;
-justify-content: center;
-}
-.logo_right {
-float: right;
-width: 10%;
-height: 100%;
-background-color: $if(primary_colour)$$primary_colour$$else$#0b4545$endif$;
-display: flex;
-align-items: center;
-justify-content: center;
-}
-.poster_title {
-text-align: center;
-position: relative;
-float: left;
-width: 80%;
-height: 100%;
-color: $if(title_textcol)$$title_textcol$$else$#FFFFFF$endif$;
-top: 50%;
-transform: translateY(-50%);
--webkit-transform: translateY(-50%);
-}
-#title {
-font-family: $if(titletext_fontfamily)$$titletext_fontfamily$$else$$if(font_family)$$font_family$$else$Palatino$endif$$endif$;
-}
-/* unvisited link */
-a:link {
-color: $if(link_col)$$link_col$$else$$if(accent_colour)$$accent_colour$$else$#008080$endif$$endif$;
-text-decoration: none;
-}
-.mybreak {
-  break-before: column;
-}
-/* visited link */
-a:visited {
-color: $if(link_col)$$link_col$$else$$if(accent_colour)$$accent_colour$$else$#008080$endif$$endif$;
-text-decoration: none;
-}
-
-/* mouse over link */
-a:hover {
-color: $if(link_col)$$link_col$$else$$if(accent_colour)$$accent_colour$$else$#008080$endif$$endif$;
-text-decoration: none;
-}
-
-/* selected link */
-a:active {
-color: $if(link_col)$$link_col$$else$$if(accent_colour)$$accent_colour$$else$#008080$endif$$endif$;
-text-decoration: none;
-}
-.poster_body {
--webkit-column-count: $if(column_numbers)$$column_numbers$$else$3$endif$; /* Chrome, Safari, Opera */
--moz-column-count: $if(column_numbers)$$column_numbers$$else$3$endif$; /* Firefox */
-column-count: $if(column_numbers)$$column_numbers$$else$3$endif$;
--webkit-column-fill: auto;
--moz-column-fill: auto;
-column-fill: auto;
--webkit-column-rule-width: $if(columnline_width)$$columnline_width$$else$1mm$endif$;
--moz-column-rule-width: $if(columnline_width)$$columnline_width$$else$1mm$endif$;
-column-rule-width: $if(columnline_width)$$columnline_width$$else$1mm$endif$;
--webkit-column-rule-style: $if(columnline_style)$$columnline_style$$else$dashed$endif$;
--moz-column-rule-style: $if(columnline_style)$$columnline_style$$else$dashed$endif$;
-column-rule-style: $if(columnline_style)$$columnline_style$$else$dashed$endif$;
--webkit-column-rule-color: $if(columnline_col)$$columnline_col$$else$$if(primary_colour)$$primary_colour$$else$#0b4545$endif$$endif$;
--moz-column-rule-color: $if(columnline_col)$$columnline_col$$else$$if(primary_colour)$$primary_colour$$else$#0b4545$endif$$endif$;
-column-rule-color: $if(columnline_col)$$columnline_col$$else$$if(primary_colour)$$primary_colour$$else$#0b4545$endif$$endif$;
-column-gap: 1em;
-padding-left: 0.5em;
-padding-right: 0.5em;
-height: 100%;
-color: $if(body_textcol)$$body_textcol$$else$#000000$endif$
-background-color: $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$;
-}
-.poster_title h1 {
-font-size: $if(title_textsize)$$title_textsize$$else$75pt$endif$;
-margin: 0;
-border: 0;
-font-weight: normal;
-}
-.poster_body_wrap{
-width: $if(poster_width)$$poster_width$$else$45in$endif$;
-height: calc(100% - $if(titlebox_height)$$titlebox_height$$else$17%$endif$);
-padding-top: calc($if(poster_height)$$poster_height$$else$38in$endif$ * 0.01);
-padding-bottom: calc($if(poster_height)$$poster_height$$else$38in$endif$ * 0.01);
-background-color: $if(body_bgcol)$$body_bgcol$$else$#ffffff$endif$;
-}
-.poster_title h3 {
-color: $if(author_textcol)$$author_textcol$$else$$if(secondary_colour)$$secondary_colour$$else$#ffffff$endif$$endif$;
-font-size: $if(author_textsize)$$author_textsize$$else$50pt$endif$;
-margin: 0;
-border: 0;
-font-weight: normal;
-}
-.poster_title h3 > sup {
-  font-size: 35pt;
-  margin-left: 0.02em;
-}
-.poster_title h5 {
-color: $if(affiliation_textcol)$$affiliation_textcol$$else$#FFFFFF$endif$;
-font-size: $if(affiliation_textsize)$$affiliation_texsize$$else$35pt$endif$;
-margin: 0;
-border: 0;
-font-weight: normal;
-}
-img {
-margin-top: 0;
-margin-bottom: 0;
-}
-.section {
-  padding: 0.2em;
-}
-.poster_body h1 {
-text-align: center;
-color: $if(sectitle_textcol)$$sectitle_textcol$$else$#FFFFFF$endif$;
-font-size: $if(sectitle_textsize)$$sectitle_textsize$$else$65pt$endif$;
-border: $if(sectitle_borderwidth)$$sectitle_borderwidth$$else$2mm$endif$ solid $if(sectitle_bordercol)$$sectitle_bordercol$$else$$if(primary_colour)$$primary_colour$$else$#0b4545$endif$$endif$;
-background-color: $if(sectitle_bgcol)$$sectitle_bgcol$$else$$if(primary_colour)$$primary_colour$$else$#0b4545$endif$$endif$;
-border-radius: $if(sectitle_boxshape)$$sectitle_boxshape$$else$4mm 0mm$endif$;
-margin-top: 2mm;
-margin-bottom: 2mm;
-font-weight: normal;
-}
-.poster_body h2 {
-color: $if(sectitle2_textcol)$$sectitle2_textcol$$else$#000000$endif$;
-font-size: $if(sectitle2_textsize)$$sectitle2_textsize$$else$40pt$endif$;
-padding-left: 4mm;
-font-weight: normal;
-}
-.span {
-width: 200%;
-}
-/* center align leaflet map,
-from https://stackoverflow.com/questions/52112119/center-leaflet-in-a-rmarkdown-document */
-.html-widget {
-margin: auto;
-position: sticky;
-margin-top: 2cm;
-margin-bottom: 2cm;
-}
-.leaflet.html-widget.html-widget-static-bound.leaflet-container.leaflet-touch.leaflet-fade-anim.leaflet-grab.leaflet-touch-drag.leaflet-touch-zoom {
-position: sticky;
-width: 100%;
-}
-pre.sourceCode.r, pre.sourceCode.python {
-background-color: #ffffff20;
-border: solid $if(secondary_colour)$$secondary_colour$$else$#008080$endif$ 1mm;
-border-radius: 0.5em;
-padding: 4mm;
-margin: auto;
-margin-top: 1em;
-margin-bottom: 1em;
-/* align-items: center; */
-}
-div.sourceCode {
-background-color: transparent;
-width: $if(codechunk_width)$$codechunk_width$$else$85%$endif$;
-margin-left: auto;
-margin-right: auto;
-}
-code.sourceCode.r, code.sourceCode.python {
-background-color: transparent;
-font-size: $if(codechunk_textsize)$$codechunk_textsize$$else$20pt$endif$;
-border-radius: 2mm;
-}
-code {
-font-size: 25pt;
-font-family: monospace;
-background-color: $if(secondary_colour)$$secondary_colour$24$else$#00808024$endif$;
-color: $if(secondary_colour)$$secondary_colour$$else$#008080$endif$;
-padding: 1.2mm;
-line-height: 1;
-border-radius: 2mm;
-}
-.caption {
-font-size: 20pt;
-}
-.table caption {
-font-size: 20pt;
-padding-bottom: 3mm;
-
-}
-code {
-font-size: 1em;
-font-family: monospace;
-background-color: $if(secondary_colour)$$secondary_colour$24$else$#00808024$endif$;
-color: $if(primary_colour)$$primary_colour$$else$#0b4545$endif$;
-padding: 1.2mm;
-border-radius: 2mm;
-}
-.poster_title code {
-font-size: 1em;
-}
-table {
-font-size: 40px;
-margin: auto;
-border-top: 3px solid #666;
-border-bottom: 3px solid #666;
-}
-table thead th {
-border-bottom: 3px solid #ddd;
-}
-td {
-padding: 8px;
-}
-th {
-padding: 15px;
-}
-caption {
-margin-bottom: 10px;
-}
-.poster_body p {
-margin-right: 4mm;
-margin-left: 4mm;
-margin-top: 6mm;
-margin-bottom: 10mm;
-color: $if(body_textcol)$$body_textcol$$else$#000000$endif$
-}
-.poster_body ol {
-margin-right: 4mm;
-margin-left: 4mm;
-}
-#ul {
-margin-right: 4mm;
-margin-left: 4mm;
-}
-.references p {
-font-size: 20pt;
-}
-.orcid img {
-  width: 1em;
-}
-</style>
-$if(custom_css)$
-<link rel="stylesheet" href=$custom_css$>
-$else$$endif$
-</head>
-<body>
-
-$for(include-before)$
-$include-before$
-$endfor$
-
-<div class="poster_wrap">
-<div class="title_container">
-<!-- Left Logo  -->
-<div class="logo_left">
-$if(logoleft_name)$
-<img src=$logoleft_name$ style="width: 80%">
-$endif$
-</div>
-<!-- Poster Title -->
-<div class= "poster_title">
-$if(title)$<h1 id="title">$title$</h1>$endif$
-$if(author)$<h3 id="author">$for(author)$$author.name$<sup>$author.affil$$if(author.orcid)$, <a class="orcid" href="https://orcid.org/$author.orcid$"><img src="https://raw.githubusercontent.com/brentthorne/posterdown/master/images/orcid.jpg"></a>$else$$endif$</sup>$sep$, $endfor$</h3>$endif$
-$if(affiliation)$<h5 id="affiliation">$for(affiliation)$<sup>$affiliation.num$</sup> $affiliation.address$$sep$; $endfor$</h5>$endif$
-</div>
-<!-- Right Logo  -->
-<div class="logo_right">
-$if(logoright_name)$
-<img src=$logoright_name$ style="width: 80%">
-$endif$
-</div>
-</div>
-
-<div class='poster_body_wrap'>
-<div class='poster_body'>
-$body$
-</div>
-</div>
-
-</div>
-
-$if(math)$
-<!-- dynamically load mathjax for compatibility with self-contained -->
-<script>
-(function () {
-var script = document.createElement("script");
-script.type = "text/javascript";
-var src = "$if(mathjax)$$mathjax$$endif$";
-if (src === "" || src === "true") src = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-MML-AM_CHTML";
-if (location.protocol !== "file:" && /^https?:/.test(src))
-src = src.replace(/^https?:/, '');
-script.src = src;
-document.getElementsByTagName("head")[0].appendChild(script);
-})();
-</script>
-$endif$
-
-$for(include-after)$
-$include-after$
-$endfor$
-
-</body>
-</html>
diff --git a/inst/rmarkdown/templates/posterdown_html/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/posterdown_html/skeleton/skeleton.Rmd
deleted file mode 100644
index 1ed2782..0000000
--- a/inst/rmarkdown/templates/posterdown_html/skeleton/skeleton.Rmd
+++ /dev/null
@@ -1,81 +0,0 @@
----
-title: Generate Reproducible & Live HTML and PDF Conference Posters Using RMarkdown
-author:
-  - name: Brent Thorne
-    affil: 1
-    orcid: '0000-0002-1099-3857'
-  - name: Another G. Author
-    affil: 2
-affiliation:
-  - num: 1
-    address: Department of Earth Science, Brock University
-  - num: 2
-    address: Department of Graphics and Layouts, University of Posters; Canada
-column_numbers: 3
-logoright_name: https&#58;//raw.githubusercontent.com/brentthorne/posterdown/master/images/betterhexlogo.png
-logoleft_name: https&#58;//raw.githubusercontent.com/brentthorne/posterdown/master/images/betterhexlogo.png
-output: 
-  posterdown::posterdown_html:
-    self_contained: false
-bibliography: packages.bib
----
-
-```{r setup, include=FALSE}
-knitr::opts_chunk$set(echo = FALSE)
-```
-
-# Introduction
-
-Welcome to `posterdown` ! This is my attempt to provide a semi-smooth workflow for those who wish to take their R Markdown skills to the conference world. Most features from R Markdown are available in this package such as Markdown section notation, figure captioning, and even citations like this one [@R-rmarkdown]. The rest of this example poster will show how you can insert typical conference poster features into your own document. 
-
-## Objectives
-
-1. Easy to use reproducible poster design. 
-2. Integration with R Markdown.
-3. Easy transition from `posterdown` to `pagedown` report or manuscript documents [@R-pagedown].
-
-# Methods
-
-This package uses the same workflow approach as the R Markdown you know and love. Basically it goes from RMarkdown > Knitr > Markdown > Pandoc > HTML/CSS > PDF. You can even use the bibliography the same way [@R-posterdown].
-
-# Results
-
-Usually you want to have a nice table displaying some important results that you have calculated. In `posterdown` this is as easy as using the `kable` table formatting you are probably use to as per typical R Markdown formatting.
-
-You can reference tables like so: Table \@ref(tab:mytable). Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam placerat augue at velit tincidunt semper. Donec elementum porta posuere. Nullam interdum, odio at tincidunt feugiat, turpis nisi blandit eros, eu posuere risus felis non quam. Nam eget lorem odio. Duis et aliquet orci. Phasellus nec viverra est.
-
-```{r mytable, out.width='80%'}
-knitr::kable(iris[1:10, 1:4], caption = 'Table caption.',align = 'c',"html")
-```
-
-Or with figures: Figure \@ref(fig:standard-plot), or Figure \@ref(fig:morefigs).
-
-```{r standard-plot, out.width='80%', fig.align='center', fig.cap='Great figure!', fig.height=5}
-plot(mtcars[1:2])
-```
-
-```{r morefigs, out.width='80%', echo=TRUE, fig.cap='Amazing, right?!', fig.height=5}
-data <- iris
-
-plot(x = data$Sepal.Length, 
-     y = data$Sepal.Width, 
-     col = data$Species,
-     pch = 19, 
-     xlab = "Sepal Length (cm)",
-     ylab = "Sepal Width (cm)")
-
-```
-
-# Next Steps
-
-Aliquam sed faucibus risus, quis efficitur erat. Vestibulum semper mauris quis tempus eleifend. Aliquam sagittis dictum ipsum, quis viverra ligula eleifend ut. Curabitur sagittis vitae arcu eget faucibus. In non elementum felis. Duis et aliquam nunc. Nunc pulvinar sapien nunc, vel pretium nisi efficitur in. Fusce fringilla maximus leo et maximus. Fusce at ligula laoreet, iaculis mi at, auctor odio. Praesent sed elementum justo. Aenean consectetur risus rhoncus tincidunt efficitur. Praesent dictum mauris at diam maximus maximus [@R-posterdown].
-
-# Conclusion
-
-Try `posterdown` out! Hopefully you like it!
-
-```{r, include=FALSE}
-knitr::write_bib(c('knitr','rmarkdown','posterdown','pagedown'), 'packages.bib')
-```
-
-# References
diff --git a/inst/rmarkdown/templates/posterdown_html/template.yaml b/inst/rmarkdown/templates/posterdown_html/template.yaml
deleted file mode 100644
index 9fc207e..0000000
--- a/inst/rmarkdown/templates/posterdown_html/template.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-name: Posterdown HTML
-description: >
- Template for creating R Markdown based PDF via HTML and CSS
-create_dir: true
diff --git a/inst/rmarkdown/templates/posterdown_ids/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/posterdown_ids/skeleton/skeleton.Rmd
index 2f88dae..e9eed0d 100644
--- a/inst/rmarkdown/templates/posterdown_ids/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/posterdown_ids/skeleton/skeleton.Rmd
@@ -1,6 +1,6 @@
 ---
 title: Generate Reproducible IDS-CD compliant HTML and PDF Posters
-subtitle: Using RMarkdown and `posterdown::posterdown_ids`
+subtitle: Using RMarkdown and `posterdown.ids::posterdown_ids`
 author:
   - name: Brent Thorne
     affil: 1
@@ -19,12 +19,12 @@
     email: kupietz@ids-mannheim.de
     website: "https://www.ids-mannheim.de/digspra/"
     qrlink: >
-      `r posterdown::qrlink('https://korap.ids-mannheim.de/gerrit/plugins/gitiles/IDS-Mannheim/posterdown')`
+      `r posterdown.ids::qrlink('https://korap.ids-mannheim.de/gerrit/plugins/gitiles/IDS-Mannheim/posterdown')`
 column_numbers: 2
 # logoright_name: https&#58;//raw.githubusercontent.com/brentthorne/posterdown/master/images/betterhexlogo.png
 logoleft_name: https&#58;//raw.githubusercontent.com/brentthorne/posterdown/master/images/betterhexlogo.png
 output: 
-  posterdown::posterdown_ids:
+  posterdown.ids::posterdown_ids:
     self_contained: false
     keep_md: true
 bibliography: packages.bib
@@ -45,7 +45,7 @@
 
 1. Easy to use reproducible poster design. [^1]
 2. Integration with R Markdown.
-3. Easy transition from `posterdown` $➝$ `pagedown` report or manuscript documents [@R-pagedown] and [revealjs-ids](https://gitlab.ids-mannheim.de/ids/revealjs).
+3. Easy transition from `posterdown` ➝ `pagedown` report or manuscript documents [@R-pagedown] and [revealjs-ids](https://gitlab.ids-mannheim.de/ids/revealjs).
 
 [^1]:Footnotes are possible, too.
 
diff --git a/man/posterdown.Rd b/man/posterdown.Rd
index b7f2097..aff251b 100644
--- a/man/posterdown.Rd
+++ b/man/posterdown.Rd
@@ -2,26 +2,28 @@
 % Please edit documentation in R/posterdown.R
 \docType{package}
 \name{posterdown}
+\alias{posterdown.ids}
+\alias{posterdown.ids-package}
 \alias{posterdown}
-\title{posterdown package}
+\title{posterdown.ids package}
 \description{
 This package creates posters for conferences
 }
-\section{poster_html}{
+\section{posterdown_ids}{
 
-Creates an R Markdown template for a PDF poster document via HTML
+Creates an R Markdown template for a IDS CD compliant PDF poster document via HTML
 }
 
-\section{poster_betterland}{
-
-Creates an R Markdown template for a PDF poster document via HTML
+\seealso{
+Useful links:
+\itemize{
+  \item \url{https://github.com/brentthorne/posterdown}
+  \item Report bugs at \url{https://github.com/brentthorne/posterdown/issues}
 }
 
-\section{poster_betterport}{
-
-Creates an R Markdown template for a PDF poster document via HTML
 }
-
 \author{
 Brent Thorne
+
+Marc Kupietz
 }
diff --git a/man/posterdown_html.Rd b/man/posterdown_html.Rd
deleted file mode 100644
index 0fad74d..0000000
--- a/man/posterdown_html.Rd
+++ /dev/null
@@ -1,65 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/posterdown_html.R
-\name{posterdown_html}
-\alias{posterdown_html}
-\alias{posterdown_ids}
-\alias{posterdown_betterland}
-\alias{posterdown_betterport}
-\title{Posterdown HTML format (using pagedown::poster_relaxed)}
-\usage{
-posterdown_html(
-  ...,
-  template = find_resource("posterdown_html", "template.html"),
-  css = NULL
-)
-
-posterdown_ids(
-  ...,
-  template = find_resource("posterdown_ids", "template.html"),
-  css = NULL
-)
-
-posterdown_betterland(
-  ...,
-  template = find_resource("posterdown_betterland", "template.html"),
-  css = NULL
-)
-
-posterdown_betterport(
-  ...,
-  template = find_resource("posterdown_betterport", "template.html"),
-  css = NULL
-)
-}
-\arguments{
-\item{...}{Additional arguments to \code{rmarkdown::html_document}}
-}
-\value{
-R Markdown output format to pass to
-\code{\link[rmarkdown:render]{rmarkdown::render()}}
-
-R Markdown output format to pass to
-\code{\link[rmarkdown:render]{rmarkdown::render()}}
-}
-\description{
-The output format \code{poster_ids()} mimics the IDS Mannheim
-corporate design posters.
-
-The output format \code{poster_betterland()} mimics the style of the
-BetterPoster movement from twitter.
-
-The output format \code{poster_betterport()} mimics the style of the
-BetterPoster movement from twitter.
-}
-\examples{
-\donttest{
-file <- file.path(tempdir(),"foo.rmd")
-rmarkdown::draft(file, template="posterdown_html", package="posterdown")
-}
-
-\donttest{
-file <- file.path(tempdir(),"foo.rmd")
-rmarkdown::draft(file, template="posterdown_ids", package="posterdown")
-}
-
-}
diff --git a/man/posterdown_ids.Rd b/man/posterdown_ids.Rd
new file mode 100644
index 0000000..a69555a
--- /dev/null
+++ b/man/posterdown_ids.Rd
@@ -0,0 +1,30 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/posterdown_html.R
+\name{posterdown_ids}
+\alias{posterdown_ids}
+\title{Posterdown IDS-CD based on HTML format (using pagedown::poster_relaxed)}
+\usage{
+posterdown_ids(
+  ...,
+  template = find_resource("posterdown_ids", "template.html"),
+  css = NULL
+)
+}
+\arguments{
+\item{...}{Additional arguments to \code{rmarkdown::html_document}}
+}
+\value{
+R Markdown output format to pass to
+\code{\link[rmarkdown:render]{rmarkdown::render()}}
+}
+\description{
+The output format \code{posterdown_ids()} mimics the IDS Mannheim
+corporate design posters.
+}
+\examples{
+\donttest{
+file <- file.path(tempdir(),"foo.rmd")
+rmarkdown::draft(file, template="posterdown_ids", package="posterdown.ids")
+}
+
+}
diff --git a/posterdown.Rproj b/posterdown.ids.Rproj
similarity index 92%
rename from posterdown.Rproj
rename to posterdown.ids.Rproj
index 270314b..df5ba20 100644
--- a/posterdown.Rproj
+++ b/posterdown.ids.Rproj
@@ -19,3 +19,5 @@
 PackageUseDevtools: Yes
 PackageInstallArgs: --no-multiarch --with-keep.source
 PackageRoxygenize: rd,collate,namespace
+
+ProjectName: posterdown.ids
