diff --git a/Cargo.toml b/Cargo.toml
index 4a9142e..1b39cc8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "blog-tools"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2021"
 authors = ["Indigo Curnick <indigocurnick@gmail.com>"]
 description = "A collection of tools that helps make blogs in Rust"
@@ -17,6 +17,7 @@ walkdir = "2.3.2"
 chrono = { version = "0.4.23", features = ["serde"] }
 markdown = "1.0.0-alpha.11"
 tl = "0.7.8"
+xml = "0.8.20"
 
 
 [dev-dependencies]
diff --git a/README.md b/README.md
index 9537bda..a35960f 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ next to a `blog.json`.
 
 The JSON must conform to the following schema
 
-```rust,ignore
+```json,ignore
 {
 "title": String,
 "date": ISO 8601 Date i.e. YYYY-MM-DD,
@@ -27,7 +27,9 @@ The JSON must conform to the following schema
 "keywords": Optional<[String]>,
 "canonical_link": Optional<String>,
 "author_name": Optional<String>,
-"author_webpage": Optional<String>
+"author_webpage": Optional<String>,
+"last_modified": Optional<Date>, (ISO 8601)
+"priority": Optional<float>
 }
 ```
 
@@ -36,7 +38,6 @@ The JSON must conform to the following schema
 In `blog-tools` all slugs are /{date}/{sub-slug}.
 
 Make sure the "slug" filed in the JSON is *just* the final sub-slug
-- `blog-tools` will automatically handle the date for you
 
 ## How This Crate is Organised
 
@@ -56,7 +57,7 @@ the best way to do this is using a lazy static like so
 ```rust,ignore
 lazy_static! {
     pub static ref STATIC_BLOG_ENTRIES: HighBlog =
-        get_high_blog(PathBuf::from(BLOG_ROOT), None, None);
+        get_high_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
     }
 ```
 
@@ -66,7 +67,7 @@ blog posts themselves. These will need to be rendered when requested
 ```rust,ignore
 lazy_static! {
     pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
-        get_medium_blog(PathBuf::from(BLOG_ROOT), None, None);
+        get_medium_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
     }
 
 let this_blog = match all_blogs.hash.get(&complete_slug) {
@@ -88,6 +89,7 @@ everything at runtime.
 let preview = preview_blogs(PathBuf::from_str(BLOG_ROOT).unwrap(), 2, None);
 let tags = get_blog_tag_list(PathBuf::from_str(BLOG_ROOT).unwrap());
 let blog_post = render_blog_post(PathBuf::from_str(BLOG_ROOT).unwrap(), date, slug, None).unwrap();
+let sitemap = create_sitemap(BLOG_ROOT, URL, &SitemapOptions::default());
 ```
 
 This method can have serious runtime performance implecations, but might be
diff --git a/examples/assets/favicon.ico b/examples/assets/favicon.ico
new file mode 100644
index 0000000..7904e09
Binary files /dev/null and b/examples/assets/favicon.ico differ
diff --git a/examples/high/main.rs b/examples/high/main.rs
index 43ad906..87a1cb7 100644
--- a/examples/high/main.rs
+++ b/examples/high/main.rs
@@ -1,10 +1,13 @@
+use std::fs;
 use std::path::PathBuf;
 
 use blog_tools::high::{get_high_blog, HighBlog, HighBlogEntry};
+use blog_tools::sitemap::SitemapOptions;
+use blog_tools::Blog;
 use lazy_static::lazy_static;
 use rocket::{
     fs::{relative, FileServer},
-    response::Redirect,
+    response::{content::RawXml, Redirect},
     Request, Route,
 };
 use rocket_dyn_templates::Template;
@@ -41,6 +44,13 @@ fn blog_index() -> Option<Template> {
     Some(Template::render("blog_index", context.into_json()))
 }
 
+#[get("/sitemap.xml")]
+fn sitemap() -> RawXml<String> {
+    let blog = get_blog_context();
+
+    return RawXml(blog.sitemap.clone());
+}
+
 #[get("/blog/<date>/<slug>", rank = 2)]
 fn blog_article(date: String, slug: String) -> Option<Template> {
     let mut context = rocket_dyn_templates::tera::Context::new();
@@ -62,7 +72,7 @@ fn tag_page(slug: String) -> Option<Template> {
     let mut these_blogs: Vec<&HighBlogEntry> = vec![];
 
     for blog in &all_blogs.entries {
-        if blog.tags.contains(&slug) {
+        if blog.get_tags().contains(&slug) {
             these_blogs.push(&blog);
         }
     }
@@ -87,14 +97,25 @@ async fn error(req: &Request<'_>) -> Redirect {
 }
 
 fn get_all_routes() -> Vec<Route> {
-    return routes![blog_index, blog_article, tag_page];
+    return routes![blog_index, blog_article, tag_page, sitemap];
 }
 
 pub static BLOG_ROOT: &str = "examples/blog";
+pub static URL: &str = "www.example.xyz";
 
 lazy_static! {
-    pub static ref STATIC_BLOG_ENTRIES: HighBlog =
-        get_high_blog(PathBuf::from(BLOG_ROOT), None, None).unwrap();
+    pub static ref STATIC_BLOG_ENTRIES: HighBlog = get_high_blog(
+        PathBuf::from(BLOG_ROOT),
+        None,
+        None,
+        &URL.to_string(),
+        &SitemapOptions {
+            include_tags: true,
+            sitemap_base: Some(fs::read_to_string("examples/xml/sitemap.xml").unwrap()),
+            ..Default::default()
+        }
+    )
+    .unwrap();
 }
 
 fn get_blog_context() -> &'static HighBlog {
diff --git a/examples/low/main.rs b/examples/low/main.rs
index e87526e..33de822 100644
--- a/examples/low/main.rs
+++ b/examples/low/main.rs
@@ -1,14 +1,17 @@
-use blog_tools::low::{
-    get_blog_tag_list, preview_blogs, preview_blogs_tagged, render_blog_post, PreviewBlogEntry,
+use blog_tools::{
+    low::{
+        get_blog_tag_list, preview_blogs, preview_blogs_tagged, render_blog_post, PreviewBlogEntry,
+    },
+    sitemap::{create_sitemap, SitemapOptions},
 };
 use rocket::{
     fs::{relative, FileServer},
-    response::Redirect,
+    response::{content::RawXml, Redirect},
     Request, Route,
 };
 use rocket_dyn_templates::Template;
 use serde::{Deserialize, Serialize};
-use std::{path::PathBuf, str::FromStr};
+use std::{fs, path::PathBuf, str::FromStr};
 
 pub static BLOG_ROOT: &str = "examples/blog";
 
@@ -82,6 +85,24 @@ fn tag_page(slug: String) -> Option<Template> {
     Some(Template::render("tags", context.into_json()))
 }
 
+pub static URL: &str = "www.example.xyz";
+
+#[get("/sitemap.xml")]
+fn sitemap() -> RawXml<String> {
+    let base_sitemap = fs::read_to_string("examples/xml/sitemap.xml").unwrap();
+    let sitemap = create_sitemap(
+        BLOG_ROOT,
+        &URL.to_string(),
+        &SitemapOptions {
+            include_tags: true,
+            sitemap_base: Some(base_sitemap),
+            ..Default::default()
+        },
+    );
+
+    return RawXml(sitemap.unwrap());
+}
+
 #[catch(404)]
 async fn not_found(req: &Request<'_>) -> Redirect {
     let mut context = rocket_dyn_templates::tera::Context::new();
@@ -97,5 +118,5 @@ async fn error(req: &Request<'_>) -> Redirect {
 }
 
 fn get_all_routes() -> Vec<Route> {
-    return routes![blog_index, blog_article, tag_page];
+    return routes![blog_index, blog_article, tag_page, sitemap];
 }
diff --git a/examples/medium/main.rs b/examples/medium/main.rs
index 33e84d3..40fb6b2 100644
--- a/examples/medium/main.rs
+++ b/examples/medium/main.rs
@@ -1,10 +1,14 @@
-use std::{path::PathBuf, str::FromStr};
+use std::{fs, path::PathBuf, str::FromStr};
 
-use blog_tools::medium::{get_medium_blog, MediumBlog, MediumBlogEntry};
+use blog_tools::{
+    medium::{get_medium_blog, MediumBlog, MediumBlogEntry},
+    sitemap::SitemapOptions,
+    Blog,
+};
 use lazy_static::lazy_static;
 use rocket::{
     fs::{relative, FileServer},
-    response::Redirect,
+    response::{content::RawXml, Redirect},
     Request, Route,
 };
 use rocket_dyn_templates::Template;
@@ -34,6 +38,13 @@ async fn main() {
     }
 }
 
+#[get("/sitemap.xml")]
+fn sitemap() -> RawXml<String> {
+    let blog = get_blog_context();
+
+    return RawXml(blog.sitemap.clone());
+}
+
 #[get("/blog")]
 fn blog_index() -> Option<Template> {
     let mut context = rocket_dyn_templates::tera::Context::new();
@@ -68,7 +79,7 @@ fn tag_page(slug: String) -> Option<Template> {
     let mut these_blogs: Vec<&MediumBlogEntry> = vec![];
 
     for blog in &all_blogs.entries {
-        if blog.tags.contains(&slug) {
+        if blog.get_tags().contains(&slug) {
             these_blogs.push(&blog);
         }
     }
@@ -93,14 +104,25 @@ async fn error(req: &Request<'_>) -> Redirect {
 }
 
 fn get_all_routes() -> Vec<Route> {
-    return routes![blog_index, blog_article, tag_page];
+    return routes![blog_index, blog_article, tag_page, sitemap];
 }
 
 pub static BLOG_ROOT: &str = "examples/blog";
+pub static URL: &str = "www.example.xyz";
 
 lazy_static! {
-    pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
-        get_medium_blog(PathBuf::from(BLOG_ROOT), None, None).unwrap();
+    pub static ref STATIC_BLOG_ENTRIES: MediumBlog = get_medium_blog(
+        PathBuf::from(BLOG_ROOT),
+        None,
+        None,
+        &URL.to_string(),
+        &SitemapOptions {
+            include_tags: true,
+            sitemap_base: Some(fs::read_to_string("examples/xml/sitemap.xml").unwrap()),
+            ..Default::default()
+        }
+    )
+    .unwrap();
 }
 
 fn get_blog_context() -> &'static MediumBlog {
diff --git a/examples/xml/sitemap.xml b/examples/xml/sitemap.xml
new file mode 100644
index 0000000..6bc43f5
--- /dev/null
+++ b/examples/xml/sitemap.xml
@@ -0,0 +1,7 @@
+<urlset>
+<url>
+<loc>www.example.xyz</loc>
+<lastmod>19-08-2023</lastmod>
+<priority>1.0</priority>
+</url>
+</urlset>
\ No newline at end of file
diff --git a/out.txt b/out.txt
deleted file mode 100644
index a9c3bbe..0000000
--- a/out.txt
+++ /dev/null
@@ -1,75 +0,0 @@
-   Compiling blog-tools v0.1.1 (/home/nathanielc/Documents/personal_code/blog-tools)
-    Finished dev [unoptimized + debuginfo] target(s) in 1.75s
-     Running `target/debug/examples/high`
-Configured for debug.
-   >> address: 0.0.0.0
-   >> port: 8080
-   >> workers: 24
-   >> max blocking threads: 512
-   >> ident: Rocket
-   >> IP header: X-Real-IP
-   >> limits: bytes = 8KiB, data-form = 2MiB, file = 1MiB, form = 32KiB, json = 1MiB, msgpack = 1MiB, string = 8KiB
-   >> temp dir: /tmp
-   >> http/2: true
-   >> keep-alive: 5s
-   >> tls: disabled
-   >> shutdown: ctrlc = true, force = true, signals = [SIGTERM], grace = 2s, mercy = 3s
-   >> log level: normal
-   >> cli colors: true
-Routes:
-   >> (blog_index) GET /blog
-   >> (FileServer: examples/assets) GET /<path..> [10]
-   >> (tag_page) GET /blog/tag/<slug>
-   >> (blog_article) GET /blog/<date>/<slug> [2]
-Catchers:
-   >> (not_found) 404
-   >> (error) 500
-Fairings:
-   >> Templating (ignite, liftoff, request)
-   >> Shield (liftoff, response, singleton)
-Shield:
-   >> X-Content-Type-Options: nosniff
-   >> X-Frame-Options: SAMEORIGIN
-   >> Permissions-Policy: interest-cohort=()
-Templating:
-   >> directory: templates
-   >> engines: ["tera"]
-Rocket has launched from http://0.0.0.0:8080
-GET /blog text/html:
-   >> Matched: (blog_index) GET /blog
-Now deadling with Tag(HTMLTag { _name: Bytes("h1"), _attributes: Attributes { raw: InlineHashMap(InlineHashMap<0 items>), id: None, class: None }, _children: InlineVec(InlineVec<1 items>), _raw: Bytes("<h1>My Second Blog</h1>") })
-Now deadling with Raw(Bytes("My Second Blog"))
-Now deadling with Raw(Bytes("\n"))
-Now deadling with Tag(HTMLTag { _name: Bytes("p"), _attributes: Attributes { raw: InlineHashMap(InlineHashMap<0 items>), id: None, class: None }, _children: InlineVec(InlineVec<1 items>), _raw: Bytes("<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Turpis tincidunt id aliquet risus. Dictum varius duis at consectetur lorem donec. Neque convallis a cras semper auctor neque vitae tempus. Lectus quam id leo in vitae turpis massa sed elementum. Dui id ornare arcu odio ut sem nulla. Iaculis urna id volutpat lacus laoreet non. Dolor magna eget est lorem ipsum. Sed viverra ipsum nunc aliquet. Turpis massa tincidunt dui ut ornare lectus sit amet est. Pretium nibh ipsum consequat nisl vel pretium. Eu sem integer vitae justo. Massa ultricies mi quis hendrerit dolor. Tortor consequat id porta nibh venenatis cras sed felis eget. Aliquam etiam erat velit scelerisque in dictum non consectetur. Id nibh tortor id aliquet lectus proin. Mauris a diam maecenas sed enim ut sem. Convallis convallis tellus id interdum velit laoreet. Massa eget egestas purus viverra accumsan in nisl.</p>") })
-Now deadling with Tag(HTMLTag { _name: Bytes("h1"), _attributes: Attributes { raw: InlineHashMap(InlineHashMap<0 items>), id: None, class: None }, _children: InlineVec(InlineVec<1 items>), _raw: Bytes("<h1>My First Blog</h1>") })
-Now deadling with Raw(Bytes("My First Blog"))
-Now deadling with Raw(Bytes("\n"))
-Now deadling with Tag(HTMLTag { _name: Bytes("p"), _attributes: Attributes { raw: InlineHashMap(InlineHashMap<0 items>), id: None, class: None }, _children: InlineVec(InlineVec<1 items>), _raw: Bytes("<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Velit laoreet id donec ultrices tincidunt arcu non sodales. Diam ut venenatis tellus in metus. Neque aliquam vestibulum morbi blandit cursus risus at ultrices mi. Purus non enim praesent elementum. Amet porttitor eget dolor morbi non arcu risus quis varius. Ornare lectus sit amet est. Varius sit amet mattis vulputate enim nulla aliquet porttitor. Id diam maecenas ultricies mi. Ut venenatis tellus in metus vulputate eu scelerisque felis imperdiet. Integer feugiat scelerisque varius morbi enim.</p>") })
-   >> Outcome: Success(200 OK)
-   >> Response succeeded.
-GET /css/style.css text/css:
-   >> Matched: (FileServer: examples/assets) GET /<path..> [10]
-   >> Outcome: Success(200 OK)
-   >> Response succeeded.
-GET /favicon.ico image/avif:
-   >> Matched: (FileServer: examples/assets) GET /<path..> [10]
-   >> I/O Error: Os { code: 2, kind: NotFound, message: "No such file or directory" }
-   >> Outcome: Forward(404 Not Found)
-   >> No matching routes for GET /favicon.ico image/avif.
-   >> Responding with registered (not_found) 404 catcher.
-   >> Response succeeded.
-GET /blog/2023-08-19/second-blog text/html:
-   >> Matched: (blog_article) GET /blog/<date>/<slug> [2]
-   >> Note: Using `String` as a parameter type is inefficient. Use `&str` instead.
-   >> `String` is used a parameter guard in examples/high/main.rs:45.
-   >> Note: Using `String` as a parameter type is inefficient. Use `&str` instead.
-   >> `String` is used a parameter guard in examples/high/main.rs:45.
-   >> Outcome: Success(200 OK)
-   >> Response succeeded.
-GET /css/style.css text/css:
-   >> Matched: (FileServer: examples/assets) GET /<path..> [10]
-   >> Outcome: Success(200 OK)
-   >> Response succeeded.
-Warning: Received SIGINT. Requesting shutdown.
-Shutdown requested. Waiting for pending I/O...
-Graceful shutdown completed successfully.
diff --git a/src/common/mod.rs b/src/common/mod.rs
index 57a00bc..4a5e3fb 100644
--- a/src/common/mod.rs
+++ b/src/common/mod.rs
@@ -11,6 +11,33 @@ use std::{
 
 use walkdir::WalkDir;
 
+use crate::Blog;
+
+// TODO: Better name?
+pub fn parse_blogs<T: AsRef<Path>, U: Blog>(
+    base: T,
+    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
+    preview_chars: Option<usize>,
+) -> Result<(Vec<U>, Vec<String>), BlogError> {
+    let blog_paths = get_blog_paths(base)?;
+
+    let mut entries = vec![];
+    let mut tags = vec![]; // TODO: would it be worth converting tags into a Set<String>?
+
+    for blog_path in blog_paths {
+        let out: U = process_blogs(blog_path, toc_generation_func, preview_chars)?;
+        entries.push(out.clone());
+
+        for tag in &out.get_tags() {
+            if !tags.contains(tag) {
+                tags.push(tag.clone());
+            }
+        }
+    }
+
+    return Ok((entries, tags));
+}
+
 pub fn get_blog_paths<T: AsRef<Path>>(base: T) -> Result<Vec<PathBuf>, BlogError> {
     let base = base.as_ref();
     if !base.is_dir() {
@@ -54,19 +81,19 @@ pub fn get_json_data<T: AsRef<Path>>(blog: T) -> Result<BlogJson, BlogError> {
 
     let file_name = match blog.file_name() {
         Some(x) => x,
-        None => todo!(),
+        None => return Err(BlogError::FileNotFound),
     };
 
     let file_str = match file_name.to_str() {
         Some(x) => x,
-        None => todo!(),
+        None => return Err(BlogError::FileNotFound),
     };
 
     let name_split: Vec<&str> = file_str.split(".").collect();
 
     let n = match name_split.get(0) {
         Some(&x) => x,
-        None => todo!(),
+        None => return Err(BlogError::ImproperFileName(file_str.to_string())),
     };
 
     let name = format!("{}.json", n);
@@ -96,3 +123,11 @@ pub fn toc(
         Ok(None)
     };
 }
+
+fn process_blogs<T: AsRef<Path>, U: Blog>(
+    blog: T,
+    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
+    preview_chars: Option<usize>,
+) -> Result<U, BlogError> {
+    return U::create(blog, toc_generation_func, preview_chars);
+}
diff --git a/src/common/types.rs b/src/common/types.rs
index 050db23..bdf6343 100644
--- a/src/common/types.rs
+++ b/src/common/types.rs
@@ -16,6 +16,8 @@ pub struct BlogJson {
     pub canonical_link: Option<String>,
     pub author_name: Option<String>,
     pub author_webpage: Option<String>,
+    pub last_modified: Option<NaiveDate>, // For sitemap, if not present uses `date`
+    pub priority: Option<f64>,            // For sitemap, if not present uses the default
 }
 
 #[derive(Debug)]
@@ -25,6 +27,7 @@ pub enum BlogError {
     FileNotFound, // TODO: It would be nice to include the file not found here but that would rely on converting a Path to a String - which involves TWO unwraps!
     /// Include the date as found as a string
     ImproperDate(String),
+    ImproperFileName(String),
 }
 
 impl Error for BlogError {}
@@ -35,7 +38,8 @@ impl Display for BlogError {
             BlogError::File(a) => write!(f, "File read error caused by: {}", a),
             BlogError::Markdown(b) => write!(f, "Markdown rendering error caused by: {}", b),
             BlogError::FileNotFound => write!(f, "File not found"),
-            BlogError::ImproperDate(c) => write!(f, "Found date `{}` which appears to be improper - dates should be in the yyyy-mm-dd format", c)
+            BlogError::ImproperDate(c) => write!(f, "Found date `{}` which appears to be improper - dates should be in the yyyy-mm-dd format", c),
+            BlogError::ImproperFileName(d) => write!(f, "Found file name `{}` which appears to be improper", d),
         }
     }
 }
diff --git a/src/high/mod.rs b/src/high/mod.rs
index c034ecd..5c9f498 100644
--- a/src/high/mod.rs
+++ b/src/high/mod.rs
@@ -1,110 +1,5 @@
-use chrono::NaiveDate;
-use markdown::mdast::Node;
-use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, path::Path};
-
-use crate::common::{BlogError, BlogJson};
-
-use self::parse::get_blog_entries;
-
 mod parse;
+mod types;
 
-/// Gets the whole `HighBlog` from the specified path. Useful to combine with lazy
-/// static for loading times
-///
-/// The path should be a folder which contains markdown files next to json files
-///
-/// Add an optional toc generation function if you want a table of contents
-///
-/// Optionally specify the number of chars for the preview. Default is 320.
-///
-/// ```rust,ignore
-/// pub static BLOG_ROOT: &str = "examples/blog/post";
-
-/// lazy_static! {
-///     pub static ref STATIC_BLOG_ENTRIES: Blog = get_blog(PathBuf::from(BLOG_ROOT), None, None).unwrap();
-/// }
-/// ```
-///
-pub fn get_high_blog<T: AsRef<Path>>(
-    base: T,
-    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
-    preview_chars: Option<usize>,
-) -> Result<HighBlog, BlogError> {
-    return get_blog_entries(base, toc_generation_func, preview_chars);
-}
-
-/// The main `HighBlog` which stores all relevant information for the blog
-///
-/// `hash` contains a map from the url slug, which is constructed from the
-/// "slug" field in the `BlogJson` and the date, to the `BlogEntry`
-///
-/// `entries` contains a date-sorted (newest first) `Vec` of `BlogEntry`.
-/// Note that `entries` and `hash` contain the same information
-/// but in different formats for performance reasons
-///
-/// `tags` is an unsorted `Vec` of all unique tags used in the blog
-///
-#[derive(Debug, Serialize, Deserialize)]
-pub struct HighBlog {
-    /// URL slug to individual blog
-    ///
-    /// Useful when you have a GET request to /blog/\<date\>/\<slug\>
-    pub hash: HashMap<String, HighBlogEntry>,
-    /// `Vec` of blog posts, sorted by date
-    ///
-    /// Useful when you want to list all blog posts e.g. on an index page
-    pub entries: Vec<HighBlogEntry>,
-    /// `Vec` of all unique tags
-    ///
-    /// Useful when you want to list all tags e.g. on an index page
-    pub tags: Vec<String>,
-}
-
-/// An individual blog post
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct HighBlogEntry {
-    /// Title of the blog post
-    pub title: String,
-    /// Date published
-    pub date: NaiveDate,
-    /// Description
-    pub desc: Option<String>,
-    /// The blog post HTML that would be included into a template
-    pub html: String,
-    /// The URL slug
-    pub slug: String,
-    /// `Vec` of tags for this blog
-    pub tags: Vec<String>,
-    /// Table of contents
-    pub toc: Option<String>,
-    /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
-    pub keywords: Option<Vec<String>>,
-    /// Optional canonical link, intended for SEO
-    pub canonical_link: Option<String>,
-    /// Optional author name
-    pub author_name: Option<String>,
-    /// Optional URL for the author
-    pub author_webpage: Option<String>,
-    /// Preview of the blogpost, useful for showing on index pages
-    pub preview: String,
-}
-
-impl HighBlogEntry {
-    pub(crate) fn new(json: BlogJson, html: String, toc: Option<String>, preview: String) -> Self {
-        return HighBlogEntry {
-            title: json.title,
-            date: json.date,
-            desc: json.desc,
-            html: html,
-            slug: format!("{}/{}", json.date, json.slug),
-            tags: json.tags,
-            toc: toc,
-            keywords: json.keywords,
-            canonical_link: json.canonical_link,
-            author_name: json.author_name,
-            author_webpage: json.author_webpage,
-            preview: preview,
-        };
-    }
-}
+pub use parse::get_high_blog;
+pub use types::{HighBlog, HighBlogEntry};
diff --git a/src/high/parse.rs b/src/high/parse.rs
index 557de96..624c7f6 100644
--- a/src/high/parse.rs
+++ b/src/high/parse.rs
@@ -1,89 +1,72 @@
-use std::{collections::HashMap, fs, path::Path};
-
-use markdown::{mdast::Node, to_html_with_options, Options};
-
-use crate::common::{get_blog_paths, get_json_data, preview::get_preview, toc, BlogError};
-
-use super::{HighBlog, HighBlogEntry};
-
-pub fn get_blog_entries<T: AsRef<Path>>(
+use std::{collections::HashMap, path::Path};
+
+use markdown::mdast::Node;
+
+use crate::{
+    common::{parse_blogs, BlogError},
+    sitemap::{create_sitemap_inner, SitemapOptions},
+    types::Blog,
+};
+
+use super::types::{HighBlog, HighBlogEntry};
+
+/// Gets the whole `HighBlog` from the specified path. Useful to combine with lazy
+/// static for loading times
+///
+/// The path should be a folder which contains markdown files next to json files
+///
+/// Add an optional toc generation function if you want a table of contents
+///
+/// Optionally specify the number of chars for the preview. Default is 320.
+///
+/// ```rust,ignore
+/// pub static BLOG_ROOT: &str = "examples/blog/post";
+
+/// lazy_static! {
+///     pub static ref STATIC_BLOG_ENTRIES: Blog = get_blog(PathBuf::from(BLOG_ROOT), None, None).unwrap();
+/// }
+/// ```
+///
+pub fn get_high_blog<T: AsRef<Path>>(
     base: T,
     toc_generation_func: Option<&dyn Fn(&Node) -> String>,
     preview_chars: Option<usize>,
+    url: &String,
+    sitemap_options: &SitemapOptions,
 ) -> Result<HighBlog, BlogError> {
-    let blog_paths = get_blog_paths(base).unwrap();
+    return get_blog_entries(
+        base,
+        toc_generation_func,
+        preview_chars,
+        url,
+        sitemap_options,
+    );
+}
 
+fn get_blog_entries<T: AsRef<Path>>(
+    base: T,
+    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
+    preview_chars: Option<usize>,
+    url: &String,
+    sitemap_options: &SitemapOptions,
+) -> Result<HighBlog, BlogError> {
     let mut hashes: HashMap<String, HighBlogEntry> = HashMap::new();
-    let mut entries: Vec<HighBlogEntry> = vec![];
-    let mut tags: Vec<String> = vec![];
 
-    for blog in blog_paths {
-        let out = process_blogs(&blog, &tags, toc_generation_func, preview_chars)?;
+    let (mut entries, tags): (Vec<HighBlogEntry>, Vec<String>) =
+        parse_blogs(base, toc_generation_func, preview_chars)?;
 
-        hashes.insert(out.entry.slug.clone(), out.entry.clone());
-        entries.push(out.entry.clone());
-        tags.extend(out.tags);
+    for entry in &entries {
+        hashes.insert(entry.get_full_slug(), entry.clone());
     }
 
-    entries.sort_by(|a, b| b.date.cmp(&a.date));
+    entries.sort_by(|a, b| b.get_date_listed().cmp(&a.get_date_listed()));
+
+    let sitemap = create_sitemap_inner(&entries, Some(&tags), url, sitemap_options)?;
 
     return Ok(HighBlog {
         hash: hashes,
         entries: entries,
         tags: tags,
+        sitemap: sitemap,
     });
 }
-
-fn process_blogs<T: AsRef<Path>>(
-    blog: T,
-    tags: &Vec<String>,
-    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
-    preview_chars: Option<usize>,
-) -> Result<OneBlog, BlogError> {
-    let blog = blog.as_ref();
-    let json_data = get_json_data(blog)?;
-
-    let mut out_tags = vec![];
-    for tag in &json_data.tags {
-        if !tags.contains(&tag) {
-            out_tags.push(tag.clone());
-        }
-    }
-
-    let markdown = match fs::read_to_string(blog) {
-        Ok(x) => x,
-        Err(y) => return Err(BlogError::File(y)),
-    };
-
-    let html = match to_html_with_options(
-        &markdown,
-        &Options {
-            compile: markdown::CompileOptions {
-                allow_dangerous_html: true,
-                allow_dangerous_protocol: true,
-
-                ..markdown::CompileOptions::default()
-            },
-            ..markdown::Options::default()
-        },
-    ) {
-        Ok(x) => x,
-        Err(y) => return Err(BlogError::Markdown(y)),
-    };
-
-    let preview: String = get_preview(&html, preview_chars);
-
-    let toc = toc(&markdown, toc_generation_func)?;
-
-    let blog_entry = HighBlogEntry::new(json_data, html, toc, preview);
-
-    return Ok(OneBlog {
-        entry: blog_entry,
-        tags: out_tags,
-    });
-}
-
-struct OneBlog {
-    pub entry: HighBlogEntry,
-    pub tags: Vec<String>,
-}
diff --git a/src/high/types.rs b/src/high/types.rs
new file mode 100644
index 0000000..041151a
--- /dev/null
+++ b/src/high/types.rs
@@ -0,0 +1,212 @@
+use std::{collections::HashMap, fs, path::Path};
+
+use chrono::NaiveDate;
+use markdown::{mdast::Node, to_html_with_options, Options};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    common::{get_json_data, preview::get_preview, toc, BlogError, BlogJson},
+    medium::MediumBlogEntry,
+    types::Blog,
+};
+
+/// The main `HighBlog` which stores all relevant information for the blog
+///
+/// `hash` contains a map from the url slug, which is constructed from the
+/// "slug" field in the `BlogJson` and the date, to the `BlogEntry`
+///
+/// `entries` contains a date-sorted (newest first) `Vec` of `BlogEntry`.
+/// Note that `entries` and `hash` contain the same information
+/// but in different formats for performance reasons
+///
+/// `tags` is an unsorted `Vec` of all unique tags used in the blog
+///
+#[derive(Debug, Serialize, Deserialize)]
+pub struct HighBlog {
+    /// URL slug to individual blog
+    ///
+    /// Useful when you have a GET request to /blog/\<date\>/\<slug\>
+    pub hash: HashMap<String, HighBlogEntry>,
+    /// `Vec` of blog posts, sorted by date
+    ///
+    /// Useful when you want to list all blog posts e.g. on an index page
+    pub entries: Vec<HighBlogEntry>,
+    /// `Vec` of all unique tags
+    ///
+    /// Useful when you want to list all tags e.g. on an index page
+    pub tags: Vec<String>,
+    /// XML Representation of the sitemap
+    pub sitemap: String,
+}
+
+// TODO: Need a better way to manage the slugs - maybe a getter function and then keep the date and slug private?
+/// An individual blog post
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct HighBlogEntry {
+    /// Title of the blog post
+    title: String,
+    /// Date published
+    date: NaiveDate,
+    /// Description
+    desc: Option<String>,
+    /// The blog post HTML that would be included into a template
+    html: String,
+    /// The URL slug - this does not include the date i.e. `my-blog` instead of `2024-08-19/my-blog`
+    slug: String,
+    /// `Vec` of tags for this blog
+    tags: Vec<String>,
+    /// Table of contents
+    toc: Option<String>,
+    /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
+    keywords: Option<Vec<String>>,
+    /// Optional canonical link, intended for SEO
+    canonical_link: Option<String>,
+    /// Optional author name
+    author_name: Option<String>,
+    /// Optional URL for the author
+    author_webpage: Option<String>,
+    /// Preview of the blogpost, useful for showing on index pages
+    preview: String,
+    /// Optional date of last modification - used for sitemap generation.
+    /// Default to date when not present
+    last_modified: Option<NaiveDate>,
+    /// Optionally used for sitemap - default to 0.5 if not present
+    priority: Option<f64>,
+}
+
+impl Blog for HighBlogEntry {
+    fn create<T: AsRef<Path>>(
+        blog: T,
+        toc_generation_func: Option<&dyn Fn(&Node) -> String>,
+        preview_chars: Option<usize>,
+    ) -> Result<Self, BlogError> {
+        let json = get_json_data(&blog)?;
+
+        let markdown = match fs::read_to_string(blog) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        let html = match to_html_with_options(
+            &markdown,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let preview: String = get_preview(&html, preview_chars);
+
+        let toc = toc(&markdown, toc_generation_func)?;
+
+        return Ok(HighBlogEntry::new(json, html, toc, preview));
+    }
+
+    fn get_title(&self) -> String {
+        return self.title.clone();
+    }
+
+    fn get_date_listed(&self) -> NaiveDate {
+        return self.date.clone();
+    }
+
+    fn get_description(&self) -> Option<String> {
+        return self.desc.clone();
+    }
+
+    fn get_html(&self) -> String {
+        return self.html.clone();
+    }
+
+    fn get_full_slug(&self) -> String {
+        return format!("{}/{}", self.get_date_listed(), self.get_part_slug());
+    }
+
+    fn get_part_slug(&self) -> String {
+        return self.slug.clone();
+    }
+
+    fn get_tags(&self) -> Vec<String> {
+        return self.tags.clone();
+    }
+
+    fn get_table_of_contents(&self) -> Option<String> {
+        return self.toc.clone();
+    }
+
+    fn get_keywords(&self) -> Option<Vec<String>> {
+        return self.keywords.clone();
+    }
+
+    fn get_canonicle_link(&self) -> Option<String> {
+        return self.canonical_link.clone();
+    }
+
+    fn get_author_name(&self) -> Option<String> {
+        return self.author_name.clone();
+    }
+
+    fn get_author_webpage(&self) -> Option<String> {
+        return self.author_webpage.clone();
+    }
+
+    fn get_preview(&self) -> String {
+        return self.preview.clone();
+    }
+
+    fn get_last_modified(&self) -> Option<NaiveDate> {
+        return self.last_modified.clone();
+    }
+
+    fn get_priority(&self) -> Option<f64> {
+        return self.priority.clone();
+    }
+}
+
+impl HighBlogEntry {
+    pub(crate) fn new(json: BlogJson, html: String, toc: Option<String>, preview: String) -> Self {
+        return HighBlogEntry {
+            title: json.title,
+            date: json.date,
+            desc: json.desc,
+            html: html,
+            slug: json.slug,
+            tags: json.tags,
+            toc: toc,
+            keywords: json.keywords,
+            canonical_link: json.canonical_link,
+            author_name: json.author_name,
+            author_webpage: json.author_webpage,
+            preview: preview,
+            last_modified: json.last_modified,
+            priority: json.priority,
+        };
+    }
+
+    pub(crate) fn new_from_medium(medium: &MediumBlogEntry, html: String) -> Self {
+        return Self {
+            title: medium.get_title(),
+            date: medium.get_date_listed(),
+            desc: medium.get_description(),
+            html: html,
+            slug: medium.get_part_slug(),
+            tags: medium.get_tags(),
+            toc: medium.get_table_of_contents(),
+            keywords: medium.get_keywords(),
+            canonical_link: medium.get_canonicle_link(),
+            author_name: medium.get_author_name(),
+            author_webpage: medium.get_author_webpage(),
+            preview: medium.get_preview(),
+            last_modified: medium.get_last_modified(),
+            priority: medium.get_priority(),
+        };
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 52c6046..ef8e33e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -27,7 +27,9 @@
 //! "keywords": Optional<[String]>,
 //! "canonical_link": Optional<String>,
 //! "author_name": Optional<String>,
-//! "author_webpage": Optional<String>
+//! "author_webpage": Optional<String>,
+//! "last_modified": Optional<Date>, (ISO 8601)
+//! "priority": Optional<float>
 //! }
 //! ```
 //!
@@ -36,7 +38,6 @@
 //! In `blog-tools` all slugs are /{date}/{sub-slug}.
 //!
 //! Make sure the "slug" filed in the JSON is *just* the final sub-slug
-//! - `blog-tools` will automatically handle the date for you
 //!
 //! ## How This Crate is Organised
 //!
@@ -55,9 +56,9 @@
 //!
 //! ```rust,ignore
 //! lazy_static! {
-//!     pub static ref STATIC_BLOG_ENTRIES: HighBlog =
-//!         get_high_blog(PathBuf::from(BLOG_ROOT), None, None);
-//!     }
+//!    pub static ref STATIC_BLOG_ENTRIES: HighBlog =
+//!        get_high_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
+//!    }
 //! ```
 //!
 //! `medium` stores the majority of the blog, but not the rendered HTML of the
@@ -65,8 +66,8 @@
 //!
 //! ```rust,ignore
 //! lazy_static! {
-//!     pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
-//!         get_medium_blog(PathBuf::from(BLOG_ROOT), None, None);
+//!    pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
+//!        get_medium_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
 //!     }
 //!
 //! let this_blog = match all_blogs.hash.get(&complete_slug) {
@@ -88,6 +89,7 @@
 //! let preview = preview_blogs(PathBuf::from_str(BLOG_ROOT).unwrap(), 2, None);
 //! let tags = get_blog_tag_list(PathBuf::from_str(BLOG_ROOT).unwrap());
 //! let blog_post = render_blog_post(PathBuf::from_str(BLOG_ROOT).unwrap(), date, slug, None).unwrap();
+//! let sitemap = create_sitemap(BLOG_ROOT, URL, &SitemapOptions::default());
 //! ```
 //!
 //! This method can have serious runtime performance implecations, but might be
@@ -111,6 +113,18 @@
 
 mod common;
 
+mod types;
+
+pub use types::Blog;
+
+/// Sitemap related utilities can be found here. If you use `high` or `medium`
+/// then the only thing you need from here is `SitemapOptions` to configure
+/// how a sitemap is generated.
+///
+/// If you use `low` then the function `create_sitemap` can be used to
+/// generate the sitemap
+pub mod sitemap;
+
 /// `high` refers to high RAM usage - using this module you will be effectively
 /// storing the entire blog in memory at all times using a lazy static. Highest
 /// runtime performance but higest RAM usage
@@ -118,8 +132,8 @@ mod common;
 /// ```rust,ignore
 /// lazy_static! {
 ///     pub static ref STATIC_BLOG_ENTRIES: HighBlog =
-///         get_high_blog(PathBuf::from(BLOG_ROOT), None, None);
-///     }
+///         get_high_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
+/// }
 /// ```
 pub mod high;
 
@@ -133,6 +147,7 @@ pub mod high;
 /// let preview = preview_blogs(PathBuf::from_str(BLOG_ROOT).unwrap(), 2, None);
 /// let tags = get_blog_tag_list(PathBuf::from_str(BLOG_ROOT).unwrap());
 /// let blog_post = render_blog_post(PathBuf::from_str(BLOG_ROOT).unwrap(), date, slug, None).unwrap();
+/// let sitemap = create_sitemap(BLOG_ROOT, URL, &SitemapOptions::default());
 /// ```
 pub mod low;
 
@@ -143,7 +158,7 @@ pub mod low;
 /// ```rust,ignore
 /// lazy_static! {
 ///     pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
-///         get_medium_blog(PathBuf::from(BLOG_ROOT), None, None);
+///         get_medium_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::Default());
 ///     }
 ///
 /// let this_blog = match all_blogs.hash.get(&complete_slug) {
diff --git a/src/low/mod.rs b/src/low/mod.rs
index 0a45d24..e08fbe8 100644
--- a/src/low/mod.rs
+++ b/src/low/mod.rs
@@ -1,421 +1,5 @@
-use std::{fs, path::Path};
+mod parse;
+mod types;
 
-use chrono::NaiveDate;
-use markdown::{mdast::Node, to_html_with_options, Options};
-use serde::{Deserialize, Serialize};
-use walkdir::WalkDir;
-
-use crate::common::{get_json_data, preview::get_preview, toc, BlogError, BlogJson};
-
-/// Use this function to get a list of all unique tags in your blog
-///
-/// WARNING: With many blogs this function could become extremely slow -
-/// maybe consider caching this? Even though this is the no-cache option, a list
-/// of single word strings isn't that large. If even this is too large to fit in
-/// memory, you probably need a database rather than this crate
-pub fn get_blog_tag_list<T: AsRef<Path>>(base: T) -> Result<Vec<String>, BlogError> {
-    let mut tags = vec![];
-
-    for entry in WalkDir::new(base) {
-        let entry = entry.unwrap();
-
-        let path = entry.path();
-
-        let extension = match path.extension() {
-            Some(x) => x.to_str().unwrap(),
-            None => continue,
-        };
-
-        if extension != "json" {
-            continue;
-        }
-
-        let parent = match path.parent() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_name = match path.file_name() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_name = match file_name.to_str() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let md_file_name = file_name.replace(".json", ".md");
-
-        let md_file_path = parent.join(md_file_name);
-
-        if !md_file_path.exists() {
-            continue;
-        }
-
-        let json_text = get_json_data(path)?;
-
-        for tag in &json_text.tags {
-            if !tags.contains(tag) {
-                tags.push(tag.clone())
-            }
-        }
-    }
-
-    return Ok(tags);
-}
-
-/// This function will find all of the blogs with the specified tag, so they
-/// can be previewed (e.g. on a tag index page). They won't contain the full HTML
-/// of the blog, only a preview.
-///
-/// Control the legnth of the preview with `preview_length`. Default is 320 chars
-pub fn preview_blogs_tagged<T: AsRef<Path>>(
-    base: T,
-    tag: String,
-    preview_length: Option<usize>,
-) -> Result<Vec<PreviewBlogEntry>, BlogError> {
-    let mut blogs = vec![];
-
-    for entry in WalkDir::new(base) {
-        let entry = entry.unwrap();
-
-        let f_n = match entry.file_name().to_str() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        if !f_n.ends_with(".json") {
-            continue;
-        }
-
-        let path = entry.path();
-        let json = get_json_data(path)?;
-
-        if !json.tags.contains(&tag) {
-            continue;
-        }
-
-        // Great! We've found the blog post!
-
-        let parent = match path.parent() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_name = match path.file_name() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_name = match file_name.to_str() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_base = file_name.replace(".json", ".md");
-
-        let md_path = parent.join(file_base);
-
-        let md = match fs::read_to_string(md_path) {
-            Ok(x) => x,
-            Err(y) => return Err(BlogError::File(y)),
-        };
-
-        // TODO: tbh I'm not very happy with rendering the HTML every single time here
-        let html = match to_html_with_options(
-            &md,
-            &Options {
-                compile: markdown::CompileOptions {
-                    allow_dangerous_html: true,
-                    allow_dangerous_protocol: true,
-
-                    ..markdown::CompileOptions::default()
-                },
-                ..markdown::Options::default()
-            },
-        ) {
-            Ok(x) => x,
-            Err(y) => return Err(BlogError::Markdown(y)),
-        };
-
-        let preview = get_preview(&html, preview_length);
-
-        let blog = PreviewBlogEntry::new(json, preview);
-
-        blogs.push(blog);
-    }
-
-    return Ok(blogs);
-}
-
-/// Renders an individual blog post.
-///
-/// Provide the date of the blog post and the slug (the slug as found in the
-/// "slug" field of the JSON).
-///
-/// Optionally, provide a table of contents generation function
-///
-/// Returns `None` if the specified blog can not be found
-pub fn render_blog_post<T: AsRef<Path>>(
-    base: T,
-    date: String,
-    slug: String,
-    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
-) -> Result<Option<LowBlogEntry>, BlogError> {
-    let base = base.as_ref();
-    let split: Vec<&str> = date.split("-").collect();
-
-    let year = match split.get(0) {
-        Some(&x) => x,
-        None => return Err(BlogError::ImproperDate(date.clone())),
-    };
-
-    let folder = base.join(format!("{}", year)).join(format!("{}", date));
-
-    for entry in WalkDir::new(folder) {
-        let entry = entry.unwrap();
-
-        let f_n = match entry.file_name().to_str() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        if !f_n.ends_with(".json") {
-            continue;
-        }
-
-        let path = entry.path();
-        let json = get_json_data(path)?;
-
-        if json.slug != slug {
-            continue;
-        }
-
-        // Great! We've found the blog post!
-
-        let parent = match path.parent() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        // TODO: I've done this little two stage file name thing several times - there must be scope for abstracting this into a function
-        let file_name = match path.file_name() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_name = match file_name.to_str() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_base = file_name.replace(".json", ".md");
-
-        let md_path = parent.join(file_base);
-
-        let md = match fs::read_to_string(md_path) {
-            Ok(x) => x,
-            Err(y) => return Err(BlogError::File(y)),
-        };
-
-        let html = match to_html_with_options(
-            &md,
-            &Options {
-                compile: markdown::CompileOptions {
-                    allow_dangerous_html: true,
-                    allow_dangerous_protocol: true,
-
-                    ..markdown::CompileOptions::default()
-                },
-                ..markdown::Options::default()
-            },
-        ) {
-            Ok(x) => x,
-            Err(y) => return Err(BlogError::Markdown(y)),
-        };
-
-        let toc = toc(&md, toc_generation_func)?;
-
-        return Ok(Some(LowBlogEntry::new(json, html, toc)));
-    }
-
-    return Ok(None);
-}
-
-/// Previews blogs for an index page. Will order from newest to oldest
-///
-/// `num` controls how many blogs will be in the preview
-///
-/// `preview_length` is how long each preview will be. Default is 320 chars
-pub fn preview_blogs<T: AsRef<Path>>(
-    base: T,
-    num: usize,
-    preview_length: Option<usize>,
-) -> Result<Vec<PreviewBlogEntry>, BlogError> {
-    let mut json_paths = vec![];
-
-    for entry in WalkDir::new(base) {
-        let entry = entry.unwrap();
-
-        let path = entry.path();
-
-        let extension = match path.extension() {
-            Some(x) => x,
-            None => continue,
-        };
-
-        if extension == "json" {
-            json_paths.push(path.to_path_buf());
-        }
-    }
-
-    let mut blogs = vec![];
-
-    for i in 0..num {
-        let this_path = match json_paths.get(i) {
-            Some(x) => x,
-            None => break,
-        };
-
-        let json = get_json_data(this_path)?;
-
-        let parent = match json_paths[i].parent() {
-            // We can use [i] here since we know this must exist :)
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_name = match json_paths[i].file_name() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_name = match file_name.to_str() {
-            Some(x) => x,
-            None => return Err(BlogError::FileNotFound),
-        };
-
-        let file_name = file_name.replace(".json", ".md");
-
-        let md_path = parent.join(file_name);
-
-        let markdown = match fs::read_to_string(md_path) {
-            Ok(x) => x,
-            Err(y) => return Err(BlogError::File(y)),
-        };
-
-        let html = match to_html_with_options(
-            &markdown,
-            &Options {
-                compile: markdown::CompileOptions {
-                    allow_dangerous_html: true,
-                    allow_dangerous_protocol: true,
-
-                    ..markdown::CompileOptions::default()
-                },
-                ..markdown::Options::default()
-            },
-        ) {
-            Ok(x) => x,
-            Err(y) => return Err(BlogError::Markdown(y)),
-        };
-
-        let preview: String = get_preview(&html, preview_length);
-
-        let blog_preview = PreviewBlogEntry::new(json, preview);
-
-        blogs.push(blog_preview);
-    }
-
-    blogs.sort_by(|a, b| b.date.cmp(&a.date));
-
-    return Ok(blogs);
-}
-
-/// An individual blog post
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct LowBlogEntry {
-    /// Title of the blog post
-    pub title: String,
-    /// Date published
-    pub date: NaiveDate,
-    /// Description
-    pub desc: Option<String>,
-    /// The blog post HTML that would be included into a template
-    pub html: String,
-    /// The URL slug
-    pub slug: String,
-    /// `Vec` of tags for this blog
-    pub tags: Vec<String>,
-    /// Table of contents
-    pub toc: Option<String>,
-    /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
-    pub keywords: Option<Vec<String>>,
-    /// Optional canonical link, intended for SEO
-    pub canonical_link: Option<String>,
-    /// Optional author name
-    pub author_name: Option<String>,
-    /// Optional URL for the author
-    pub author_webpage: Option<String>,
-}
-
-impl LowBlogEntry {
-    pub(crate) fn new(json: BlogJson, html: String, toc: Option<String>) -> Self {
-        return LowBlogEntry {
-            title: json.title,
-            date: json.date,
-            desc: json.desc,
-            html: html,
-            slug: format!("{}/{}", json.date, json.slug),
-            tags: json.tags,
-            toc: toc,
-            keywords: json.keywords,
-            canonical_link: json.canonical_link,
-            author_name: json.author_name,
-            author_webpage: json.author_webpage,
-        };
-    }
-}
-
-/// An individual blog post
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct PreviewBlogEntry {
-    /// Title of the blog post
-    pub title: String,
-    /// Date published
-    pub date: NaiveDate,
-    /// Description
-    pub desc: Option<String>,
-    /// The URL slug
-    pub slug: String,
-    /// `Vec` of tags for this blog
-    pub tags: Vec<String>,
-    /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
-    pub keywords: Option<Vec<String>>,
-    /// Optional canonical link, intended for SEO
-    pub canonical_link: Option<String>,
-    /// Optional author name
-    pub author_name: Option<String>,
-    /// Optional URL for the author
-    pub author_webpage: Option<String>,
-    /// Preview of the blogpost, useful for showing on index pages
-    pub preview: String,
-}
-
-impl PreviewBlogEntry {
-    pub(crate) fn new(json: BlogJson, preview: String) -> Self {
-        return PreviewBlogEntry {
-            title: json.title,
-            date: json.date,
-            desc: json.desc,
-            slug: format!("{}/{}", json.date, json.slug),
-            tags: json.tags,
-            keywords: json.keywords,
-            canonical_link: json.canonical_link,
-            author_name: json.author_name,
-            author_webpage: json.author_webpage,
-            preview: preview,
-        };
-    }
-}
+pub use parse::{get_blog_tag_list, preview_blogs, preview_blogs_tagged, render_blog_post};
+pub use types::{LowBlogEntry, PreviewBlogEntry};
diff --git a/src/low/parse.rs b/src/low/parse.rs
new file mode 100644
index 0000000..2ecd2ec
--- /dev/null
+++ b/src/low/parse.rs
@@ -0,0 +1,334 @@
+use std::{fs, path::Path};
+
+use markdown::{mdast::Node, to_html_with_options, Options};
+use walkdir::WalkDir;
+
+use crate::common::{get_json_data, preview::get_preview, toc, BlogError};
+
+use super::types::{LowBlogEntry, PreviewBlogEntry};
+
+/// Use this function to get a list of all unique tags in your blog
+///
+/// WARNING: With many blogs this function could become extremely slow -
+/// maybe consider caching this? Even though this is the no-cache option, a list
+/// of single word strings isn't that large. If even this is too large to fit in
+/// memory, you probably need a database rather than this crate
+pub fn get_blog_tag_list<T: AsRef<Path>>(base: T) -> Result<Vec<String>, BlogError> {
+    let mut tags = vec![];
+
+    for entry in WalkDir::new(base) {
+        let entry = entry.unwrap();
+
+        let path = entry.path();
+
+        let extension = match path.extension() {
+            Some(x) => x.to_str().unwrap(),
+            None => continue,
+        };
+
+        if extension != "json" {
+            continue;
+        }
+
+        let parent = match path.parent() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_name = match path.file_name() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_name = match file_name.to_str() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let md_file_name = file_name.replace(".json", ".md");
+
+        let md_file_path = parent.join(md_file_name);
+
+        if !md_file_path.exists() {
+            continue;
+        }
+
+        let json_text = get_json_data(path)?;
+
+        for tag in &json_text.tags {
+            if !tags.contains(tag) {
+                tags.push(tag.clone())
+            }
+        }
+    }
+
+    return Ok(tags);
+}
+
+/// This function will find all of the blogs with the specified tag, so they
+/// can be previewed (e.g. on a tag index page). They won't contain the full HTML
+/// of the blog, only a preview.
+///
+/// Control the legnth of the preview with `preview_length`. Default is 320 chars
+pub fn preview_blogs_tagged<T: AsRef<Path>>(
+    base: T,
+    tag: String,
+    preview_length: Option<usize>,
+) -> Result<Vec<PreviewBlogEntry>, BlogError> {
+    let mut blogs = vec![];
+
+    for entry in WalkDir::new(base) {
+        let entry = entry.unwrap();
+
+        let f_n = match entry.file_name().to_str() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        if !f_n.ends_with(".json") {
+            continue;
+        }
+
+        let path = entry.path();
+        let json = get_json_data(path)?;
+
+        if !json.tags.contains(&tag) {
+            continue;
+        }
+
+        // Great! We've found the blog post!
+
+        let parent = match path.parent() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_name = match path.file_name() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_name = match file_name.to_str() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_base = file_name.replace(".json", ".md");
+
+        let md_path = parent.join(file_base);
+
+        let md = match fs::read_to_string(md_path) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        // TODO: tbh I'm not very happy with rendering the HTML every single time here
+        let html = match to_html_with_options(
+            &md,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let preview = get_preview(&html, preview_length);
+
+        let blog = PreviewBlogEntry::new(json, preview);
+
+        blogs.push(blog);
+    }
+
+    return Ok(blogs);
+}
+
+/// Renders an individual blog post.
+///
+/// Provide the date of the blog post and the slug (the slug as found in the
+/// "slug" field of the JSON).
+///
+/// Optionally, provide a table of contents generation function
+///
+/// Returns `None` if the specified blog can not be found
+pub fn render_blog_post<T: AsRef<Path>>(
+    base: T,
+    date: String,
+    slug: String,
+    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
+) -> Result<Option<LowBlogEntry>, BlogError> {
+    let base = base.as_ref();
+    let split: Vec<&str> = date.split("-").collect();
+
+    let year = match split.get(0) {
+        Some(&x) => x,
+        None => return Err(BlogError::ImproperDate(date.clone())),
+    };
+
+    let folder = base.join(format!("{}", year)).join(format!("{}", date));
+
+    for entry in WalkDir::new(folder) {
+        let entry = entry.unwrap();
+
+        let f_n = match entry.file_name().to_str() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        if !f_n.ends_with(".json") {
+            continue;
+        }
+
+        let path = entry.path();
+        let json = get_json_data(path)?;
+
+        if json.slug != slug {
+            continue;
+        }
+
+        // Great! We've found the blog post!
+
+        let parent = match path.parent() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        // TODO: I've done this little two stage file name thing several times - there must be scope for abstracting this into a function
+        let file_name = match path.file_name() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_name = match file_name.to_str() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_base = file_name.replace(".json", ".md");
+
+        let md_path = parent.join(file_base);
+
+        let md = match fs::read_to_string(md_path) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        let html = match to_html_with_options(
+            &md,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let toc = toc(&md, toc_generation_func)?;
+
+        return Ok(Some(LowBlogEntry::new(json, html, toc)));
+    }
+
+    return Ok(None);
+}
+
+/// Previews blogs for an index page. Will order from newest to oldest
+///
+/// `num` controls how many blogs will be in the preview
+///
+/// `preview_length` is how long each preview will be. Default is 320 chars
+pub fn preview_blogs<T: AsRef<Path>>(
+    base: T,
+    num: usize,
+    preview_length: Option<usize>,
+) -> Result<Vec<PreviewBlogEntry>, BlogError> {
+    let mut json_paths = vec![];
+
+    for entry in WalkDir::new(base) {
+        let entry = entry.unwrap();
+
+        let path = entry.path();
+
+        let extension = match path.extension() {
+            Some(x) => x,
+            None => continue,
+        };
+
+        if extension == "json" {
+            json_paths.push(path.to_path_buf());
+        }
+    }
+
+    let mut blogs = vec![];
+
+    for i in 0..num {
+        let this_path = match json_paths.get(i) {
+            Some(x) => x,
+            None => break,
+        };
+
+        let json = get_json_data(this_path)?;
+
+        let parent = match json_paths[i].parent() {
+            // We can use [i] here since we know this must exist :)
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_name = match json_paths[i].file_name() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_name = match file_name.to_str() {
+            Some(x) => x,
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        let file_name = file_name.replace(".json", ".md");
+
+        let md_path = parent.join(file_name);
+
+        let markdown = match fs::read_to_string(md_path) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        let html = match to_html_with_options(
+            &markdown,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let preview: String = get_preview(&html, preview_length);
+
+        let blog_preview = PreviewBlogEntry::new(json, preview);
+
+        blogs.push(blog_preview);
+    }
+
+    blogs.sort_by(|a, b| b.date.cmp(&a.date));
+
+    return Ok(blogs);
+}
diff --git a/src/low/types.rs b/src/low/types.rs
new file mode 100644
index 0000000..15d464b
--- /dev/null
+++ b/src/low/types.rs
@@ -0,0 +1,214 @@
+use std::fs;
+
+use chrono::NaiveDate;
+use markdown::{to_html_with_options, Options};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    common::{get_json_data, preview::get_preview, toc, BlogError, BlogJson},
+    types::Blog,
+};
+
+/// An individual blog post
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct LowBlogEntry {
+    /// Title of the blog post
+    pub title: String,
+    /// Date published
+    pub date: NaiveDate,
+    /// Description
+    pub desc: Option<String>,
+    /// The blog post HTML that would be included into a template
+    pub html: String,
+    /// The URL slug
+    pub slug: String,
+    /// `Vec` of tags for this blog
+    pub tags: Vec<String>,
+    /// Table of contents
+    pub toc: Option<String>,
+    /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
+    pub keywords: Option<Vec<String>>,
+    /// Optional canonical link, intended for SEO
+    pub canonical_link: Option<String>,
+    /// Optional author name
+    pub author_name: Option<String>,
+    /// Optional URL for the author
+    pub author_webpage: Option<String>,
+    last_modified: Option<NaiveDate>,
+    priority: Option<f64>,
+    previw_chars: Option<usize>,
+}
+
+impl Blog for LowBlogEntry {
+    fn create<T: AsRef<std::path::Path>>(
+        blog: T,
+        toc_generation_func: Option<&dyn Fn(&markdown::mdast::Node) -> String>,
+        preview_chars: Option<usize>,
+    ) -> Result<Self, crate::common::BlogError> {
+        let json = get_json_data(&blog)?;
+
+        let markdown = match fs::read_to_string(blog) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        let html = match to_html_with_options(
+            &markdown,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let toc = toc(&markdown, toc_generation_func)?;
+
+        return Ok(LowBlogEntry {
+            title: json.title,
+            date: json.date,
+            desc: json.desc,
+            html: html,
+            slug: json.slug,
+            tags: json.tags,
+            toc: toc,
+            keywords: json.keywords,
+            canonical_link: json.canonical_link,
+            author_name: json.author_name,
+            author_webpage: json.author_webpage,
+            last_modified: json.last_modified,
+            priority: json.priority,
+            previw_chars: preview_chars,
+        });
+    }
+    fn get_title(&self) -> String {
+        return self.title.clone();
+    }
+
+    fn get_date_listed(&self) -> NaiveDate {
+        return self.date.clone();
+    }
+
+    fn get_description(&self) -> Option<String> {
+        return self.desc.clone();
+    }
+
+    fn get_html(&self) -> String {
+        return self.html.clone();
+    }
+
+    fn get_full_slug(&self) -> String {
+        return format!("{}/{}", self.get_date_listed(), self.get_part_slug());
+    }
+
+    fn get_part_slug(&self) -> String {
+        return self.slug.clone();
+    }
+
+    fn get_tags(&self) -> Vec<String> {
+        return self.tags.clone();
+    }
+
+    fn get_table_of_contents(&self) -> Option<String> {
+        return self.toc.clone();
+    }
+
+    fn get_keywords(&self) -> Option<Vec<String>> {
+        return self.keywords.clone();
+    }
+
+    fn get_canonicle_link(&self) -> Option<String> {
+        return self.canonical_link.clone();
+    }
+
+    fn get_author_name(&self) -> Option<String> {
+        return self.author_name.clone();
+    }
+
+    fn get_author_webpage(&self) -> Option<String> {
+        return self.author_webpage.clone();
+    }
+
+    fn get_preview(&self) -> String {
+        let preview = get_preview(&self.html, self.previw_chars);
+
+        return preview;
+    }
+
+    fn get_last_modified(&self) -> Option<NaiveDate> {
+        return self.last_modified.clone();
+    }
+
+    fn get_priority(&self) -> Option<f64> {
+        return self.priority.clone();
+    }
+}
+
+impl LowBlogEntry {
+    pub(crate) fn new(json: BlogJson, html: String, toc: Option<String>) -> Self {
+        return LowBlogEntry {
+            title: json.title,
+            date: json.date,
+            desc: json.desc,
+            html: html,
+            slug: json.slug,
+            tags: json.tags,
+            toc: toc,
+            keywords: json.keywords,
+            canonical_link: json.canonical_link,
+            author_name: json.author_name,
+            author_webpage: json.author_webpage,
+            last_modified: json.last_modified,
+            priority: json.priority,
+            previw_chars: None,
+        };
+    }
+}
+
+/// An individual blog post
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct PreviewBlogEntry {
+    /// Title of the blog post
+    pub title: String,
+    /// Date published
+    pub date: NaiveDate,
+    /// Description
+    pub desc: Option<String>,
+    /// The URL slug
+    pub slug: String,
+    /// `Vec` of tags for this blog
+    pub tags: Vec<String>,
+    /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
+    pub keywords: Option<Vec<String>>,
+    /// Optional canonical link, intended for SEO
+    pub canonical_link: Option<String>,
+    /// Optional author name
+    pub author_name: Option<String>,
+    /// Optional URL for the author
+    pub author_webpage: Option<String>,
+    /// Preview of the blogpost, useful for showing on index pages
+    pub preview: String,
+}
+
+impl PreviewBlogEntry {
+    pub(crate) fn new(json: BlogJson, preview: String) -> Self {
+        return PreviewBlogEntry {
+            title: json.title,
+            date: json.date,
+            desc: json.desc,
+            slug: json.slug,
+            tags: json.tags,
+            keywords: json.keywords,
+            canonical_link: json.canonical_link,
+            author_name: json.author_name,
+            author_webpage: json.author_webpage,
+            preview: preview,
+        };
+    }
+}
diff --git a/src/medium/mod.rs b/src/medium/mod.rs
index 848c449..35cd0fb 100644
--- a/src/medium/mod.rs
+++ b/src/medium/mod.rs
@@ -1,177 +1,5 @@
-use std::{collections::HashMap, fs, path::PathBuf};
-
-use chrono::{Datelike, NaiveDate};
-use markdown::{mdast::Node, to_html_with_options, Options};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    common::{BlogError, BlogJson},
-    high::HighBlogEntry,
-};
-
-use self::parse::get_blog_entries;
-
 mod parse;
+mod types;
 
-/// Gets the whole `MediumBlog` from the specified path. Useful to combine with lazy
-/// static for loading times
-///
-/// The path should be a folder which contains markdown files next to json files
-///
-/// Add an optional toc generation function if you want a table of contents
-///
-/// Optionally specify the number of chars for the preview. Default is 320.
-///
-/// ```rust,ignore
-/// lazy_static! {
-///     pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
-///         get_medium_blog(PathBuf::from(BLOG_ROOT), None, None).unwrap();
-///     }
-///
-/// let this_blog = match all_blogs.hash.get(&complete_slug) {
-///     Some(x) => x,
-///     None => return None,
-/// };
-///
-/// context.insert(
-///     "blog",
-///     &this_blog
-///         .render(PathBuf::from_str(BLOG_ROOT).unwrap())
-///         .unwrap(),
-/// );
-/// ```
-///
-pub fn get_medium_blog(
-    base: PathBuf,
-    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
-    preview_chars: Option<usize>,
-) -> Result<MediumBlog, BlogError> {
-    return get_blog_entries(base, toc_generation_func, preview_chars);
-}
-
-/// The main `MediumBlog` which stores all relevant information for the blog
-///
-/// `hash` contains a map from the url slug, which is constructed from the
-/// "slug" field in the `BlogJson` and the date, to the `BlogEntry`
-///
-/// `entries` contains a date-sorted (newest first) `Vec` of `BlogEntry`.
-/// Note that `entries` and `hash` contain the same information
-/// but in different formats for performance reasons
-///
-/// `tags` is an unsorted `Vec` of all unique tags used in the blog
-///
-#[derive(Serialize, Deserialize)]
-pub struct MediumBlog {
-    /// URL slug to individual blog
-    ///
-    /// Useful when you have a GET request to /blog/\<date\>/\<slug\>
-    pub hash: HashMap<String, MediumBlogEntry>,
-    /// `Vec` of blog posts, sorted by date
-    ///
-    /// Useful when you want to list all blog posts e.g. on an index page
-    pub entries: Vec<MediumBlogEntry>,
-    /// `Vec` of all unique tags
-    ///
-    /// Useful when you want to list all tags e.g. on an index page
-    pub tags: Vec<String>,
-}
-
-/// An individual blog post. You will need to render this using `render`
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct MediumBlogEntry {
-    /// Title of the blog post
-    pub title: String,
-    /// Date published
-    pub date: NaiveDate,
-    /// Description
-    pub desc: Option<String>,
-    /// The URL slug
-    pub slug: String,
-    /// `Vec` of tags for this blog
-    pub tags: Vec<String>,
-    /// Table of contents
-    pub toc: Option<String>,
-    /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
-    pub keywords: Option<Vec<String>>,
-    /// Optional canonical link, intended for SEO
-    pub canonical_link: Option<String>,
-    /// Optional author name
-    pub author_name: Option<String>,
-    /// Optional URL for the author
-    pub author_webpage: Option<String>,
-    /// Preview of the blogpost, useful for showing on index pages
-    pub preview: String,
-    file_name: String,
-}
-
-impl MediumBlogEntry {
-    pub(crate) fn new(
-        json: BlogJson,
-        toc: Option<String>,
-        preview: String,
-        file_name: String,
-    ) -> Self {
-        return MediumBlogEntry {
-            title: json.title,
-            date: json.date,
-            desc: json.desc,
-            slug: format!("{}/{}", json.date, json.slug),
-            tags: json.tags,
-            toc: toc,
-            keywords: json.keywords,
-            canonical_link: json.canonical_link,
-            author_name: json.author_name,
-            author_webpage: json.author_webpage,
-            preview: preview,
-            file_name,
-        };
-    }
-
-    /// Use this function to render a `MediumBlogEntry` into a `HighBlogEntry`,
-    /// which then contains the full blog HTML you can return to a user
-    pub fn render(&self, base: PathBuf) -> Result<HighBlogEntry, BlogError> {
-        let year = self.date.year();
-        let path = base
-            .join(format!("{}", year))
-            .join(format!("{}", self.date))
-            .join(self.file_name.clone());
-
-        let md = match fs::read_to_string(path) {
-            Ok(x) => x,
-            Err(y) => return Err(BlogError::File(y)),
-        };
-
-        let html = match to_html_with_options(
-            &md,
-            &Options {
-                compile: markdown::CompileOptions {
-                    allow_dangerous_html: true,
-                    allow_dangerous_protocol: true,
-
-                    ..markdown::CompileOptions::default()
-                },
-                ..markdown::Options::default()
-            },
-        ) {
-            Ok(x) => x,
-            Err(y) => return Err(BlogError::Markdown(y)),
-        };
-
-        let high = HighBlogEntry {
-            title: self.title.clone(),
-            date: self.date.clone(),
-            desc: self.desc.clone(),
-            html,
-            slug: self.slug.clone(),
-            tags: self.tags.clone(),
-            toc: self.toc.clone(),
-            keywords: self.keywords.clone(),
-            canonical_link: self.canonical_link.clone(),
-            author_name: self.author_name.clone(),
-            author_webpage: self.author_webpage.clone(),
-            preview: self.preview.clone(),
-        };
-
-        return Ok(high);
-    }
-}
+pub use parse::get_medium_blog;
+pub use types::{MediumBlog, MediumBlogEntry};
diff --git a/src/medium/parse.rs b/src/medium/parse.rs
index e6abfea..b5dd88b 100644
--- a/src/medium/parse.rs
+++ b/src/medium/parse.rs
@@ -1,100 +1,86 @@
-use std::{collections::HashMap, fs, path::Path};
-
-use markdown::{mdast::Node, to_html_with_options, Options};
-
-use crate::common::{get_blog_paths, get_json_data, preview::get_preview, toc, BlogError};
-
-use super::{MediumBlog, MediumBlogEntry};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+use markdown::mdast::Node;
+
+use crate::{
+    common::{parse_blogs, BlogError},
+    sitemap::{create_sitemap_inner, SitemapOptions},
+    Blog,
+};
+
+use super::types::{MediumBlog, MediumBlogEntry};
+
+/// Gets the whole `MediumBlog` from the specified path. Useful to combine with lazy
+/// static for loading times
+///
+/// The path should be a folder which contains markdown files next to json files
+///
+/// Add an optional toc generation function if you want a table of contents
+///
+/// Optionally specify the number of chars for the preview. Default is 320.
+///
+/// ```rust,ignore
+/// lazy_static! {
+///     pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
+///         get_medium_blog(PathBuf::from(BLOG_ROOT), None, None).unwrap();
+///     }
+///
+/// let this_blog = match all_blogs.hash.get(&complete_slug) {
+///     Some(x) => x,
+///     None => return None,
+/// };
+///
+/// context.insert(
+///     "blog",
+///     &this_blog
+///         .render(PathBuf::from_str(BLOG_ROOT).unwrap())
+///         .unwrap(),
+/// );
+/// ```
+///
+pub fn get_medium_blog(
+    base: PathBuf,
+    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
+    preview_chars: Option<usize>,
+    url: &String,
+    sitemap_options: &SitemapOptions,
+) -> Result<MediumBlog, BlogError> {
+    return get_blog_entries(
+        base,
+        toc_generation_func,
+        preview_chars,
+        url,
+        sitemap_options,
+    );
+}
 
 pub fn get_blog_entries<T: AsRef<Path>>(
     base: T,
     toc_generation_func: Option<&dyn Fn(&Node) -> String>,
     preview_chars: Option<usize>,
+    url: &String,
+    sitemap_options: &SitemapOptions,
 ) -> Result<MediumBlog, BlogError> {
-    let blog_paths = get_blog_paths(base).unwrap();
-
     let mut hashes: HashMap<String, MediumBlogEntry> = HashMap::new();
-    let mut entries: Vec<MediumBlogEntry> = vec![];
-    let mut tags: Vec<String> = vec![];
 
-    for blog in blog_paths {
-        let out = process_blogs(&blog, &tags, toc_generation_func, preview_chars)?;
+    let (mut entries, tags): (Vec<MediumBlogEntry>, Vec<String>) =
+        parse_blogs(base, toc_generation_func, preview_chars)?;
 
-        hashes.insert(out.blog_entry.slug.clone(), out.blog_entry.clone());
-        entries.push(out.blog_entry.clone());
-        tags.extend(out.tags);
+    for entry in &entries {
+        hashes.insert(entry.get_full_slug(), entry.clone());
     }
 
-    entries.sort_by(|a, b| b.date.cmp(&a.date));
+    entries.sort_by(|a, b| b.get_date_listed().cmp(&a.get_date_listed()));
+
+    let sitemap = create_sitemap_inner(&entries, Some(&tags), url, sitemap_options)?;
 
     return Ok(MediumBlog {
         hash: hashes,
-        entries,
-        tags,
+        entries: entries,
+        tags: tags,
+        sitemap: sitemap,
     });
 }
-
-fn process_blogs<T: AsRef<Path>>(
-    blog: T,
-    tags: &Vec<String>,
-    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
-    preview_chars: Option<usize>,
-) -> Result<SingleBlogProcess, BlogError> {
-    let blog = blog.as_ref();
-    let json_data = get_json_data(blog)?;
-
-    let mut out_tags = vec![];
-    for tag in &json_data.tags {
-        if !tags.contains(&tag) {
-            // I guess technically, we can get repeats if the user puts the same tag in the json list...
-            out_tags.push(tag.clone());
-        }
-    }
-
-    let markdown = match fs::read_to_string(blog) {
-        Ok(x) => x,
-        Err(y) => return Err(BlogError::File(y)),
-    };
-
-    let html = match to_html_with_options(
-        &markdown,
-        &Options {
-            compile: markdown::CompileOptions {
-                allow_dangerous_html: true,
-                allow_dangerous_protocol: true,
-
-                ..markdown::CompileOptions::default()
-            },
-            ..markdown::Options::default()
-        },
-    ) {
-        Ok(x) => x,
-        Err(y) => return Err(BlogError::Markdown(y)),
-    };
-
-    let preview: String = get_preview(&html, preview_chars);
-
-    let toc = toc(&markdown, toc_generation_func)?;
-
-    let file_name = match blog.file_name() {
-        Some(x) => x,
-        None => return Err(BlogError::FileNotFound),
-    };
-
-    let file_name = match file_name.to_str() {
-        Some(x) => x.to_string(),
-        None => return Err(BlogError::FileNotFound),
-    };
-
-    let blog_entry = MediumBlogEntry::new(json_data, toc, preview, file_name);
-
-    return Ok(SingleBlogProcess {
-        blog_entry,
-        tags: out_tags,
-    });
-}
-
-struct SingleBlogProcess {
-    pub blog_entry: MediumBlogEntry,
-    pub tags: Vec<String>,
-}
diff --git a/src/medium/types.rs b/src/medium/types.rs
new file mode 100644
index 0000000..97e025a
--- /dev/null
+++ b/src/medium/types.rs
@@ -0,0 +1,233 @@
+use std::{collections::HashMap, fs, path::PathBuf};
+
+use chrono::{Datelike, NaiveDate};
+use markdown::{to_html_with_options, Options};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    common::{get_json_data, preview::get_preview, toc, BlogError, BlogJson},
+    high::HighBlogEntry,
+    types::Blog,
+};
+
+/// The main `MediumBlog` which stores all relevant information for the blog
+///
+/// `hash` contains a map from the url slug, which is constructed from the
+/// "slug" field in the `BlogJson` and the date, to the `BlogEntry`
+///
+/// `entries` contains a date-sorted (newest first) `Vec` of `BlogEntry`.
+/// Note that `entries` and `hash` contain the same information
+/// but in different formats for performance reasons
+///
+/// `tags` is an unsorted `Vec` of all unique tags used in the blog
+///
+#[derive(Serialize, Deserialize)]
+pub struct MediumBlog {
+    /// URL slug to individual blog
+    ///
+    /// Useful when you have a GET request to /blog/\<date\>/\<slug\>
+    pub hash: HashMap<String, MediumBlogEntry>,
+    /// `Vec` of blog posts, sorted by date
+    ///
+    /// Useful when you want to list all blog posts e.g. on an index page
+    pub entries: Vec<MediumBlogEntry>,
+    /// `Vec` of all unique tags
+    ///
+    /// Useful when you want to list all tags e.g. on an index page
+    pub tags: Vec<String>,
+    /// `String` representation of the sitemap
+    pub sitemap: String,
+}
+
+/// An individual blog post. You will need to render this using `render`
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct MediumBlogEntry {
+    /// Title of the blog post
+    title: String,
+    /// Date published
+    date: NaiveDate,
+    /// Description
+    desc: Option<String>,
+    /// The URL slug
+    slug: String,
+    /// `Vec` of tags for this blog
+    tags: Vec<String>,
+    /// Table of contents
+    toc: Option<String>,
+    /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
+    keywords: Option<Vec<String>>,
+    /// Optional canonical link, intended for SEO
+    canonical_link: Option<String>,
+    /// Optional author name
+    author_name: Option<String>,
+    /// Optional URL for the author
+    author_webpage: Option<String>,
+    /// Preview of the blogpost, useful for showing on index pages
+    preview: String,
+    file_name: String, // ! can't be present in `high` or `low`
+    last_modified: Option<NaiveDate>,
+    priority: Option<f64>,
+}
+
+impl Blog for MediumBlogEntry {
+    fn create<T: AsRef<std::path::Path>>(
+        blog: T,
+        toc_generation_func: Option<&dyn Fn(&markdown::mdast::Node) -> String>,
+        preview_chars: Option<usize>,
+    ) -> Result<Self, BlogError> {
+        let json = get_json_data(&blog)?;
+
+        let markdown = match fs::read_to_string(&blog) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        let html = match to_html_with_options(
+            &markdown,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let preview: String = get_preview(&html, preview_chars);
+
+        let toc = toc(&markdown, toc_generation_func)?;
+
+        let file_name = match blog.as_ref().file_name() {
+            Some(x) => x.to_str().unwrap().to_string(),
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        return Ok(MediumBlogEntry::new(json, toc, preview, file_name));
+    }
+
+    fn get_title(&self) -> String {
+        return self.title.clone();
+    }
+
+    fn get_date_listed(&self) -> NaiveDate {
+        return self.date.clone();
+    }
+
+    fn get_description(&self) -> Option<String> {
+        return self.desc.clone();
+    }
+
+    fn get_html(&self) -> String {
+        todo!();
+    }
+
+    fn get_full_slug(&self) -> String {
+        return format!("{}/{}", self.get_date_listed(), self.get_part_slug());
+    }
+
+    fn get_part_slug(&self) -> String {
+        return self.slug.clone();
+    }
+
+    fn get_tags(&self) -> Vec<String> {
+        return self.tags.clone();
+    }
+
+    fn get_table_of_contents(&self) -> Option<String> {
+        return self.toc.clone();
+    }
+
+    fn get_keywords(&self) -> Option<Vec<String>> {
+        return self.keywords.clone();
+    }
+
+    fn get_canonicle_link(&self) -> Option<String> {
+        return self.canonical_link.clone();
+    }
+
+    fn get_author_name(&self) -> Option<String> {
+        return self.author_name.clone();
+    }
+
+    fn get_author_webpage(&self) -> Option<String> {
+        return self.author_webpage.clone();
+    }
+
+    fn get_preview(&self) -> String {
+        return self.preview.clone();
+    }
+
+    fn get_last_modified(&self) -> Option<NaiveDate> {
+        return self.last_modified.clone();
+    }
+
+    fn get_priority(&self) -> Option<f64> {
+        return self.priority.clone();
+    }
+}
+
+impl MediumBlogEntry {
+    pub(crate) fn new(
+        json: BlogJson,
+        toc: Option<String>,
+        preview: String,
+        file_name: String,
+    ) -> Self {
+        return MediumBlogEntry {
+            title: json.title,
+            date: json.date,
+            desc: json.desc,
+            slug: json.slug,
+            tags: json.tags,
+            toc: toc,
+            keywords: json.keywords,
+            canonical_link: json.canonical_link,
+            author_name: json.author_name,
+            author_webpage: json.author_webpage,
+            preview: preview,
+            file_name,
+            last_modified: json.last_modified,
+            priority: json.priority,
+        };
+    }
+
+    /// Use this function to render a `MediumBlogEntry` into a `HighBlogEntry`,
+    /// which then contains the full blog HTML you can return to a user
+    pub fn render(&self, base: PathBuf) -> Result<HighBlogEntry, BlogError> {
+        let year = self.date.year();
+        let path = base
+            .join(format!("{}", year))
+            .join(format!("{}", self.date))
+            .join(self.file_name.clone());
+
+        let md = match fs::read_to_string(path) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        let html = match to_html_with_options(
+            &md,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let high = HighBlogEntry::new_from_medium(self, html);
+
+        return Ok(high);
+    }
+}
diff --git a/src/sitemap/mod.rs b/src/sitemap/mod.rs
new file mode 100644
index 0000000..b61cc75
--- /dev/null
+++ b/src/sitemap/mod.rs
@@ -0,0 +1,6 @@
+mod sitemap;
+mod types;
+pub use sitemap::create_sitemap;
+pub use types::SitemapOptions;
+
+pub(crate) use sitemap::create_sitemap_inner;
diff --git a/src/sitemap/sitemap.rs b/src/sitemap/sitemap.rs
new file mode 100644
index 0000000..01ddbe3
--- /dev/null
+++ b/src/sitemap/sitemap.rs
@@ -0,0 +1,174 @@
+use std::{io::Cursor, path::Path};
+
+use xml::{reader::XmlEvent as ReaderXmlEvent, writer::XmlEvent, EmitterConfig, EventReader};
+
+use crate::{
+    common::{parse_blogs, BlogError},
+    low::LowBlogEntry,
+    types::Blog,
+};
+
+use super::types::SitemapOptions;
+
+const DATE_FORMAT: &'static str = "%d-%m-%Y";
+
+/// Use this function in `low` mode to generate a sitemap
+///
+/// Parameters
+///
+/// - `blog_root`: Path to the root of the blog e.g. `files/blog`
+/// - `url_base`: URL of the website e.g. `www.example.com`
+/// - `options`: `SitemapOptions` for configuration
+pub fn create_sitemap<T: AsRef<Path>>(
+    blog_root: T,
+    url_base: &String,
+    options: &SitemapOptions,
+) -> Result<String, BlogError> {
+    let (entries, tags): (Vec<LowBlogEntry>, Vec<String>) = parse_blogs(blog_root, None, None)?;
+
+    return create_sitemap_inner(&entries, Some(&tags), url_base, options);
+}
+
+pub fn create_sitemap_inner<T: Blog>(
+    entries: &Vec<T>,
+    maybe_tags: Option<&Vec<String>>,
+    url_base: &String,
+    options: &SitemapOptions,
+) -> Result<String, BlogError> {
+    let mut buffer = Cursor::new(Vec::new());
+    let mut writer = EmitterConfig::new()
+        .perform_indent(true)
+        .create_writer(&mut buffer);
+
+    writer
+        .write(
+            XmlEvent::start_element("urlset")
+                .attr("xmlns", "http://www.sitemaps.org/schemas/sitemap/0.9"),
+        )
+        .unwrap();
+
+    let default_priority = options.default_priority;
+
+    // Blog pages
+    for blog in entries {
+        writer.write(XmlEvent::start_element("url")).unwrap();
+
+        // Location
+        writer.write(XmlEvent::start_element("loc")).unwrap();
+
+        let loc = format!(
+            "{}/{}/{}",
+            url_base,
+            options.blog_root_slug,
+            blog.get_full_slug()
+        );
+
+        writer.write(XmlEvent::characters(&loc)).unwrap();
+        writer.write(XmlEvent::end_element()).unwrap();
+
+        // Last Modified
+        writer.write(XmlEvent::start_element("lastmod")).unwrap();
+
+        let lastmod = match blog.get_last_modified() {
+            Some(x) => x.format(DATE_FORMAT).to_string(),
+            None => blog.get_date_listed().format(DATE_FORMAT).to_string(),
+        };
+
+        writer.write(XmlEvent::characters(&lastmod)).unwrap();
+        writer.write(XmlEvent::end_element()).unwrap();
+
+        // Priority
+
+        writer.write(XmlEvent::start_element("priority")).unwrap();
+
+        let priority = match blog.get_priority() {
+            None => default_priority,
+            Some(x) => {
+                if x > 1.0 || x < 0.0 {
+                    panic!("Priority must be between 0.0 and 1.0, got `{}`", x);
+                }
+
+                x
+            }
+        };
+        writer
+            .write(XmlEvent::characters(&format!("{}", priority)))
+            .unwrap();
+        writer.write(XmlEvent::end_element()).unwrap();
+
+        writer.write(XmlEvent::end_element()).unwrap(); // Finish <url>
+    }
+
+    // Tag pages
+    if options.include_tags && maybe_tags.is_some() {
+        let tags = maybe_tags.unwrap();
+        let current_time = chrono::offset::Utc::now();
+        let lastmod = current_time.date_naive().format(&DATE_FORMAT).to_string();
+
+        for tag in tags {
+            writer.write(XmlEvent::start_element("url")).unwrap();
+
+            // Location
+            writer.write(XmlEvent::start_element("loc")).unwrap();
+
+            let loc = format!("{}/{}/{}", url_base, options.tag_root_slug, tag);
+
+            writer.write(XmlEvent::characters(&loc)).unwrap();
+            writer.write(XmlEvent::end_element()).unwrap();
+
+            // Last Modified
+            writer.write(XmlEvent::start_element("lastmod")).unwrap();
+
+            writer.write(XmlEvent::characters(&lastmod)).unwrap();
+            writer.write(XmlEvent::end_element()).unwrap();
+
+            // Priority
+
+            writer.write(XmlEvent::start_element("priority")).unwrap();
+
+            writer
+                .write(XmlEvent::characters(&format!("{}", default_priority)))
+                .unwrap();
+            writer.write(XmlEvent::end_element()).unwrap();
+
+            writer.write(XmlEvent::end_element()).unwrap(); // Finish <url>
+        }
+    }
+
+    if let Some(sitemap_base) = &options.sitemap_base {
+        let parser = EventReader::from_str(&sitemap_base);
+
+        for e in parser {
+            match e {
+                Ok(ReaderXmlEvent::StartElement { name, .. }) => {
+                    let this_name = name.to_string();
+                    if this_name == "urlset" {
+                        continue;
+                    }
+                    writer
+                        .write(XmlEvent::start_element(this_name.as_str()))
+                        .unwrap();
+                }
+                Ok(ReaderXmlEvent::Characters(x)) => {
+                    writer.write(XmlEvent::characters(&x)).unwrap();
+                }
+                Ok(ReaderXmlEvent::EndElement { name }) => {
+                    if name.to_string() == "urlset" {
+                        continue;
+                    }
+                    writer.write(XmlEvent::end_element()).unwrap();
+                }
+                Err(e) => {
+                    eprintln!("Error: {e}");
+                    break;
+                }
+                // There's more: https://docs.rs/xml-rs/latest/xml/reader/enum.XmlEvent.html
+                _ => {}
+            }
+        }
+    }
+
+    writer.write(XmlEvent::end_element()).unwrap(); // End <urlset>
+
+    return Ok(String::from_utf8(buffer.into_inner()).unwrap());
+}
diff --git a/src/sitemap/types.rs b/src/sitemap/types.rs
new file mode 100644
index 0000000..9b82d3e
--- /dev/null
+++ b/src/sitemap/types.rs
@@ -0,0 +1,45 @@
+/// Options to configure how the sitemap is generated
+///
+/// `blog-tools` can generate a sitemap for all of the blogs and tags,
+/// but obviously doesn't know about any other pages. However, if you provide
+/// this struct with a String representation of an XML sitemap it will
+/// automatically add those pages into the sitemap for you
+pub struct SitemapOptions {
+    /// The default priority to use for a blog in the sitemap if no priority is
+    /// provided inside the JSON. If this is not explicityly set then the
+    /// default is 0.5
+    pub default_priority: f64,
+    /// Whether to include tag pages in the sitemap. Set this to `true` if your
+    /// website has explicit pages where all the blogs of a certain tag are
+    /// present
+    pub include_tags: bool,
+    /// This represents the location of the blog in the URL. The default is
+    /// `blog`. This would mean the individual blog posts are found at
+    /// `www.example.com/blog/2024-05-12/my-blog`. If you set this parameter to
+    /// `blog-home` then the sitemap would generate
+    /// www.example.com/blog-home/2024-05/12/my-blog`
+    pub blog_root_slug: String,
+    /// This represents the location of the tag index in the URL. The default is
+    /// `blog/tag`, if you set `include_tags` to `true`. If `include_tags` is
+    /// `false` (default behaviour), then this is ignored.
+    /// For example, if you had a tag called `science` then the
+    /// URL would be `www.example.com/blog/tag/science`.
+    pub tag_root_slug: String,
+    /// Optional `String` representation of an XML sitemap. This function will
+    /// automatically merge the records of this sitemap into the sitemap it
+    /// generates. Useful if you have a bunch of pages which are not part of the
+    /// blog that you'd like in the sitemap
+    pub sitemap_base: Option<String>,
+}
+
+impl Default for SitemapOptions {
+    fn default() -> Self {
+        Self {
+            default_priority: 0.5, // TODO: Maybe move this value into a constant?
+            include_tags: false,
+            blog_root_slug: "blog".to_string(), // TODO: Maybe move this value into a constant?
+            tag_root_slug: "blog/tag".to_string(),
+            sitemap_base: None,
+        }
+    }
+}
diff --git a/src/types.rs b/src/types.rs
new file mode 100644
index 0000000..00983f3
--- /dev/null
+++ b/src/types.rs
@@ -0,0 +1,73 @@
+use std::path::Path;
+
+use chrono::NaiveDate;
+use markdown::mdast::Node;
+
+use crate::common::BlogError;
+
+// TODO: give these lifetimes so we don't need to clone
+/// Primary trait that describes a single blog post. Any struct which derives
+/// this is intended to be converted into a JSON with serde and used in a template.
+/// You can of course use any of these other methods for any purpose in the
+/// blog
+pub trait Blog: Clone {
+    /// Create a blog post
+    ///
+    /// Parameters
+    ///
+    /// - `blog`: Path to the root of the blog
+    ///     For this to work, you should have a folder, for instance, `blog` which serves
+    ///     as the root. Within this folder, you must have the following structure
+    ///
+    ///     - blog
+    ///         - 2023
+    ///             - 2023-01-01
+    ///                 - my_first_blog.json
+    ///                 - my_first_blog.md
+    ///             - (other folders)
+    ///
+    /// - `toc_generation_func` - A function which parses a blog and generates
+    ///     a table of contents. Optional.
+    /// - `preview_chars` - number of chars to be taken in the preview of the
+    ///     blog. Default is 320.
+    fn create<T: AsRef<Path>>(
+        blog: T,
+        toc_generation_func: Option<&dyn Fn(&Node) -> String>,
+        preview_chars: Option<usize>,
+    ) -> Result<Self, BlogError>;
+    /// Get the blog title
+    fn get_title(&self) -> String;
+    /// Get the original publication date
+    fn get_date_listed(&self) -> NaiveDate;
+    /// Get the SEO description
+    fn get_description(&self) -> Option<String>;
+    /// Get the HTML of the blog
+    fn get_html(&self) -> String;
+    /// Get the full slug - this would be e.g. `2024-03-19/my-blog`.
+    /// In the JSON, you should NOT include the date in the slug
+    fn get_full_slug(&self) -> String;
+    /// Get the partial slug of the blog. This would be the `slug` field from the
+    /// JSON
+    fn get_part_slug(&self) -> String;
+    /// Get a list of tags for the blog
+    fn get_tags(&self) -> Vec<String>;
+    /// Get the table of contents. Only present if a table of contents funciton
+    /// was provided
+    fn get_table_of_contents(&self) -> Option<String>;
+    /// Get keywords
+    fn get_keywords(&self) -> Option<Vec<String>>;
+    /// Get the canonicle link
+    fn get_canonicle_link(&self) -> Option<String>;
+    /// Get the author
+    fn get_author_name(&self) -> Option<String>; // TODO: Maybe support authors?
+    /// Get the author webpage
+    fn get_author_webpage(&self) -> Option<String>; // TODO: again, support multiple authors?
+    /// Get the blog preview. This is the first few hundred characters of the blog,
+    /// useful for an index page
+    fn get_preview(&self) -> String;
+    /// Get the last modified date, mostly use for sitemaps. This is not the
+    /// original publication date
+    fn get_last_modified(&self) -> Option<NaiveDate>;
+    /// Get the priority for the sitemap
+    fn get_priority(&self) -> Option<f64>;
+}
diff --git a/templates/blog.html.tera b/templates/blog.html.tera
index 877e7dc..8f5e624 100644
--- a/templates/blog.html.tera
+++ b/templates/blog.html.tera
@@ -27,6 +27,8 @@
     {% if blog.desc %}
     <meta name="description" content="{{ blog.desc }}">
     {% endif %}
+
+    <link rel="icon" href="/favicon.ico">
 </head>
 
 <body>
diff --git a/templates/blog_index.html.tera b/templates/blog_index.html.tera
index 44938a1..8ede688 100644
--- a/templates/blog_index.html.tera
+++ b/templates/blog_index.html.tera
@@ -7,6 +7,7 @@
     <link rel="stylesheet" type="text/css" href="/css/style.css">
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="icon" href="/favicon.ico">
 </head>
 
 <body>
@@ -22,7 +23,7 @@
             {% for entry in blog.entries %}
 
             <div class="blog-card">
-                <a href="/blog/{{ entry.slug }}" class="no-underline black-links">
+                <a href="/blog/{{ entry.date }}/{{ entry.slug }}" class="no-underline black-links">
                     <div class="card-body">
                         <h4>
                             <span>{{ entry.title }}</span>
diff --git a/templates/tags.html.tera b/templates/tags.html.tera
index 774b9eb..fa353ad 100644
--- a/templates/tags.html.tera
+++ b/templates/tags.html.tera
@@ -7,6 +7,7 @@
     <link rel="stylesheet" type="text/css" href="/css/style.css">
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="icon" href="/favicon.ico">
 </head>
 
 <body>
@@ -22,7 +23,7 @@
             {% for entry in blogs %}
 
             <div class="blog-card">
-                <a href="/blog/{{ entry.slug }}" class="no-underline black-links">
+                <a href="/blog/{{ entry.date }}/{{ entry.slug }}" class="no-underline black-links">
                     <div class="card-body">
                         <h4>
                             <span>{{ entry.title }}</span>