Get AI summaries of any video or article — Sign up free
Obsidian - Aprils Automatic Timelines thumbnail

Obsidian - Aprils Automatic Timelines

Josh Plunkett·
5 min read

Based on Josh Plunkett's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

April’s Automatic Timelines builds a vertical RPG timeline in Obsidian by pulling event data from each event note’s front matter.

Briefing

April’s Automatic Timelines turns Obsidian notes into a clean, vertical timeline for tabletop RPG campaigns—pulling event titles, dates, summaries, and optional images directly from each event note’s front matter. The big practical win is that it keeps event data in the vault as plain markdown files, avoiding the “data.json disappearing” anxiety that has surrounded Fantasy Calendar’s storage layer during its rebuild.

Setup starts with installing the Community plugin “April’s automatic timelines,” then configuring which front matter keys hold the timeline’s start date, end date, title, body, and picture. Out of the box, the plugin expects a specific set of keys (like AET event title and AET event body), but the configuration can be adjusted to match a user’s own templates. A key integration point is Fantasy Calendar support: enabling Fantasy Calendar presets lets the timeline read FC-style fields (FC date, FC end, FC display name, FC calendar, and FC category) so both systems stay synchronized.

Event notes are where the timeline magic happens. Each note includes front matter wrapped in triple-dash delimiters, with a render flag (render enabled) that determines whether the note appears on the timeline. The note also declares a timeline name (timelines), and can optionally define multiple timeline names—useful for splitting content into a “master” timeline and smaller year-based timelines. The plugin uses the note’s front matter to decide where it lands on the timeline, and it sorts by the configured date fields rather than the filename.

When rendered, each timeline entry shows an image (the first image in the note), an event title, a short two-line summary drawn from the note content, and a clickable entry that jumps to the underlying note. Overlapping or closely spaced dates cause the timeline’s side markers to break into multiple lines, creating a more readable visualization when events cluster.

A notable advanced feature is configurable date parsing via regex. By default, the plugin assumes a day-month-year format, but the parser can be changed to support “funky” date formats—so campaigns that store dates differently can still generate correct placements. The transcript also flags that this regex-based configuration may change as the plugin’s maintainers simplify it, so checking the readme is recommended.

For users already relying on Fantasy Calendar, the workflow becomes even smoother: Fantasy Calendar can read the same front matter fields from notes, meaning events can be stored once and displayed in both places. The transcript advises keeping events as notes rather than relying on Fantasy Calendar’s UI-created entries, citing reports of issues with the underlying data.json.

Finally, the plugin’s limitations are straightforward: there’s no horizontal timeline option at present, and it won’t work with Obsidian Publish because plugins generally don’t run there. Still, the overall result is a fast, template-driven way to build RPG campaign indexes—potentially even chapter-by-chapter book navigation—using nothing more than structured note front matter and a rendered timeline view.

Cornell Notes

April’s Automatic Timelines generates a vertical timeline in Obsidian by reading event details from each event note’s front matter. Each note includes a render-enabled flag, a timeline name (timelines), and date fields (start/end) plus optional title, body, and picture keys. When Fantasy Calendar presets are enabled, the timeline can use FC date fields and stay consistent with Fantasy Calendar’s own front matter-driven event system. The plugin also supports a regex-based date parser for nonstandard date formats and shows a short two-line summary plus a first-image thumbnail per event. Storing events as notes reduces risk compared with relying on Fantasy Calendar’s data.json during its rebuild.

What front matter fields does April’s Automatic Timelines need to place an event on the timeline?

The configuration centers on two date keys: an event start key and an event end key (the transcript also mentions optional keys for event title, event body, and event picture). In the default configuration, the plugin uses specific keys like AET event date / AET event title / AET event body / AET event picture, but the user can override these in the plugin settings. Regardless of the exact key names, the timeline will only render notes where render enabled is set to true and where the note declares a timeline name via timelines.

How does the plugin decide whether a note appears, and how can one note belong to multiple timelines?

Each event note includes a boolean-style flag render enabled. If it’s false, the note won’t show up in the timeline; the transcript calls this out as a common “silly mistake” when nothing appears. The note also includes timelines (timeline name(s)). The transcript notes that timelines can contain multiple names separated by commas—enabling a single event to appear in a master timeline and also in a year-specific timeline.

What does a rendered timeline entry show, and where does the summary text come from?

A rendered entry pulls an image from the note (specifically the first image) and displays an event title plus a short summary. The summary is not the full note content; it’s limited to the first two lines of the note content. Entries are clickable and can jump to the underlying note, and hovering can reveal details if that’s set up in Obsidian.

How does Fantasy Calendar integration change the workflow?

With Fantasy Calendar presets enabled in April’s Automatic Timelines settings, the timeline reads FC-style front matter fields such as FC date, FC end, FC display name, FC calendar, and FC category. The transcript emphasizes that Fantasy Calendar already reads events from note front matter, so using the same FC fields means events can appear in both systems without duplicating data. It also recommends storing events as notes rather than creating them via Fantasy Calendar’s UI, due to reported issues with data.json.

Why is date parsing configuration important, and what’s the role of regex?

The plugin includes a day parser option that uses regex to interpret “funky” date formats. While many users store dates as year-month-day or day-month-year, regex lets the plugin extract year, month, and day from other text patterns and prioritize which parts to treat as which. The transcript notes that this may evolve—there’s an issue raised to make the configuration easier for non-regex users—so the readme may be updated by the time someone watches.

What are the practical limitations mentioned for publishing and layout?

The transcript says the plugin won’t work with Obsidian Publish because plugins generally don’t run there. It also notes there’s no horizontal timeline version currently, unlike older timeline plugins that had a horizontal option (which was challenging to get working).

Review Questions

  1. If a timeline entry doesn’t appear, which two front matter conditions should be checked first (based on the transcript)?
  2. How can one event note be made to appear in both a master timeline and a year-specific timeline?
  3. What risks does the transcript associate with storing events in Fantasy Calendar’s data.json instead of as notes, and how does April’s plugin help mitigate that?

Key Points

  1. 1

    April’s Automatic Timelines builds a vertical RPG timeline in Obsidian by pulling event data from each event note’s front matter.

  2. 2

    The plugin renders only notes marked render enabled: true and tied to the correct timeline name(s) in timelines.

  3. 3

    Fantasy Calendar presets let the timeline use FC date fields (FC date/FC end plus FC display name, FC calendar, and FC category) so both tools stay aligned.

  4. 4

    Each timeline card can show an image (first image in the note) and a short two-line summary rather than the entire note body.

  5. 5

    Date placement relies on configured start/end keys, and regex-based day parsing can support nonstandard date formats.

  6. 6

    Storing events as notes reduces dependence on Fantasy Calendar’s data.json during its rebuild, which has caused missing data for some users.

  7. 7

    The plugin currently won’t work on Obsidian Publish and has no horizontal timeline option yet.

Highlights

The timeline entries pull a first-image thumbnail and only the first two lines of note content, keeping the visualization crisp.
Using note-based events avoids the “data.json disappearing” problem tied to Fantasy Calendar’s rebuild.
One event note can belong to multiple timelines by listing multiple timeline names in the timelines field.
Overlapping dates cause the timeline’s side markers to split into multiple lines for better readability.
Regex-based date parsing can be customized to handle unusual date formats, though the config may change over time.

Topics

  • Obsidian Timelines
  • Fantasy Calendar Integration
  • Front Matter Templates
  • Date Parsing
  • RPG Campaign Indexing

Mentioned