diff --git a/R/revealjs_presentation.R b/R/revealjs_presentation.R
index 21212a7..c35cdeb 100644
--- a/R/revealjs_presentation.R
+++ b/R/revealjs_presentation.R
@@ -33,6 +33,47 @@
 #' ```
 #' to create notes only viewable in presentation mode.
 #' 
+#' ## Slide timing
+#' 
+#' Speaker time can be planned per slide and per speaker by adding a comment
+#' with a speaker code and the expected duration (in `MM:SS`, `HH:MM:SS`, or
+#' plain seconds format) anywhere inside a slide:
+#' 
+#' ```markdown
+#' ## My slide title
+#' 
+#' Some content
+#' 
+#' <!-- MK 00:30 -->
+#' ```
+#' 
+#' This means Marc Kupietz will need 30 seconds for that slide. For talks
+#' presented by a single speaker, the speaker code can be omitted:
+#' `<!-- 00:30 -->`.
+#' 
+#' Typically you start from a known total time budget and adjust the
+#' individual slides to it. You can set this budget yourself with the
+#' reveal.js `totalTime` option (in seconds):
+#' 
+#' ```yaml
+#' output:
+#'   revealjs.ids::revealjs_presentation:
+#'     reveal_options:
+#'       totalTime: 3600 # one hour
+#' ```
+#' 
+#' During rendering, comments are converted into `data-timing` attributes on
+#' the slides' `<section>` elements (several speakers per slide are summed
+#' up), and the calculated grand total is passed to reveal.js as the
+#' `totalTime` config value. This activates the pacing timer in the
+#' [speaker view](https://revealjs.com/speaker-view/), which shows how you
+#' are doing relative to your plan. A summary of the total time per speaker
+#' is printed during rendering. If the document sets `totalTime` or
+#' `defaultTiming` itself (via `reveal_options`), those take precedence.
+#'
+#' The function [slide_timing()] computes these totals directly from an
+#' `.Rmd` source file without rendering it.
+#' 
 #' ### Search
 #' 
 #' When opt-in, it is possible to show a search box when pressing `CTRL + SHIFT +
@@ -343,6 +384,21 @@
     args
   }
 
+  # post-processor converting <!-- MK 00:30 --> speaker timing comments into
+  # data-timing attributes on the enclosing sections (activating the pacing
+  # timer of the notes plugin) and reporting per-speaker totals
+  post_processor <- function(metadata, input_file, output_file, clean, verbose) {
+    lines <- readLines(output_file, warn = FALSE, encoding = "UTF-8")
+    result <- apply_timing_attributes(lines)
+    comments <- attr(result, "comments")
+    if (nrow(comments) > 0) {
+      result <- inject_total_time(result, sum(comments$seconds))
+      writeLines(enc2utf8(result), output_file, useBytes = TRUE)
+      message(timing_report_message(comments))
+    }
+    output_file
+  }
+
   # return format
   output_format(
     knitr = knitr_options_html(fig_width, fig_height, fig_retina, keep_md),
@@ -354,6 +410,7 @@
     keep_md = keep_md,
     clean_supporting = self_contained,
     pre_processor = pre_processor,
+    post_processor = post_processor,
     base_format = html_document_base(
       lib_dir = lib_dir,
       self_contained = self_contained,
diff --git a/R/slide_timing.R b/R/slide_timing.R
new file mode 100644
index 0000000..560716d
--- /dev/null
+++ b/R/slide_timing.R
@@ -0,0 +1,221 @@
+# Pattern matching timing comments, e.g. <!-- MK 00:30 --> or just <!-- 00:30 -->
+timing_comment_pattern <- paste0(
+  "<!--[[:space:]]*(?:([[:alnum:]._-]+)[[:space:]]+)?",
+  "([0-9]+(?::[0-9]{2}){0,2})[[:space:]]*-->"
+)
+
+parse_duration_seconds <- function(x) {
+  vapply(x, function(t) {
+    parts <- strsplit(t, ":", fixed = TRUE)[[1]]
+    parts <- suppressWarnings(as.numeric(parts))
+    if (length(parts) == 0 || length(parts) > 3 || anyNA(parts)) {
+      return(NA_real_)
+    }
+    multipliers <- c(3600, 60, 1)[(4 - length(parts)):3]
+    sum(parts * multipliers)
+  }, numeric(1), USE.NAMES = FALSE)
+}
+
+format_seconds <- function(x) {
+  x <- round(x)
+  h <- floor(x / 3600)
+  m <- floor((x %% 3600) / 60)
+  s <- x %% 60
+  ifelse(h > 0, sprintf("%d:%02d:%02d", h, m, s), sprintf("%d:%02d", m, s))
+}
+
+# Extract all timing comments from a character vector (one line per element).
+# Returns a data frame with columns line (1-based index), speaker (NA for
+# comments without a speaker code), duration, and seconds.
+extract_timing_comments <- function(lines) {
+  matches <- regmatches(lines, regexec(timing_comment_pattern, lines))
+  hits <- which(lengths(matches) > 0)
+  if (length(hits) == 0) {
+    return(data.frame(
+      line = integer(), speaker = character(), duration = character(),
+      seconds = numeric()
+    ))
+  }
+  speaker <- trimws(vapply(matches[hits], `[[`, character(1), 2))
+  speaker[speaker == ""] <- NA_character_
+  data.frame(
+    line = hits,
+    speaker = speaker,
+    duration = vapply(matches[hits], `[[`, character(1), 3),
+    seconds = parse_duration_seconds(vapply(matches[hits], `[[`, character(1), 3)),
+    stringsAsFactors = FALSE
+  )
+}
+
+# Assign each timing comment to the slide it belongs to. A comment belongs to
+# the slide whose heading most recently appeared before it; content before the
+# first heading belongs to the title slide.
+assign_slides <- function(lines, comments, slide_level) {
+  headings <- grepl(paste0("^#{1,", slide_level, "}[[:space:]]"), lines)
+  slide_of_line <- cumsum(headings)
+  comments$slide <- slide_of_line[comments$line]
+  titles <- trimws(sub("^#+[[:space:]]+", "", lines[headings]))
+  c("(title)", titles)[comments$slide + 1]
+}
+
+#' Compute per-speaker slide times from timing comments
+#'
+#' Parses an R Markdown presentation for timing comments of the form
+#' `<!-- MK 00:30 -->` (speaker code followed by a duration in `MM:SS`,
+#' `HH:MM:SS`, or plain seconds format) or, for single-speaker talks, simply
+#' `<!-- 00:30 -->`, and computes the time allocated to each slide, each
+#' speaker, and the whole presentation.
+#'
+#' The same convention can be used directly in
+#' [revealjs_presentation()]: any such comment in the source document is
+#' automatically converted into a `data-timing` attribute on the enclosing
+#' slide's `<section>` element, which activates the pacing timer in the
+#' reveal.js speaker view.
+#'
+#' @param input Path to an R Markdown file.
+#' @param slide_level Level of heading that denotes individual slides (should
+#'   match the `slide_level` used when rendering).
+#'
+#' @return A list with three elements: `slides` (one row per slide and
+#'   speaker), `speakers` (total time per speaker), and `total` (grand total
+#'   in seconds). `slide_timing()` is called for its side effect of printing a
+#'   summary.
+#'
+#' @examples
+#' \dontrun{
+#' slide_timing("talk.Rmd")
+#' }
+#'
+#' @importFrom stats aggregate
+#' @export
+slide_timing <- function(input, slide_level = 2) {
+  lines <- readLines(input, warn = FALSE)
+  comments <- extract_timing_comments(lines)
+  if (nrow(comments) == 0) {
+    message("No timing comments found in ", input)
+    return(invisible(NULL))
+  }
+  comments$slide_title <- assign_slides(lines, comments, slide_level)
+  comments$speaker <- timing_speaker_label(comments$speaker)
+
+  by_speaker <- aggregate(seconds ~ speaker, comments, FUN = sum)
+  total <- sum(comments$seconds)
+  show_speakers <- any(comments$speaker != "(unnamed)")
+
+  cat("Slide timing for", basename(input), "\n\n")
+  if (show_speakers) {
+    per_slide <- aggregate(seconds ~ slide_title + speaker, comments, FUN = sum)
+  } else {
+    per_slide <- aggregate(seconds ~ slide_title, comments, FUN = sum)
+  }
+  print(data.frame(
+    slide = per_slide$slide_title,
+    speaker = if (show_speakers) per_slide$speaker else NULL,
+    time = format_seconds(per_slide$seconds),
+    stringsAsFactors = FALSE
+  ))
+  cat("\n")
+  named_speakers <- by_speaker[by_speaker$speaker != "(unnamed)", , drop = FALSE]
+  if (nrow(named_speakers) > 0) {
+    print(
+      data.frame(
+        speaker = c(named_speakers$speaker, "total"),
+        time = format_seconds(c(named_speakers$seconds, total)),
+        stringsAsFactors = FALSE
+      ),
+      row.names = FALSE
+    )
+  } else {
+    cat("total time:", format_seconds(total), "\n")
+  }
+
+  invisible(list(slides = comments[, c("slide_title", "speaker", "duration", "seconds")],
+                 speakers = by_speaker, total = total))
+}
+
+# Display label for unnamed speakers
+timing_speaker_label <- function(speaker) {
+  ifelse(is.na(speaker), "(unnamed)", speaker)
+}
+
+# Convert timing comments into data-timing attributes on the enclosing
+# <section> elements of a rendered reveal.js HTML document. Returns the
+# modified lines invisibly along with the extracted comments as attributes.
+apply_timing_attributes <- function(lines) {
+  comments <- extract_timing_comments(lines)
+  if (nrow(comments) == 0) {
+    return(invisible(structure(lines, comments = comments)))
+  }
+
+  section_lines <- grep("^<section[^>]*>", lines)
+  section_of_comment <- findInterval(comments$line, section_lines)
+  ok <- section_of_comment > 0
+  if (!all(ok)) {
+    warning(
+      "Ignoring ", sum(!ok), " timing comment(s) outside any <section>",
+      call. = FALSE
+    )
+    comments <- comments[ok, , drop = FALSE]
+    section_of_comment <- section_of_comment[ok]
+  }
+
+  per_section <- tapply(comments$seconds, section_of_comment, sum)
+
+  for (idx in names(per_section)) {
+    target <- section_lines[as.integer(idx)]
+    lines[target] <- sub(
+      "^(<section[^>]*?)(/?>)$",
+      sprintf('\\1 data-timing="%d"\\2', round(per_section[[idx]])),
+      lines[target]
+    )
+  }
+
+  invisible(structure(lines, comments = comments))
+}
+
+# Activate the pacing timer of the notes plugin by injecting the total time
+# planned with the timing comments into the reveal.js configuration. Without
+# a totalTime or defaultTiming config value, the speaker view does not show
+# any pacing information at all.
+inject_total_time <- function(lines, seconds) {
+  # only respect explicitly configured pacing values, not e.g. the
+  # unconditional "defaultTiming: null" emitted by the pandoc template
+  pacing <- grep("\\b(totalTime|defaultTiming)\\s*:", lines, value = TRUE)
+  if (any(!grepl(":\\s*(null|0|false|\"\"|'')\\s*,?\\s*$", trimws(pacing)))) {
+    return(lines)
+  }
+  init <- grep("Reveal\\.initialize\\(\\s*\\{", lines)
+  if (length(init) == 0) {
+    return(lines)
+  }
+  append(
+    lines,
+    sprintf("\t\t\ttotalTime: %d,", round(seconds)),
+    after = init[[1]]
+  )
+}
+
+timing_report_message <- function(comments) {
+  comments$speaker <- timing_speaker_label(comments$speaker)
+  by_speaker <- aggregate(seconds ~ speaker, comments, FUN = sum)
+  total <- sum(comments$seconds)
+  named <- by_speaker[by_speaker$speaker != "(unnamed)", , drop = FALSE]
+  unnamed <- by_speaker[by_speaker$speaker == "(unnamed)", , drop = FALSE]
+  parts <- c(
+    # note: paste0() would treat a zero-length data frame column as "",
+    # so only build these strings when there is something to report
+    if (nrow(named) > 0) paste0(named$speaker, ": ", format_seconds(named$seconds)),
+    if (nrow(unnamed) > 1 || (nrow(unnamed) == 1 && nrow(named) > 0)) {
+      paste0("(unnamed): ", format_seconds(unnamed$seconds))
+    }
+  )
+  if (length(parts) > 0) {
+    sprintf(
+      "Slide timing -- %s -- total %s",
+      paste(parts, collapse = ", "),
+      format_seconds(total)
+    )
+  } else {
+    sprintf("Slide timing -- total %s", format_seconds(total))
+  }
+}