diff --git a/.gitignore b/.gitignore
index df0acd4..8206fce 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,6 @@
 *.RData
 *.Ruserdata
 .Rproj.user
+# ignore skeleton files
+skeleton.html
+skeleton_files/
diff --git a/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.Rmd
index 1d9a93c..21bdb7c 100644
--- a/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.Rmd
@@ -2,7 +2,7 @@
 # PLEASE SEE THE README for in depth description github.com/brentthorne/posterdown
 poster_height: "32in"
 poster_width: "46in"
-font_family: 'Indie Flower'
+font_family: 'Rasa'
 #ESSENTIALS
 title: A Better Reproducible Poster Title
 author:
@@ -14,7 +14,7 @@
     email: bthorne2@brocku.ca
   - name: Another G. Contributor
     affil: 2
-    email: 'ag.con@posterdown.net'
+    email: ag.con@posterdown.net
   - name: Person Three
     affil: 3
 affiliation:
@@ -65,7 +65,7 @@
 
 # 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 [@thorneposterdown2019]. If you are not an R user don't sweat as you do **NOT** need to use it at all! Feel free to use only the Markdown functionallity of this package :)
+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 [@thorneposterdown2019]. If you are 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 :)
 
 # Methods
 
diff --git a/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.html b/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.html
index 7d4b9cb..458cfbd 100644
--- a/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.html
+++ b/inst/rmarkdown/templates/posterdown_betterland/skeleton/skeleton.html
@@ -85,7 +85,7 @@
 Google fonts api stuff
 -->
 <link href='https://fonts.googleapis.com/css?family=Special Elite' rel='stylesheet'>
-<link href='https://fonts.googleapis.com/css?family=Indie Flower' rel='stylesheet'>
+<link href='https://fonts.googleapis.com/css?family=Rasa' rel='stylesheet'>
 
 <!--
 Here are the required style attributes for css to make this poster work :)
@@ -194,7 +194,7 @@
 column-rule-color: black;
 -webkit-column-gap: 50%;
 background-color: #FFFFFF;
-font-family: Indie Flower;
+font-family: Rasa;
 color: #000000;
 }
 span.citation {
@@ -357,7 +357,7 @@
 
 <div id="introduction" class="section level1">
 <h1>Introduction</h1>
-<p>This is the <code>posterdown_betterland</code> template for the {posterdown} package! I was inspired by the twitter thread of <a href="https://mobile.twitter.com/mikemorrison/status/1110191245035479041">Mike Morrison</a> and wanted to apply the <code>#betterposter</code> concept to the reproducible (yet simple to use) functionality of the {posterdown} package <span class="citation">(Thorne <a href="#ref-thorneposterdown2019">2019</a>)</span>. If you are not an R user don’t sweat as you do <strong>NOT</strong> need to use it at all! Feel free to use only the Markdown functionallity of this package :)</p>
+<p>This is the <code>posterdown_betterland</code> template for the {posterdown} package! I was inspired by the twitter thread of <a href="https://mobile.twitter.com/mikemorrison/status/1110191245035479041">Mike Morrison</a> and wanted to apply the <code>#betterposter</code> concept to the reproducible (yet simple to use) functionality of the {posterdown} package <span class="citation">(Thorne <a href="#ref-thorneposterdown2019">2019</a>)</span>. If you are not an R user don’t sweat as you do <strong>NOT</strong> need to use it at all! Feel free to use only the Markdown functionality of this package :)</p>
 </div>
 <div id="methods" class="section level1">
 <h1>Methods</h1>
diff --git a/inst/rmarkdown/templates/posterdown_betterport/skeleton/skeleton.Rmd b/inst/rmarkdown/templates/posterdown_betterport/skeleton/skeleton.Rmd
index 4d45027..80a9d61 100644
--- a/inst/rmarkdown/templates/posterdown_betterport/skeleton/skeleton.Rmd
+++ b/inst/rmarkdown/templates/posterdown_betterport/skeleton/skeleton.Rmd
@@ -75,9 +75,9 @@
 
 # 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 [@thorneposterdown2019]. If you are not an R user don't sweat as you do **NOT** need to use it at all! Feel free to use only the Markdown functionallity of this package :) 
+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 [@thorneposterdown2019]. If you are 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 :) 
 
-HTML documents such as this allow for "live" posters (aka GIFs or embeded videos etc), see Figure \@ref(fig:mymapfig) bellow for an example of a study site map made using the {ggspatial} or Figure \@ref(fig:gganimatefig) for an example using the [{gganimate}](github.com/thomasp85/gganimate) package by [@gganimate2017]. I can even change the order of the figures in the poster and [{posterdown}](github.com/brentthorne/posterdown) will take care of the formatting of Figure numbers for you, see Figure \@ref(fig:mymapfig).
+HTML documents such as this allow for "live" posters (aka GIFs or embedded videos etc), see Figure \@ref(fig:mymapfig) bellow for an example of a study site map made using the {ggspatial} or Figure \@ref(fig:gganimatefig) for an example using the [{gganimate}](github.com/thomasp85/gganimate) package by [@gganimate2017]. I can even change the order of the figures in the poster and [{posterdown}](github.com/brentthorne/posterdown) will take care of the formatting of Figure numbers for you, see Figure \@ref(fig:mymapfig).
 
 ```{r, mymapfig, out.width="100%", cache=FALSE, fig.cap='Map of Long Lake eample from the [ggspatial](https://github.com/paleolimbot/ggspatial) package [@ggspatial].', comment=FALSE}
 
