diff --git a/rphylopic/img/rphylopic-radial-phylogeny.png b/rphylopic/img/rphylopic-radial-phylogeny.png
new file mode 100644
index 0000000..de86617
Binary files /dev/null and b/rphylopic/img/rphylopic-radial-phylogeny.png differ
diff --git a/rphylopic/index.qmd b/rphylopic/index.qmd
new file mode 100644
index 0000000..61c79c2
--- /dev/null
+++ b/rphylopic/index.qmd
@@ -0,0 +1,184 @@
+---
+title: "Introduction to rphylopic"
+description: "An R package that allows users to easily fetch and visualize silhouettes of organisms from PhyloPic."
+author:
+  - William Gearty
+  - Lewis A. Jones
+date: "`r Sys.Date()`"
+categories: [r, ggplot2, dataviz]
+difficulty: Beginner
+image: img/rphylopic-radial-phylogeny.png
+format:
+  html:
+    toc: true
+  revealjs:
+    smaller: true
+    output-file: index-slides.html
+    css: style/template.css
+    slide-number: c/t
+    include-in-header: style/header.html
+    include-after-body: style/footer.html
+execute:
+  output-location: fragment
+  echo: true
+  warning: false
+  message: false
+  freeze: auto
+filters:
+  - at: pre-ast
+    path: web_and_slides_autogenerated.lua
+editor:
+  markdown:
+    wrap: 72
+---
+
+<!-- ENSURE THAT THIS DOCUMENT FOLLOWS THE MODULE STRUCTURE DESCRIBED IN THE GUIDELINES -->
+<!-- https://docs.google.com/document/d/16cxSA2bA1MnrnpzmN2yzJNCwJVO7Hm5ceyz10sCmnzY/edit?tab=t.0 -->
+
+## Introduction
+
+### What is PhyloPic
+
+[PhyloPic](https://www.phylopic.org) is an open database of free silhouette images of animals, plants, and other life forms, available for reuse under Creative Commons licenses. At time of writing, >13,000 silhouette images are available covering a broad array of biological groups from dinosaurs and corals to grasses and viruses. To date, the silhouettes have been created by over 500 volunteer contributors, and are increasingly used in data visualisation.
+
+### What is **rphylopic**
+
+::: {.narration}
+
+**rphylopic** is a package that allows users to easily fetch and visualize silhouettes of organisms from [PhyloPic](https://www.phylopic.org/). The package allows users to add silhouettes as layers or as data points to both base R and ggplot2 plots. Additional functionality allows users to pick between available silhouettes, transform them (e.g., rotate and recolor), and save image files. This module will give you an overview of the package and provide example usage.
+
+:::
+
+::: {.slides-only}
+
+- a bullet summary for the slide
+- which would be redundant on the page
+
+:::
+
+### Installation
+
+## Using rphylopic
+
+### Getting silhouettes
+
+::: {.narration}
+Every silhouette available via PhyloPic has a universally unique identifier (UUID). The first step to get a PhyloPic silhouette into R is to 1) identify the silhouette you want and then 2) identify the UUID for that silhouette. rphylopic provides a couple different ways to do this:
+:::
+
+::: {.narration}
+The simplest way to do this is to use the `get_uuid()` function. You can use this function to search PhyloPic based on a taxonomic or phylogenetic name (e.g., Canis lupus or pan-Mollusca). However, multiple silhouettes (and hence UUIDs) can exist for a searched name. The n argument in `get_uuid()` allows you to fetch n matched UUIDs. Using a returned UUID, you can then fetch the respective silhouette using `get_phylopic()`.
+:::
+
+```{r}
+# Load rphylopic
+library(rphylopic)
+# Get a single image UUID for a species
+uuid <- get_uuid(name = "Canis lupus")
+# Get the image for that UUID
+img <- get_phylopic(uuid = uuid)
+plot(img)
+```
+
+```{r}
+# But multiple silhouettes can exist per species...
+uuid <- get_uuid(name = "Canis lupus", n = 5)
+```
+
+## One plot per slide
+
+::: {.narration}
+Each `##` heading starts a slide, and the filter closes the slide after every
+figure, so two plots never share one slide. Prose after a figure introduces the next
+figure rather than trailing behind the old one.
+:::
+
+::: {.panel-tabset}
+
+### Tab A
+
+```{r}
+#| code-fold: true
+plot(mtcars$wt, mtcars$mpg)
+```
+
+### Tab B
+
+```{r}
+plot(mtcars$hp, mtcars$mpg)
+```
+
+:::
+
+```{r}
+plot(mtcars$wt, mtcars$mpg)
+```
+
+::: {.narration}
+This narration belongs to the plot below, and lands on its slide as speaker notes.
+:::
+
+```{r}
+plot(mtcars$hp, mtcars$mpg)
+```
+
+## Deeper headings
+
+::: {.narration}
+`###` and deeper headings are promoted to slide level, so each becomes its own
+slide instead of piling onto the previous slide. On the website they stay a normal
+sub-heading.
+:::
+
+### A sub-heading
+
+::: {.narration}
+This is its own slide.
+:::
+
+## Building up a slide
+
+::: {.narration}
+When a slide holds two or more code chunks, the filter expands it into an
+auto-animate build-up: one step per chunk, earlier chunks staying on screen, and
+the narration advancing with each step/click.
+:::
+
+```{r}
+x <- mtcars$wt
+mean(x)
+```
+
+::: {.narration}
+The second chunk arrives on the next step, with the first still visible.
+:::
+
+```{r}
+round(sd(x), 3)
+```
+
+## Callouts
+
+::: {.narration}
+A callout gets a slide of its own. The content is un-boxed and the slide is titled by its own heading.
+:::
+
+::: {.callout-note}
+## A note
+
+This box is dropped on the slide, which lets a figure inside it stretch to fit.
+:::
+
+::: {.callout-caution collapse="true"}
+## An exercise solution
+
+A *collapsed* callout is the exception: it keeps its box. Since clicking on
+slides can be awkward, the collapsed content is held back as a fragment and
+revealed when you advance. On the website it stays a click-to-open box.
+:::
+
+## More info
+
+- [Quarto revealjs](https://quarto.org/docs/presentations/revealjs/)
+- [Callouts](https://quarto.org/docs/authoring/callouts.html)
+- the repo README, for the other two ways to build a module
diff --git a/rphylopic/style/logo_top_right.png b/rphylopic/style/logo_top_right.png
new file mode 100644
index 0000000..72455f2
Binary files /dev/null and b/rphylopic/style/logo_top_right.png differ
diff --git a/rphylopic/style/template.css b/rphylopic/style/template.css
new file mode 100644
index 0000000..7a61ee0
--- /dev/null
+++ b/rphylopic/style/template.css
@@ -0,0 +1,125 @@
+/* Same background as on the website */
+.reveal .slide-background {
+  background: rgb(245.4, 250.35, 250.65);
+}
+
+p,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+ul,
+ol,
+li,
+center,
+.quarto-title-authors {
+  color: #575756 !important;
+}
+
+/* Logo pinned in the top right corner of every slide */
+.reveal::after {
+  content: "";
+  position: fixed;
+  right: 10%;
+  top: -5px;
+  width: 15%;
+  height: 15%;
+  background-image: url(logo_top_right.png);
+  background-size: contain;
+  background-position: right bottom;
+  background-repeat: no-repeat;
+  z-index: 10;
+}
+
+/* Social links footer, on the title slide only */
+.title-footer {
+  display: none;
+  position: fixed;
+  bottom: 0;
+  left: 0;
+  height: 3%;
+  width: 100%;
+  padding: 0.6em 1em;
+  text-align: center;
+  font-family: var(--r-main-font);
+  font-size: 18px;
+  color: white;
+  background-color: #0d725a;
+  z-index: 10;
+}
+
+.title-footer span {
+  margin: 0 1.5em;
+}
+
+.title-footer a {
+  display: inline-flex;
+  align-items: center;
+  color: white;
+  text-decoration: none;
+}
+
+.title-footer i {
+  font-size: 1.4em;
+}
+
+body:has(#title-slide.present) .title-footer {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+/* Larger logo on the title slide */
+.reveal:has(#title-slide.present)::after {
+  width: 30%;
+  height: 30%;
+  left: 33%;
+  top: -45px;
+}
+
+/* Recolor the menu icon (it is an image, not a glyph) */
+body:has(#title-slide.present) .reveal .slide-menu-button .fa-bars::before {
+  filter: brightness(0) invert(1);
+}
+
+h1 {
+  text-align: center;
+}
+
+/* Slide numbers: plain text, not on the title slide */
+.reveal .slide-number a {
+  color: #575756;
+  text-decoration: none;
+  pointer-events: none;
+}
+
+body:has(#title-slide.present) .reveal .slide-number {
+  display: none !important;
+}
+
+/* Code almost at the same size as the surrounding text */
+.reveal code {
+  font-size: 0.9em;
+}
+
+.reveal pre {
+  font-size: 0.7em;
+}
+
+/* Slightly rounded code blocks */
+.reveal div.sourceCode {
+  border-radius: 8px;
+  overflow: hidden;
+  border: 1px solid #0d725a;
+}
+
+.reveal pre {
+  border-radius: 8px;
+}
+
+/* Wrap the slide title to avoid overlapping with the logo in the top right corner */
+section>h2 {
+  width: 85%;
+}
\ No newline at end of file
diff --git a/rphylopic/web_and_slides_autogenerated.lua b/rphylopic/web_and_slides_autogenerated.lua
new file mode 100644
index 0000000..dd7ad54
--- /dev/null
+++ b/rphylopic/web_and_slides_autogenerated.lua
@@ -0,0 +1,307 @@
+-- web_and_slides_autogenerated.lua -- AUTOGENERATED, DO NOT EDIT.
+-- Copied from the repo root's web_and_slides.lua by sync_filter.r (see _quarto.yml).
+-- Edit that file instead; this copy exists so the module is self-contained.
+--
+-- web_and_slides.lua
+-- Combined filter for dual html + revealjs Quarto modules:
+--   * Div    : `::: {.narration}`   -> speaker notes on revealjs, plain prose elsewhere.
+--              `::: {.slides-only}` -> revealjs slides only: dropped elsewhere
+--              (equivalent to `::: {.content-visible when-format="revealjs"}`)
+--              `::: {.html-only}`   -> html only: dropped on revealjs slides
+--              (equivalent to `::: {.content-hidden when-format="revealjs"}`)
+--   * Pandoc : on revealjs, headings below the slide level are promoted so each
+--              becomes its own slide, the slide closes after each plot (so no two
+--              plots share a slide and a plot's following prose stays with the
+--              next plot -- unless only prose remains before the next heading, in
+--              which case it stays put rather than making a blank slide), and each
+--              callout is unwrapped onto its own slide titled by its own heading
+--              (no box, so any figure inside hoists and stretches; an untitled
+--              callout keeps the section title; a callout the author collapsed
+--              keeps its box, its body held back as a fragment, since revealjs
+--              ignores Quarto's `collapse`). Split slides repeat the current
+--              heading so they keep a title. Finally, any slide with 2+ cells is
+--              expanded into an auto-animate build-up (one step per cell, cells
+--              accumulating, notes advancing) so each step is a real slide whose
+--              figure still hoists and auto-stretches; an interactive quarto-live
+--              cell is skipped there, since duplicating it duplicates the editor.
+--              Other formats untouched.
+-- Register at the `pre-ast` stage so callouts are still plain divs here (Quarto
+-- normalizes them into custom AST nodes after that point).
+
+function Div(el)
+  if el.classes:includes("slides-only") then
+    if not quarto.doc.is_format("revealjs") then
+      return {}                                  -- slides only: nothing on the website
+    end
+    return el.content
+  end
+  if el.classes:includes("html-only") then
+    if quarto.doc.is_format("revealjs") then
+      return {}                                  -- html only: nothing on the slides
+    end
+    return el.content
+  end
+  if not el.classes:includes("narration") then
+    return nil                                   -- leave every other div alone
+  end
+  if quarto.doc.is_format("revealjs") then
+    el.classes = el.classes:filter(function(c) return c ~= "narration" end)
+    el.classes:insert("notes")                   -- Pandoc emits <aside class="notes">
+    return el
+  end
+  return el.content                              -- drop wrapper, keep prose inline
+end
+
+function Pandoc(doc)
+  if not quarto.doc.is_format("revealjs") then
+    return nil                                   -- leave the website (html) alone
+  end
+
+  local slide_level = 2                          -- revealjs default
+  local sl = doc.meta["slide-level"]
+  if sl then slide_level = tonumber(pandoc.utils.stringify(sl)) or 2 end
+
+  local function is_callout(el)
+    for _, c in ipairs(el.classes) do
+      if c:match("^callout") then return true end
+    end
+    return false
+  end
+
+  local function has_plot(cell)                  -- a rendered figure/display output
+    for _, child in ipairs(cell.content) do
+      if child.t == "Div" and child.classes:includes("cell-output-display") then
+        return true
+      end
+    end
+    return false
+  end
+
+  local kept_collapsed = false   -- a collapsed callout kept its box; needs the CSS below
+
+  -- revealjs ignores Quarto's `collapse`, so a callout the author collapsed (a
+  -- hidden solution, say) would otherwise be given away on the slide. Keep its
+  -- box and title and hold the body back as a fragment, revealed on the next
+  -- advance. `collapse="false"` (collapsible but open) is not affected.
+  local function is_collapsed(el)
+    local c = el.attributes["collapse"]
+    return c ~= nil and c ~= "false"
+  end
+
+  -- clone a collapsed callout with everything after its title heading wrapped in
+  -- a `.fragment` div; its nested content is left exactly as the author wrote it
+  local function hold_collapsed(el)
+    kept_collapsed = true
+    local kept, body = el:clone(), pandoc.List()
+    local titled = #kept.content > 0 and kept.content[1].t == "Header"
+    for j = (titled and 2 or 1), #kept.content do body:insert(kept.content[j]) end
+    if #body == 0 then return kept end
+    local held = pandoc.List()
+    if titled then held:insert(kept.content[1]) end
+    held:insert(pandoc.Div(body, pandoc.Attr("", { "fragment" })))
+    kept.content = held
+    return kept
+  end
+
+  -- unwrap callouts to plain blocks (recursively, for nested callouts) so their
+  -- content sits directly on the slide -- a de-boxed callout behaves like normal
+  -- slide content, and any figure inside hoists and auto-stretches. Headings at
+  -- or above the slide level are demoted so a nested title can't split the slide;
+  -- the leading heading is re-promoted to the slide title by the caller.
+  local function unwrap_callouts(blocks)
+    local flat = pandoc.List()
+    for _, b in ipairs(blocks) do
+      if b.t == "Div" and is_callout(b) and is_collapsed(b) then
+        flat:insert(hold_collapsed(b))         -- collapsed: keep the box
+      elseif b.t == "Div" and is_callout(b) then
+        flat:extend(unwrap_callouts(b.content))
+      elseif b.t == "Header" and b.level <= slide_level then
+        local h = b:clone(); h.level = slide_level + 1; flat:insert(h)
+      else
+        flat:insert(b)
+      end
+    end
+    return flat
+  end
+
+  -- is there any visible code cell before the next slide boundary, starting at
+  -- block index `from`? A heading, rule, or callout is a boundary (a callout
+  -- self-titles onto its own slide), so a trailing note only breaks if a plain
+  -- cell -- not a callout -- lands on the new slide first.
+  local function content_before_boundary(from)
+    for j = from, #doc.blocks do
+      local b = doc.blocks[j]
+      if b.t == "Header" or b.t == "HorizontalRule" then return false end
+      if b.t == "Div" and is_callout(b) then return false end
+      if b.t == "Div" and b.classes:includes("cell") then return true end
+    end
+    return false
+  end
+
+  local out            = pandoc.List()
+  local pending        = false                   -- a break is owed before the next slide content
+  local filled         = false                   -- this slide already holds a visible cell/callout
+  local current_header = nil                     -- most recent slide title, repeated on splits
+
+  -- a break that keeps the current title: a fresh heading, else a plain rule
+  local function slide_break()
+    if current_header then
+      local h = current_header:clone()
+      h.level = slide_level                       -- render as a content-slide title
+      h.identifier = ""                           -- let Quarto assign a fresh unique id
+      return h
+    end
+    return pandoc.HorizontalRule()
+  end
+
+  for i = 1, #doc.blocks do
+    local blk = doc.blocks[i]
+    if blk.t == "Header" then
+      if blk.level > slide_level then blk.level = slide_level end   -- deep headings -> own slide
+      if blk.level <= slide_level then pending = false; filled = false end
+      current_header = blk
+      out:insert(blk)
+    elseif blk.t == "HorizontalRule" then
+      pending = false; filled = false
+      out:insert(blk)
+    elseif blk.t == "Div" and is_callout(blk) and is_collapsed(blk) then
+      -- collapsed: keep the box, since unwrapping it would reveal the content.
+      -- Lands on its own slide under the section title, body held as a fragment.
+      if pending or filled then out:insert(slide_break()) end
+      out:insert(hold_collapsed(blk))
+      filled = true; pending = true
+    elseif blk.t == "Div" and is_callout(blk) then
+      -- give the callout its own slide titled by its own heading (promoted to the
+      -- slide level, so the heading is itself the slide boundary); content is
+      -- unwrapped so any figure inside hoists and stretches
+      local content = unwrap_callouts(blk.content)
+      if #content > 0 and content[1].t == "Header" then
+        local title = content[1]:clone()
+        title.level = slide_level                                                -- callout heading -> slide title
+        title.identifier = ""
+        content[1] = title
+        out:extend(content)
+      else
+        if pending or filled then out:insert(slide_break()) end                  -- untitled callout keeps the section title
+        out:extend(content)
+      end
+      filled = true; pending = true                                              -- alone; close the slide after
+    elseif blk.t == "Div" and blk.classes:includes("cell") then
+      if pending then out:insert(slide_break()); pending = false; filled = false end
+      filled = true
+      if has_plot(blk) then pending = true end                                   -- close the slide after a plot
+      out:insert(blk)
+    else
+      -- prose/notes: honor a plot's pending break only if a cell/callout still
+      -- follows before the next heading -- so the prose introduces the next
+      -- slide. If only notes remain, breaking would make a blank titled slide,
+      -- so keep them on the current slide instead.
+      if pending then
+        if content_before_boundary(i + 1) then out:insert(slide_break()); filled = false end
+        pending = false
+      end
+      out:insert(blk)
+    end
+  end
+
+  -- second pass: expand any slide holding 2+ cells into an auto-animate build-up
+  -- -- one step per cell, cells accumulating, notes advancing with each new cell.
+  -- Each step is a real slide, so its figure still hoists and auto-stretches
+  -- (unlike a fragment). Single-cell and cell-free slides pass through unchanged.
+
+  -- a quarto-live editor cell (`{webr}` / `{pyodide}`): at this stage knitr has
+  -- passed the block through, so the cell holds a CodeBlock whose language is
+  -- still brace-wrapped
+  local live_langs = {                           -- the spellings live.lua itself accepts
+    ["{webr}"] = true, webr = true, ["{webr-r}"] = true,
+    ["{pyodide}"] = true, pyodide = true, ["{pyodide-python}"] = true,
+  }
+  local function is_interactive(b)
+    if b.t ~= "Div" or not b.classes:includes("cell") then return false end
+    for _, c in ipairs(b.content) do
+      if c.t == "CodeBlock" then
+        for _, cl in ipairs(c.classes) do
+          if live_langs[cl] then return true end
+        end
+      end
+    end
+    return false
+  end
+
+  -- only executed cells make build-up steps: an interactive cell is left where
+  -- the author put it, because duplicating it across steps duplicates the
+  -- editor, and whatever a student typed on one step would not carry to the next
+  local function is_cell(b)
+    return b.t == "Div" and b.classes:includes("cell") and not is_interactive(b)
+  end
+
+  local function strip_ids(cell)                 -- clone a cell with ids blanked (it is duplicated across steps)
+    local c = cell:clone()
+    c.identifier = ""
+    return pandoc.walk_block(c, {
+      Div       = function(d)  d.identifier  = ""; return d  end,
+      CodeBlock = function(cb) cb.identifier = ""; return cb end,
+    })
+  end
+
+  local function emit_slide(delim, body, dest)
+    local segs, notes = {}, pandoc.List()         -- notes accumulates until the next cell
+    for _, b in ipairs(body) do
+      if is_cell(b) then
+        segs[#segs + 1] = { notes = notes, cell = b }; notes = pandoc.List()
+      else
+        notes:insert(b)
+      end
+    end                                            -- leftover `notes` = trailing, after the last cell
+
+    -- nothing to build up, or no heading to carry the auto-animate flag: emit as-is
+    if #segs < 2 or delim == nil or delim.t ~= "Header" then
+      if delim then dest:insert(delim) end
+      for _, b in ipairs(body) do dest:insert(b) end
+      return
+    end
+
+    for k = 1, #segs do
+      local h = delim:clone()
+      h.identifier = ""                            -- fresh id per step
+      h.attributes["auto-animate"] = "true"
+      dest:insert(h)
+      for j = 1, k do dest:insert(strip_ids(segs[j].cell)) end     -- cells 1..k accumulate
+      for _, n in ipairs(segs[k].notes) do dest:insert(n) end      -- notes for the cell just revealed
+      if k == #segs then
+        for _, n in ipairs(notes) do dest:insert(n) end            -- trailing notes on the last step
+      end
+    end
+  end
+
+  local expanded, delim, body = pandoc.List(), nil, pandoc.List()
+  for _, b in ipairs(out) do
+    -- a slide boundary is a rule or a heading at/above the slide level; deeper
+    -- headings (e.g. an unwrapped callout's title) stay within the slide
+    if b.t == "HorizontalRule" or (b.t == "Header" and b.level <= slide_level) then
+      emit_slide(delim, body, expanded); delim = b; body = pandoc.List()
+    else
+      body:insert(b)
+    end
+  end
+  emit_slide(delim, body, expanded)                -- flush the last slide
+
+
+  -- the revealjs theme shrinks every callout box to 0.7em (and compensates for
+  -- that in headings). A kept box holds ordinary slide content, so put the
+  -- slide's own sizes back inside it -- an extra class beats the theme's
+  -- specificity, and the heading variables keep a custom theme's scale.
+  if kept_collapsed then
+    quarto.doc.include_text("in-header", [==[<style>
+.reveal .slides section div.callout.callout-style-simple,
+.reveal .slides section div.callout.callout-style-default { font-size: inherit; }
+.reveal .slides section div.callout.callout-style-simple h1,
+.reveal .slides section div.callout.callout-style-default h1 { font-size: var(--r-heading1-size); }
+.reveal .slides section div.callout.callout-style-simple h2,
+.reveal .slides section div.callout.callout-style-default h2 { font-size: var(--r-heading2-size); }
+.reveal .slides section div.callout.callout-style-simple h3,
+.reveal .slides section div.callout.callout-style-default h3 { font-size: var(--r-heading3-size); }
+</style>]==])
+  end
+  return pandoc.Pandoc(expanded, doc.meta)
+end