diff --git a/lua/neorg/modules/core/journal/module.lua b/lua/neorg/modules/core/journal/module.lua
index 4f151fe85..4fb206c59 100644
--- a/lua/neorg/modules/core/journal/module.lua
+++ b/lua/neorg/modules/core/journal/module.lua
@@ -4,87 +4,132 @@
     description: The journal module allows you to take personal notes with zero friction.
     summary: Easily track a journal within Neorg.
     ---
-The journal module exposes a total of six commands.
-The first three, `:Neorg journal today|yesterday|tomorrow`, allow you to access entries
-for a given time relative to today. A file will be opened with the respective date as a `.norg` file.
-
-The fourth command, `:Neorg journal custom`, allows you to specify a custom date as an argument.
-The date must be formatted according to the `YYYY-mm-dd` format, e.g. `2023-01-01`.
-
-The `:Neorg journal template` command creates a template file which will be used as the base whenever
-a new journal entry is created.
-
-Last but not least, the `:Neorg journal toc open|update` commands open or create/update a Table of Contents
-file found in the root of the journal. This file contains links to all other journal entries, alongside
-their titles.
+Journals are "periodic" in Neorg. You could have a daily journal, a weekly journal, a quarterly
+journal, etc, (or all of them at once). Neorg ships with `daily`, `weekly`, and `monthly` journals
+already defined, and `daily` is the default.
+
+### Commands:
+
+The main commands are: `:Neorg journal previous|current|next <name?>`, where `<name>` is the name of
+a periodic journal--either one of the pre-defined journal names mentioned above, or a custom name
+added in configuration. Eliding `name` will use the default journal (usually `daily` but this is
+configurable)
+
+Additionally, you can specify a custom date with `:Neorg journal custom <name?> <date?>`. The date
+can be either:
+- a date in `YYYY-mm-dd` format, e.g. `2023-01-01`
+- a date in the Norg date format: `<day>?,? <day-of-month> <month> -?<year> <time> <timezone>`, eg:
+    - `Sat, 29 Oct 1994 19:43.31 GMT`
+    - `We 12th Jan 2022`
+
+If an exact date isn't given, it will go to the previous valid date. For example: `:Neorg journal
+custom monthly 2024-01-12` will be the same as `:Neorg journal custom monthly 2024-01-01`; both will
+take you to Jan 2024's monthly note. If you leave `date` out Neorg will prompt you to select a date
+via the calendar.
+
+Some aliases exist for convenience (and backwards compatibility):
+- `:Neorg journal yesterday|today|tomorrow`, are aliases for `:Neorg journal previous|current|next
+daily`. (as such, you cannot name a periodic journal "today", "yesterday", or "tomorrow").
+
+`:Neorg journal next_workday|prev_workday` commands skip weekends and holidays (supplied by user),
+useful in a work environment
+
+The `:Neorg journal template <name>` command creates or opens a template file which will be copied
+whenever a new journal entry is created.
+
+Last but not least, the `:Neorg journal toc open|update <name>` commands open or create/update
+a Table of Contents file found in the root of your journal folder. Each journal has its own ToC that
+only references files that are a part of the same journal. For example, `:Neorg journal toc update
+weekly` will create a file that references all of the weekly journals.
 --]]
 
 local neorg = require("neorg.core")
+local Path = require("pathlib")
 local config, lib, log, modules = neorg.config, neorg.lib, neorg.log, neorg.modules
 
+local tempus ---@type core.tempus
+local dirman ---@type core.dirman
+local treesitter ---@type core.integrations.treesitter
+
 local module = modules.create("core.journal")
 
-module.examples = {
-    ["Changing TOC format to divide year in quarters"] = function()
-        -- In your ["core.journal"] options, change toc_format to a function like this:
+module.config.public = {
+    -- Which workspace to use for the journal files, the default behaviour
+    -- is to use the current workspace.
+    --
+    -- It is recommended to set this to a static workspace, but the most optimal
+    -- behaviour may vary from workflow to workflow.
+    workspace = nil,
 
-        require("neorg").setup({
-            load = {
-                -- ...
-                ["core.journal"] = {
-                    config = {
-                        -- ...
-                        toc_format = function(entries)
-                            -- Convert the entries into a certain format
+    -- The name for the folder in which the journal files are put.
+    journal_folder = "journal",
 
-                            local output = {}
-                            local current_year
-                            local current_quarter
-                            local last_quarter
-                            local current_month
-                            for _, entry in ipairs(entries) do
-                                -- Don't print the year if it hasn't changed
-                                if not current_year or current_year < entry[1] then
-                                    current_year = entry[1]
-                                    current_month = nil
-                                    table.insert(output, "* " .. current_year)
-                                end
+    -- when a journal command is used without a name, this is the journal that it will default to
+    default_journal_name = "daily",
 
-                                -- Check to which quarter the current month corresponds to
-                                if entry[2] <= 3 then
-                                    current_quarter = 1
-                                elseif entry[2] <= 6 then
-                                    current_quarter = 2
-                                elseif entry[2] <= 9 then
-                                    current_quarter = 3
-                                else
-                                    current_quarter = 4
-                                end
+    -- The strategy to use to create directories.
+    -- May be "flat" (`2022-03-02.norg`), "nested" (`2022/03/02.norg`),
+    -- a lua string with the format given to `os.date()` or a lua function with the signature:
+    -- `fun(date: os.date): string` where the return value is a format string passed to os.date
+    strategy = "nested",
 
-                                -- If the current month corresponds to another quarter, print it
-                                if current_quarter ~= last_quarter then
-                                    table.insert(output, "** Quarter " .. current_quarter)
-                                    last_quarter = current_quarter
-                                end
+    -- The name of the template file to use (sans the `.norg`) when running `:Neorg journal
+    -- template`. The actual file path will be: `base_template_name .. "-" .. journal_name .. ".norg"`
+    -- for the default  journal template this looks like: `"template-daily.norg"`
+    base_template_name = "template",
 
-                                -- Don't print the month if it hasn't changed
-                                if not current_month or current_month < entry[2] then
-                                    current_month = entry[2]
-                                    table.insert(output, "*** Month " .. current_month)
-                                end
+    -- Whether to apply the template file to new journal entries.
+    use_template = true,
 
-                                -- Prints the file link
-                                table.insert(output, "   " .. entry[4] .. string.format("[%s]", entry[5]))
-                            end
+    -- Formatter function used to generate the toc file.
+    -- Receives a table that contains tables like { yy, mm, dd, link, title }.
+    --
+    -- The function must return a table of strings.
+    toc_format = nil,
 
-                            return output
-                        end,
-                        -- ...
-                    },
-                },
-            },
-        })
-    end,
+    -- this is where you can define additional periodic journals
+    --
+    -- an example entry looks like:
+    -- ```lua
+    -- sprint = {
+    --   start_date = os.time({ year = 2024, month = 06, day = 17 }), -- a Monday
+    --   period = { day = 14 },
+    --   path_format_strategy = "%Y/%m/%d-sprint.norg",
+    --   parse_journal_path = nil, -- nil | fun(path: string): [number?, number?, number?]? (year, month, day)
+    -- }
+    -- ```
+    -- - `sprint` is the name of the journal, it's how you refer to the journal in commands.
+    -- - `start_date` can be any time, including days in the future
+    -- - `period` can contain `days` or (`months` and `years`). You can't mix `days` with
+    --   `months`/`years` due to inconsistencies with the length of the later group
+    -- - `path_format_strategy` accepts the same values as `strategy`, _and_ it is optional. By
+    --   default the normal journal strategy is used with `-<journal_name>` appended to the end
+    --   - If a function is passed, you also must pass a function for `parse_journal_path` which
+    --     takes a file path and returns either nil, or a table with three numbers that represent the
+    --     year, month, and day for the file to be categorized under. Any of year/month/day may be
+    --     omitted at the expense of grouping in the ToC
+    --
+    -- You can override default journal behaviours with this table. For example, if you want your
+    -- daily journal to run a little into the next day so you can use `:Neorg journal today` at 1am
+    -- and get the previous day's journal, you can do something like this:
+    -- ```lua
+    -- daily = {
+    --   start_date = os.time({ year = 2024, month = 6, day = 1, hour = 1 })
+    --   -- other fields will keep their default values
+    -- }
+    -- ```
+    journals = {},
+
+    -- List of dates that {prev,next}_workday will skip
+    -- `os.time({ month = months["January"], day = 1, year = 2026 })`
+    holidays = {},
+}
+
+module.config.private = {
+    strategies = {
+        flat = "%Y-%m-%d.norg",
+        nested = "%Y" .. config.pathsep .. "%m" .. config.pathsep .. "%d.norg",
+    },
 }
 
 module.setup = function()
@@ -93,36 +138,204 @@ module.setup = function()
         requires = {
             "core.dirman",
             "core.integrations.treesitter",
+            "core.tempus",
         },
     }
 end
 
----@type core.integrations.treesitter
-local ts
 module.load = function()
-    ts = module.required["core.integrations.treesitter"] --[[@as core.integrations.treesitter]]
+    tempus = module.required["core.tempus"] ---@type core.tempus
+    dirman = module.required["core.dirman"] ---@type core.dirman
+    treesitter = module.required["core.integrations.treesitter"] ---@type core.integrations.treesitter
+
+    ---@type PathlibPath
+    module.config.private.journal_folder = Path(module.config.public.journal_folder)
+
+    module.config.private.holidays = vim.iter(module.config.public.holidays):map(function(t)
+        return os.date("*t", t)
+    end)
 
     if module.config.private.strategies[module.config.public.strategy] then
         module.config.public.strategy = module.config.private.strategies[module.config.public.strategy]
     end
 
+    ---alter a format strategy to include the name of the journal at the end (to avoid name
+    ---collisions with the default journal)
+    local function alter_strategy(strat, name)
+        -- use the default strategy for the default journal
+        if name == module.config.public.default_journal_name then
+            return strat
+        end
+
+        if type(strat) == "string" then
+            return strat:gsub("%.norg$", "-" .. name .. ".norg")
+        end
+
+        if type(strat) == "function" then
+            return function(t)
+                local str = strat(t)
+                return str:gsub("%.norg$", "-" .. name .. ".norg")
+            end
+        end
+
+        return strat
+    end
+
+    ---@class JournalMonthTimePeriod
+    ---@field year number?
+    ---@field month number?
+
+    ---@class JournalDayTimePeriod
+    ---@field day number?
+
+    ---@alias JournalTimePeriod JournalDayTimePeriod | JournalMonthTimePeriod
+
+    ---@class _AJournalSpec
+    ---@field start_date integer time
+    ---@field period JournalTimePeriod
+
+    ---@class StringJournalSpec : _AJournalSpec
+    ---@field path_format_strategy string
+
+    ---@class FuncJournalSpec : _AJournalSpec
+    ---@field path_format_strategy fun(date: osdate): string
+    ---@field parse_journal_path fun(path: string): boolean
+
+    ---@alias JournalSpec FuncJournalSpec | StringJournalSpec
+
+    ---@type table<string, JournalSpec>
+    module.config.private.journals = {
+        daily = {
+            start_date = os.time({ year = 2024, month = 06, day = 01, hour = 0 }),
+            period = { day = 1 },
+            path_format_strategy = alter_strategy(module.config.public.strategy, "daily"),
+        },
+        weekly = {
+            -- NOTE: this makes the week start on a Monday
+            start_date = os.time({ year = 2024, month = 06, day = 03, hour = 0 }),
+            period = { day = 7 },
+            path_format_strategy = alter_strategy(module.config.public.strategy, "weekly"),
+        },
+        monthly = {
+            start_date = os.time({ year = 2024, month = 01, day = 01, hour = 0 }),
+            period = { month = 1 },
+            path_format_strategy = alter_strategy(module.config.public.strategy, "monthly"),
+        },
+    }
+
+    -- validate user defined journals
+    for name, journal in pairs(module.config.public.journals) do
+        if journal.period then
+            if journal.period.day and (journal.period.month or journal.period.year) then
+                log.warn(
+                    "Journals cannot have a period that mixes days with months or years. Days will be ignored for journal: "
+                    .. name
+                )
+            end
+        end
+        if module.config.private.journals[name] then
+            goto continue
+        end
+
+        if not journal.path_format_strategy then
+            journal.path_format_strategy = alter_strategy(module.config.public.strategy, name)
+        end
+
+        -- require a parse function if the format strategy is a function
+        if type(journal.path_format_strategy) == "function" then
+            if not journal.parse_journal_path then
+                log.error(
+                    ("Journal `%s` has a `path_format_strategy` of type `function` but no `parse_journal_path` function was provided.")
+                    :format(
+                        name
+                    )
+                )
+                module.config.public.journals[name] = nil
+                goto continue
+            end
+        end
+
+        ::continue::
+    end
+
+    ---@type FuncJournalSpec
+    module.config.public.journals =
+        vim.tbl_deep_extend("keep", module.config.public.journals, module.config.private.journals)
+
+    for _, journal in pairs(module.config.public.journals) do
+        -- if the format strategy is a string, we auto generate the filter function like this:
+        if not journal.parse_journal_path then
+            local path_pat =
+                tempus.date_format_to_lua_pattern((journal --[[@as StringJournalSpec]]).path_format_strategy)
+            journal.parse_journal_path = function(full_path)
+                -- print("path_pat:", path_pat)
+                local match = { full_path:match(path_pat) }
+                if not vim.tbl_isempty(match) then
+                    return match
+                end
+            end
+        end
+    end
+
     modules.await("core.neorgcmd", function(neorgcmd)
+        local journal_names = vim.tbl_keys(module.config.public.journals)
         neorgcmd.add_commands_from_table({
             journal = {
                 min_args = 1,
-                max_args = 2,
                 subcommands = {
                     tomorrow = { args = 0, name = "journal.tomorrow" },
                     yesterday = { args = 0, name = "journal.yesterday" },
                     today = { args = 0, name = "journal.today" },
-                    custom = { max_args = 1, name = "journal.custom" }, -- format :yyyy-mm-dd
-                    template = { args = 0, name = "journal.template" },
+                    previous = {
+                        min_args = 0,
+                        max_args = 1,
+                        name = "journal.previous",
+                        complete = { journal_names },
+                    },
+                    prev_workday = {
+                        args = 0,
+                        name = "journal.prev_workday",
+                    },
+                    current = {
+                        min_args = 0,
+                        max_args = 1,
+                        name = "journal.current",
+                        complete = { journal_names },
+                    },
+                    next = {
+                        min_args = 0,
+                        max_args = 1,
+                        name = "journal.next",
+                        complete = { journal_names },
+                    },
+                    next_workday = {
+                        args = 0,
+                        name = "journal.next_workday",
+                    },
+                    custom = {
+                        min_args = 1,
+                        name = "journal.custom",
+                        complete = { journal_names },
+                    },
+                    template = {
+                        max_args = 1,
+                        name = "journal.template",
+                        complete = { journal_names },
+                    },
                     toc = {
                         args = 1,
                         name = "journal.toc",
                         subcommands = {
-                            open = { args = 0, name = "journal.toc.open" },
-                            update = { args = 0, name = "journal.toc.update" },
+                            open = {
+                                max_args = 1,
+                                name = "journal.toc.open",
+                                complete = { journal_names },
+                            },
+                            update = {
+                                max_args = 1,
+                                name = "journal.toc.update",
+                                complete = { journal_names },
+                            },
                         },
                     },
                 },
@@ -131,374 +344,381 @@ module.load = function()
     end)
 end
 
-module.config.public = {
-    -- Which workspace to use for the journal files, the default behaviour
-    -- is to use the current workspace.
-    --
-    -- It is recommended to set this to a static workspace, but the most optimal
-    -- behaviour may vary from workflow to workflow.
-    workspace = nil,
+---@class core.journal
+module.public = {
+    ---Opens a diary entry at the given time
+    ---@param journal_name string journal name
+    ---@param date? number The time to open the journal entry at as returned by `os.time()`
+    open_journal = function(journal_name, date)
+        local workspace = module.config.public.workspace or dirman.get_current_workspace()[1]
+        local folder_name = module.config.private.journal_folder
+        local template_name = module.private.get_template_name(journal_name)
+
+        local journal = module.config.public.journals[journal_name]
+        if not journal then
+            local valid_names = vim.iter(vim.tbl_keys(module.config.public.journals)):join(", ")
+            log.error(
+                ("Cannot find journal with name: `%s`\nHere is a list of recognized journal names: %s"):format(
+                    journal_name,
+                    valid_names
+                )
+            )
+            return
+        end
 
-    -- The name for the folder in which the journal files are put.
-    journal_folder = "journal",
+        local path = os.date(
+        ---@diagnostic disable-next-line: param-type-mismatch
+            (type(journal.path_format_strategy) == "function" and journal.path_format_strategy(os.date("*t", date)))
+            or journal.path_format_strategy,
+            ---@diagnostic disable-next-line: param-type-mismatch
+            date
+        )
 
-    -- The strategy to use to create directories.
-    -- May be "flat" (`2022-03-02.norg`), "nested" (`2022/03/02.norg`),
-    -- a lua string with the format given to `os.date()` or a lua function
-    -- that returns a lua string with the same format.
-    strategy = "nested",
+        local workspace_path = dirman.get_workspace(workspace)
 
-    -- The name of the template file to use when running `:Neorg journal template`.
-    template_name = "template.norg",
+        local journal_file_exists = dirman.file_exists(workspace_path / folder_name / path)
 
-    -- Whether to apply the template file to new journal entries.
-    use_template = true,
+        dirman.create_file(folder_name / path, workspace)
 
-    -- Formatter function used to generate the toc file.
-    -- Receives a table that contains tables like { yy, mm, dd, link, title }.
-    --
-    -- The function must return a table of strings.
-    toc_format = nil,
+        if
+            not journal_file_exists
+            and module.config.public.use_template
+            and dirman.file_exists(workspace_path / folder_name / template_name)
+        then
+            vim.cmd("$read " .. (workspace_path / folder_name / template_name) .. "| w")
+        end
+    end,
 }
 
-module.config.private = {
-    strategies = {
-        flat = "%Y-%m-%d.norg",
-        nested = "%Y" .. config.pathsep .. "%m" .. config.pathsep .. "%d.norg",
-    },
-}
+module.private = {
+    journal_previous = function(args)
+        local journal_name = args[1]
+        local journal = module.config.public.journals[journal_name]
+        local current = module.private.get_period_date(journal_name)
+        module.public.open_journal(journal_name, tempus.sub_time(current, journal.period))
+    end,
 
----@class core.journal
-module.public = {
-    version = "0.0.9",
-
-    --- Opens a diary entry at the given time
-    ---@param time? number #The time to open the journal entry at as returned by `os.time()`
-    ---@param custom_date? string #A YYYY-mm-dd string that specifies a date to open the diary at instead
-    open_diary = function(time, custom_date)
-        -- TODO(vhyrro): Change this to use Norg dates!
-        local workspace = module.config.public.workspace or module.required["core.dirman"].get_current_workspace()[1]
-        local folder_name = module.config.public.journal_folder
-        local template_name = module.config.public.template_name
-
-        if custom_date then
-            local year, month, day = custom_date:match("^(%d%d%d%d)-(%d%d)-(%d%d)$")
-
-            if not year or not month or not day then
-                log.error("Wrong date format: use YYYY-mm-dd")
-                return
+    journal_next = function(args)
+        local journal_name = args[1]
+        local journal = module.config.public.journals[journal_name]
+        local current = module.private.get_period_date(journal_name)
+        module.public.open_journal(journal_name, tempus.add_time(current, journal.period))
+    end,
+
+    ---@param day osdate
+    ---@param direction number
+    ---@return number # return of os.time
+    workdays = function(day, direction)
+        day.day = day.day + 1 * direction
+        local x = 0
+        while
+            day.wday <= 2
+            or module.config.private.holidays:any(function(holiday)
+                return holiday.day == day.day and holiday.month == day.month and day.year == holiday.year
+            end)
+        do
+            day.day = day.day + 1 * direction
+            day.wday = lib.number_wrap(day.wday + 1 * direction, 1, 7)
+            x = x + 1
+            if x > 10 then
+                log.error("10 iterations of yesterweekday and we didn't find a valid day")
+                break
             end
+        end
+        return os.time(day)
+    end,
 
-            time = os.time({
-                year = year,
-                month = month,
-                day = day,
-            })
+    -- skip weekends and holidays
+    journal_previous_workday = function()
+        print("uhhh")
+        local day = os.date("*t", os.time()) --[[@as osdate]]
+        P({day = day})
+        print("module.private.workdays(day, -1):", module.private.workdays(day, -1))
+        module.public.open_journal("daily", module.private.workdays(day, -1))
+    end,
+
+    -- skip weekends and holidays
+    journal_next_workday = function()
+        print("next?")
+        local day = os.date("*t", os.time()) --[[@as osdate]]
+        module.public.open_journal("daily", module.private.workdays(day, 1))
+    end,
+
+    ---Get the date at the start of the period which contains the given time for the given journal.
+    ---When time is nil, use the current time
+    ---@param journal_name string
+    ---@param time number?
+    ---@return number os.time or 0 when given an invalid journal
+    get_period_date = function(journal_name, time)
+        local journal = module.config.public.journals[journal_name]
+        if not journal then
+            return 0
         end
 
-        local path = os.date(
-            type(module.config.public.strategy) == "function" and module.config.public.strategy(os.date("*t", time))
-                or module.config.public.strategy,
-            time
-        )
+        local start_date = os.date("*t", journal.start_date)
+        local start_as_Date = tempus.to_date(os.date("*t", journal.start_date) --[[@as osdate]])
 
-        local workspace_path = module.required["core.dirman"].get_workspace(workspace)
+        time = time or os.time()
+        local date = os.date("*t", time)
 
-        local journal_file_exists =
-            module.required["core.dirman"].file_exists(workspace_path .. "/" .. folder_name .. config.pathsep .. path)
+        if journal.period.month or journal.period.year then -- months/years take priority, and days will be ignored if present
+            -- calculate based on months
+            local period_months = (journal.period.month or 0) + (journal.period.year or 0) * 12
+            local start_months = (start_date.month or 0) + (start_date.year or 0) * 12
+            local current_months = (date.month or 0) + (date.year or 0) * 12
+            local month_diff = current_months - start_months
+            local time_periods_since_start = math.floor(month_diff / period_months)
 
-        module.required["core.dirman"].create_file(folder_name .. config.pathsep .. path, workspace)
+            -- TODO: is this off by one or okay?
+            return tempus.add_time(start_as_Date, {
+                month = time_periods_since_start * period_months,
+            })
+        else
+            -- calculate based on days, this calculation would work for everything if months were
+            -- a consistent length :|
+            local diff = os.difftime(os.time(date --[[@as osdateparam]]), journal.start_date)
+            local start_plus_period = tempus.add_time(start_as_Date, journal.period)
+            local period_as_int = os.difftime(start_plus_period, journal.start_date)
 
-        module.required["core.dirman"].create_file(folder_name .. config.pathsep .. path, workspace)
+            local time_periods_since_start = math.floor(diff / period_as_int)
 
-        if
-            not journal_file_exists
-            and module.config.public.use_template
-            and module.required["core.dirman"].file_exists(workspace_path .. "/" .. folder_name .. "/" .. template_name)
-        then
-            vim.cmd("$read " .. workspace_path .. "/" .. folder_name .. "/" .. template_name .. "| 1d | w")
+            return tempus.add_time(start_as_Date, {
+                day = time_periods_since_start * (journal.period.day or 0),
+            })
+        end
+    end,
+
+    ---@param args string[]
+    journal_current = function(args)
+        local journal_name = args[1]
+        if journal_name == nil then
+            journal_name = module.config.public.default_journal_name
         end
+        local current = module.private.get_period_date(journal_name)
+        module.public.open_journal(journal_name, current)
     end,
 
-    --- Opens a diary entry for tomorrow's date
-    diary_tomorrow = function()
-        module.public.open_diary(os.time() + 24 * 60 * 60)
+    --- Opens a journal entry for tomorrow's date
+    journal_tomorrow = function()
+        module.private.journal_next({ "daily" })
     end,
 
-    --- Opens a diary entry for yesterday's date
-    diary_yesterday = function()
-        module.public.open_diary(os.time() - 24 * 60 * 60)
+    --- Opens a journal entry for yesterday's date
+    journal_yesterday = function()
+        module.private.journal_previous({ "daily" })
     end,
 
-    --- Opens a diary entry for today's date
-    diary_today = function()
-        module.public.open_diary()
+    --- Opens a journal entry for today's date
+    journal_today = function()
+        module.private.journal_current({ "daily" })
     end,
 
-    create_template = function()
+    get_template_name = function(journal_name)
+        return module.config.public.base_template_name
+            .. "-"
+            .. (journal_name or module.config.public.default_journal_name)
+            .. ".norg"
+    end,
+
+    --- Creates a template file
+    create_template = function(args)
         local workspace = module.config.public.workspace
-        local folder_name = module.config.public.journal_folder
-        local template_name = module.config.public.template_name
+        local folder_name = module.config.private.journal_folder
+        local template_name = module.private.get_template_name(args[1])
 
-        module.required["core.dirman"].create_file(
-            folder_name .. config.pathsep .. template_name,
-            workspace or module.required["core.dirman"].get_current_workspace()[1]
-        )
+        dirman.create_file(folder_name / template_name, workspace or dirman.get_current_workspace()[1])
     end,
 
+    -- TODO: file paths for this are going to be weird I think...
+    -- might just want another config option for TOC file paths/locations on each periodic journal
+
     --- Opens the toc file
-    open_toc = function()
-        local workspace = module.config.public.workspace or module.required["core.dirman"].get_current_workspace()[1]
+    ---@param args string[]
+    open_toc = function(args)
+        local journal_name = args[1] or module.config.public.default_journal_name
+        local workspace = module.config.public.workspace or dirman.get_current_workspace()[1]
         local index = modules.get_module_config("core.dirman").index
-        local folder_name = module.config.public.journal_folder
+        local folder_name = module.config.private.journal_folder
 
         -- If the toc exists, open it, if not, create it
-        if module.required["core.dirman"].file_exists(folder_name .. config.pathsep .. index) then
-            module.required["core.dirman"].open_file(workspace, folder_name .. config.pathsep .. index)
+        if dirman.file_exists(folder_name / index) then
+            dirman.open_file(workspace, folder_name / index)
         else
-            module.public.create_toc()
+            module.private.create_toc({ journal_name })
         end
     end,
 
-    --- Creates or updates the toc file
-    create_toc = function()
-        local workspace = module.config.public.workspace or module.required["core.dirman"].get_current_workspace()[1]
+    --- Creates or updates the toc file for a given journal
+    ---@param args string[]
+    create_toc = function(args)
+        local journal_name = args[1] or module.config.public.default_journal_name
+        local journal = module.config.public.journals[journal_name]
+
+        local workspace = module.config.public.workspace or dirman.get_current_workspace()[1]
         local index = modules.get_module_config("core.dirman").index
-        local workspace_path = module.required["core.dirman"].get_workspace(workspace)
+        local workspace_path = dirman.get_workspace(workspace)
         local workspace_name_for_links = module.config.public.workspace or ""
-        local folder_name = module.config.public.journal_folder
+        local folder_name = module.config.private.journal_folder
+
+        local journal_base_path = workspace_path / folder_name
 
         -- Each entry is a table that contains tables like { yy, mm, dd, link, title }
         local toc_entries = {}
 
-        -- Get a filesystem handle for the files in the journal folder
-        -- path is for each subfolder
-        local get_fs_handle = function(path)
-            path = path or ""
-            local handle =
-                vim.loop.fs_scandir(workspace_path .. config.pathsep .. folder_name .. config.pathsep .. path)
-
-            if type(handle) ~= "userdata" then
-                error(lib.lazy_string_concat("Failed to scan directory '", workspace, path, "': ", handle))
-            end
-
-            return handle
-        end
-
-        ---Gets the title from the metadata of a file, must be called in a vim.schedule
-        ---@param file PathlibPath | string
-        ---@return string?
-        local get_title = function(file)
-            local path = workspace_path / folder_name / file
-            local meta
-            if vim.fn.bufexists(tostring(path)) == 1 then
-                local buf = vim.fn.bufloaded(vim.fn.bufnr(tostring(path)))
-                meta = ts.get_document_metadata(buf)
-            else
-                meta = ts.get_document_metadata(path)
-            end
+        -- Gets the title from the metadata of a file, must be called in a vim.schedule
+        ---@param file_path PathlibPath
+        ---@return string? #the title or nil if no title is present
+        local get_title = function(file_path)
+            local meta = treesitter.get_document_metadata(file_path, false)
             if meta then
                 return meta.title
             end
         end
 
-        vim.loop.fs_scandir(workspace_path .. config.pathsep .. folder_name .. config.pathsep, function(err, handle)
-            assert(not err, lib.lazy_string_concat("Unable to generate TOC for directory '", folder_name, "' - ", err))
+        assert(type(journal.path_format_strategy) == "string")
 
-            while true do
-                -- Name corresponds to either a YYYY-mm-dd.norg file, or just the year ("nested" strategy)
-                local name, type = vim.loop.fs_scandir_next(handle) ---@diagnostic disable-line -- TODO: type error workaround <pysan3>
+        for file in
+        journal_base_path:fs_iterdir(false, nil, function(path)
+            return path:is_hidden()
+        end)
+        do
+            local file_date_info = journal.parse_journal_path(tostring(file))
+            if not file_date_info then
+                goto continue
+            end
 
-                if not name then
-                    break
-                end
+            -- Get the title from the metadata, else, default to the name of the file
+            local title = get_title(file) or ({ file:basename():match("(.*)%.norg$") })[1]
+            local ws_rel_path = file:relative_to(workspace_path)
+
+            -- Insert a new entry
+            table.insert(toc_entries, {
+                tonumber(file_date_info[1]), -- year
+                tonumber(file_date_info[2]), -- month
+                tonumber(file_date_info[3]), -- day
+                ("{:%s:}"):format(Path.new("$" .. workspace_name_for_links) / ws_rel_path),
+                title,
+            })
 
-                -- Handle nested entries
-                if type == "directory" then
-                    local years_handle = get_fs_handle(name)
-                    while true do
-                        -- mname is the month
-                        local mname, mtype = vim.loop.fs_scandir_next(years_handle)
+            ::continue::
+        end
 
-                        if not mname then
-                            break
+        vim.schedule(function()
+            -- Gets a default format for the entries
+            local format = module.config.public.toc_format
+                or function(entries)
+                    local months_text = {
+                        "January",
+                        "February",
+                        "March",
+                        "April",
+                        "May",
+                        "June",
+                        "July",
+                        "August",
+                        "September",
+                        "October",
+                        "November",
+                        "December",
+                    }
+                    -- Convert the entries into a certain format to be written
+                    local output = {}
+                    local current_year
+                    local current_month
+                    for _, entry in ipairs(entries) do
+                        -- Don't print the year and month if they haven't changed
+                        if not current_year or current_year < entry[1] then
+                            current_year = entry[1]
+                            current_month = nil
+                            table.insert(output, "* " .. current_year)
                         end
-
-                        if mtype == "directory" then
-                            local months_handle = get_fs_handle(name .. config.pathsep .. mname)
-                            while true do
-                                -- dname is the day
-                                local dname, dtype = vim.loop.fs_scandir_next(months_handle)
-
-                                if not dname then
-                                    break
-                                end
-
-                                -- If it's a .norg file, also ensure it is a day entry
-                                if dtype == "file" and string.match(dname, "%d%d%.norg") then
-                                    -- Split the file name
-                                    local file = vim.split(dname, ".", { plain = true })
-
-                                    vim.schedule(function()
-                                        -- Get the title from the metadata, else, it just defaults to the name of the file
-                                        local title = get_title(
-                                            name .. config.pathsep .. mname .. config.pathsep .. dname
-                                        ) or file[1]
-
-                                        -- Insert a new entry
-                                        table.insert(toc_entries, {
-                                            tonumber(name),
-                                            tonumber(mname),
-                                            tonumber(file[1]),
-                                            "{:$"
-                                                .. workspace_name_for_links
-                                                .. config.pathsep
-                                                .. module.config.public.journal_folder
-                                                .. config.pathsep
-                                                .. name
-                                                .. config.pathsep
-                                                .. mname
-                                                .. config.pathsep
-                                                .. file[1]
-                                                .. ":}",
-                                            title,
-                                        })
-                                    end)
-                                end
-                            end
+                        if not current_month or current_month < entry[2] then
+                            current_month = entry[2]
+                            table.insert(output, "** " .. months_text[current_month])
                         end
-                    end
-                end
 
-                -- Handles flat entries
-                -- If it is a .norg file, but it's not any user generated file.
-                -- The match is here to avoid handling files made by the user, like a template file, or
-                -- the toc file
-                if type == "file" and string.match(name, "%d+-%d+-%d+%.norg") then
-                    -- Split yyyy-mm-dd to a table
-                    local file = vim.split(name, ".", { plain = true })
-                    local parts = vim.split(file[1], "-")
-
-                    -- Convert the parts into numbers
-                    for k, v in pairs(parts) do
-                        parts[k] = tonumber(v) ---@diagnostic disable-line -- TODO: type error workaround <pysan3>
+                        -- Prints the file link
+                        table.insert(output, "   " .. entry[4] .. string.format("[%s]", entry[5]))
                     end
 
-                    vim.schedule(function()
-                        -- Get the title from the metadata, else, it just defaults to the name of the file
-                        local title = get_title(name) or parts[3]
-
-                        -- And insert a new entry that corresponds to the file
-                        table.insert(toc_entries, {
-                            parts[1],
-                            parts[2],
-                            parts[3],
-                            "{:$"
-                                .. workspace_name_for_links
-                                .. config.pathsep
-                                .. module.config.public.journal_folder
-                                .. config.pathsep
-                                .. file[1]
-                                .. ":}",
-                            title,
-                        })
-                    end)
+                    return output
                 end
-            end
 
-            vim.schedule(function()
-                -- Gets a default format for the entries
-                local format = module.config.public.toc_format
-                    or function(entries)
-                        local months_text = {
-                            "January",
-                            "February",
-                            "March",
-                            "April",
-                            "May",
-                            "June",
-                            "July",
-                            "August",
-                            "September",
-                            "October",
-                            "November",
-                            "December",
-                        }
-                        -- Convert the entries into a certain format to be written
-                        local output = {}
-                        local current_year
-                        local current_month
-                        for _, entry in ipairs(entries) do
-                            -- Don't print the year and month if they haven't changed
-                            if not current_year or current_year < entry[1] then
-                                current_year = entry[1]
-                                current_month = nil
-                                table.insert(output, "* " .. current_year)
-                            end
-                            if not current_month or current_month < entry[2] then
-                                current_month = entry[2]
-                                table.insert(output, "** " .. months_text[current_month])
-                            end
+            dirman.create_file(
+                journal_base_path:relative_to(workspace_path) / index,
+                workspace or dirman.get_current_workspace()[1]
+            )
 
-                            -- Prints the file link
-                            table.insert(output, "   " .. entry[4] .. string.format("[%s]", entry[5]))
-                        end
-
-                        return output
-                    end
-
-                module.required["core.dirman"].create_file(
-                    folder_name .. config.pathsep .. index,
-                    workspace or module.required["core.dirman"].get_current_workspace()[1]
-                )
-
-                -- The current buffer now must be the toc file, so we set our toc entries there
-                vim.api.nvim_buf_set_lines(0, 0, -1, false, format(toc_entries))
-                vim.cmd("w")
-            end)
+            -- The current buffer now must be the toc file, so we set our toc entries there
+            vim.api.nvim_buf_set_lines(0, 0, -1, false, format(toc_entries))
+            vim.cmd("w")
         end)
     end,
 }
 
-module.on_event = function(event)
-    if event.split_type[1] == "core.neorgcmd" then
-        if event.split_type[2] == "journal.tomorrow" then
-            module.public.diary_tomorrow()
-        elseif event.split_type[2] == "journal.yesterday" then
-            module.public.diary_yesterday()
-        elseif event.split_type[2] == "journal.custom" then
-            if not event.content[1] then
-                local calendar = modules.get_module("core.ui.calendar")
-
-                if not calendar then
-                    log.error("[ERROR]: `core.ui.calendar` is not loaded! Said module is required for this operation.")
-                    return
-                end
+local function handle_custom(args)
+    local journal_name = args[1] or module.config.public.default_journal_name
+    if not args[2] then
+        local calendar = modules.get_module("core.ui.calendar")
 
-                calendar.select_date({
-                    callback = vim.schedule_wrap(function(osdate)
-                        module.public.open_diary(
-                            nil,
-                            string.format("%04d", osdate.year)
-                                .. "-"
-                                .. string.format("%02d", osdate.month)
-                                .. "-"
-                                .. string.format("%02d", osdate.day)
-                        )
-                    end),
-                })
-            else
-                module.public.open_diary(nil, event.content[1])
+        if not calendar then
+            log.error("[ERROR]: `core.ui.calendar` is not loaded but is required for this operation.")
+            return
+        end
+
+        calendar.select_date({
+            callback = vim.schedule_wrap(function(osdate)
+                module.public.open_journal(journal_name, module.private.get_period_date(journal_name, os.time(osdate)))
+            end),
+        })
+    else
+        local year, month, day = args[2]:match("^(%d%d%d%d)-(%d%d)-(%d%d)$")
+
+        if not year or not month or not day then
+            -- try to treat it like a Norg date
+            local date = tempus.parse_date(vim.iter(args):skip(1):join(" "))
+            if type(date) == "string" then
+                log.error("Error trying to parse date: ", date)
+                return
             end
-        elseif event.split_type[2] == "journal.today" then
-            module.public.diary_today()
-        elseif event.split_type[2] == "journal.template" then
-            module.public.create_template()
-        elseif event.split_type[2] == "journal.toc.open" then
-            module.public.open_toc()
-        elseif event.split_type[2] == "journal.toc.update" then
-            module.public.create_toc()
+
+            year = date.year
+            month = date.month.number
+            day = date.day
         end
+
+        if not year or not month or not day then
+            log.error("Must specify year month and day, in either YYYY-mm-dd or norg date format")
+            return
+        end
+        local time = os.time({
+            year = year,
+            month = month,
+            day = day,
+        })
+
+        module.public.open_journal(journal_name, module.private.get_period_date(journal_name, time))
+    end
+end
+
+local event_handlers = {
+    ["core.neorgcmd.events.journal.previous"] = module.private.journal_previous,
+    ["core.neorgcmd.events.journal.current"] = module.private.journal_current,
+    ["core.neorgcmd.events.journal.next"] = module.private.journal_next,
+    ["core.neorgcmd.events.journal.prev_workday"] = module.private.journal_previous_workday,
+    ["core.neorgcmd.events.journal.next_workday"] = module.private.journal_next_workday,
+    ["core.neorgcmd.events.journal.yesterday"] = module.private.journal_yesterday,
+    ["core.neorgcmd.events.journal.tomorrow"] = module.private.journal_tomorrow,
+    ["core.neorgcmd.events.journal.today"] = module.private.journal_today,
+    ["core.neorgcmd.events.journal.custom"] = handle_custom,
+    ["core.neorgcmd.events.journal.template"] = module.private.create_template,
+    ["core.neorgcmd.events.journal.toc.update"] = module.private.create_toc,
+    ["core.neorgcmd.events.journal.toc.open"] = module.private.open_toc,
+}
+
+module.on_event = function(event)
+    if event_handlers[event.type] then
+        return event_handlers[event.type](event.content)
     end
 end
 
@@ -507,6 +727,11 @@ module.events.subscribed = {
         ["journal.yesterday"] = true,
         ["journal.tomorrow"] = true,
         ["journal.today"] = true,
+        ["journal.previous"] = true,
+        ["journal.current"] = true,
+        ["journal.next"] = true,
+        ["journal.prev_workday"] = true,
+        ["journal.next_workday"] = true,
         ["journal.custom"] = true,
         ["journal.template"] = true,
         ["journal.toc.update"] = true,
@@ -514,4 +739,67 @@ module.events.subscribed = {
     },
 }
 
+module.examples = {
+    ["Changing TOC format to divide year in quarters"] = function()
+        -- In your ["core.journal"] options, change toc_format to a function like this:
+
+        require("neorg").setup({
+            load = {
+                -- ...
+                ["core.journal"] = {
+                    config = {
+                        -- ...
+                        toc_format = function(entries)
+                            -- Convert the entries into a certain format
+
+                            local output = {}
+                            local current_year
+                            local current_quarter
+                            local last_quarter
+                            local current_month
+                            for _, entry in ipairs(entries) do
+                                -- Don't print the year if it hasn't changed
+                                if not current_year or current_year < entry[1] then
+                                    current_year = entry[1]
+                                    current_month = nil
+                                    table.insert(output, "* " .. current_year)
+                                end
+
+                                -- Check to which quarter the current month corresponds to
+                                if entry[2] <= 3 then
+                                    current_quarter = 1
+                                elseif entry[2] <= 6 then
+                                    current_quarter = 2
+                                elseif entry[2] <= 9 then
+                                    current_quarter = 3
+                                else
+                                    current_quarter = 4
+                                end
+
+                                -- If the current month corresponds to another quarter, print it
+                                if current_quarter ~= last_quarter then
+                                    table.insert(output, "** Quarter " .. current_quarter)
+                                    last_quarter = current_quarter
+                                end
+
+                                -- Don't print the month if it hasn't changed
+                                if not current_month or current_month < entry[2] then
+                                    current_month = entry[2]
+                                    table.insert(output, "*** Month " .. current_month)
+                                end
+
+                                -- Prints the file link
+                                table.insert(output, "   " .. entry[4] .. string.format("[%s]", entry[5]))
+                            end
+
+                            return output
+                        end,
+                        -- ...
+                    },
+                },
+            },
+        })
+    end,
+}
+
 return module
diff --git a/lua/neorg/modules/core/tempus/module.lua b/lua/neorg/modules/core/tempus/module.lua
index df4567de6..1e39a813c 100644
--- a/lua/neorg/modules/core/tempus/module.lua
+++ b/lua/neorg/modules/core/tempus/module.lua
@@ -18,7 +18,7 @@ mapping them):
 --]]
 
 local neorg = require("neorg.core")
-local lib, modules, utils = neorg.lib, neorg.modules, neorg.utils
+local lib, modules, utils, log = neorg.lib, neorg.modules, neorg.utils, neorg.log
 
 local module = modules.create("core.tempus")
 
@@ -230,6 +230,7 @@ module.public = {
     ---@return osdate #A Lua date
     to_lua_date = function(parsed_date)
         local now = os.date("*t") --[[@as osdate]]
+        now.isdst = nil
         local parsed = os.time(vim.tbl_deep_extend("force", now, {
             day = parsed_date.day,
             month = parsed_date.month and parsed_date.month.number or nil,
@@ -445,6 +446,103 @@ module.public = {
             }, callback)
         end
     end,
+
+    ---add some time to a given date
+    ---@param date Date | number
+    ---@param elapsed_time { year: number?, month: number?, day: number? }
+    ---@return number
+    add_time = function(date, elapsed_time)
+        if type(date) == "number" then
+            date = module.public.to_date(os.date("*t", date) --[[@as osdate]])
+        end
+        local lua_date = module.public.to_lua_date(date)
+        lua_date.year = lua_date.year + (elapsed_time.year or 0)
+        lua_date.month = lua_date.month + (elapsed_time.month or 0)
+        lua_date.day = lua_date.day + (elapsed_time.day or 0)
+        return os.time(lua_date --[[@as osdateparam]])
+    end,
+
+    ---add some time to a given date
+    ---@param date Date | number
+    ---@param elapsed_time { year: number?, month: number?, day: number? }
+    ---@return number
+    sub_time = function(date, elapsed_time)
+        if type(date) == "number" then
+            date = module.public.to_date(os.date("*t", date) --[[@as osdate]])
+        end
+        local lua_date = module.public.to_lua_date(date)
+        lua_date.year = lua_date.year - (elapsed_time.year or 0)
+        lua_date.month = lua_date.month - (elapsed_time.month or 0)
+        lua_date.day = lua_date.day - (elapsed_time.day or 0)
+        return os.time(lua_date --[[@as osdateparam]])
+    end,
+
+    ---convert a date format string into a lua pattern that will match strings produced by the
+    ---date format string. Creates capture groups around %Y, %m, and %d
+    ---@param format_str string
+    ---@return string?
+    date_format_to_lua_pattern = function(format_str)
+        local illegal_date_format_params = {
+            "%%c", -- current date time formatted according to locale
+            "%%C", -- current century number.. like what the fuck?
+            "%%G", -- wtf is this?
+            "%%g", -- ^
+            "%%r", -- another locale dependant full time format
+            "%%x", -- ^
+            "%%X", -- ^
+            "%%z", -- timezone, why are you putting this in a filename?
+            "%%Z", -- timezone, why are you putting this in a filename?
+        }
+
+        for _, pat in ipairs(illegal_date_format_params) do
+            if format_str:match(pat) then
+                log.error("Disallowed date format str provided to `date_format_to_lua_pattern`: " .. pat)
+                return nil
+            end
+        end
+
+        -- meta substitutions
+        format_str = format_str
+            :gsub("%%F", "%%Y-%%m-%%d")
+            :gsub("%%D", "%%m/%%d/%%y")
+            :gsub("%%R", "%%H:%%M")
+            :gsub("%%T", "%%H:%%M:%%S")
+            :gsub("%%h", "%%b")
+            :gsub("%%k", "%%e")
+            :gsub("%%l", "%%e")
+
+        -- NOTE: Before this substitution, a `%d` on the right side means "the day of the month"
+        format_str = format_str
+            :gsub("%%d", "(%%d%%d)")
+            :gsub("%%e", "[%%d ]%%d")
+            :gsub("%%u", "%%d")
+            :gsub("%%w", "%%d")
+            :gsub("%%m", "(%%d%%d)")
+            :gsub("%%H", "%%d%%d")
+            :gsub("%%I", "%%d%%d")
+            :gsub("%%M", "%%d%%d")
+            :gsub("%%S", "%%d%%d")
+            :gsub("%%U", "%%d%%d")
+            :gsub("%%V", "%%d%%d")
+            :gsub("%%W", "%%d%%d")
+            :gsub("%%y", "%%d%%d")
+            :gsub("%%j", "%%d%%d%%d")
+            :gsub("%%Y", "(%%d%%d%%d%%d)")
+            :gsub("%%s", "%%d+")
+            :gsub("%%p", "[AP]M") -- it's actually backwards like this
+            :gsub("%%P", "[ap]m") -- I didn't mess it up
+            :gsub("%%a", "%%a+")
+            :gsub("%%A", "%%a+")
+            :gsub("%%b", "%%a+")
+            :gsub("%%B", "%%a+")
+
+        -- escape chars
+        format_str = format_str
+            :gsub("^%^", "%%^")
+            :gsub("%$$", "%%$")
+            :gsub("%.", "%%.")
+        return format_str .. "$"
+    end,
 }
 
 module.private = {
diff --git a/lua/neorg/modules/core/ui/calendar/module.lua b/lua/neorg/modules/core/ui/calendar/module.lua
index 323b76574..8dd856bc7 100644
--- a/lua/neorg/modules/core/ui/calendar/module.lua
+++ b/lua/neorg/modules/core/ui/calendar/module.lua
@@ -24,6 +24,14 @@ module.setup = function()
     }
 end
 
+---@class NeorgCalendarOptions
+---@field height? number
+---@field padding? number
+---@field mode? "standalone" | "select_date" | "select_range"
+---@field callback? fun(date: string)
+---@field view? "monthly"
+---@field date? osdate
+
 module.private = {
 
     modes = {},
@@ -36,7 +44,7 @@ module.private = {
             return cur_mode
         end
 
-        print("Error: mode not set or not available")
+        error("Error: mode not set or not available")
     end,
 
     get_view = function(name)
@@ -44,7 +52,7 @@ module.private = {
             return module.private.views[name]
         end
 
-        print("Error: view not set or not available")
+        error("Error: view not set or not available")
     end,
 
     extract_ui_info = function(buffer, window)
@@ -64,6 +72,7 @@ module.private = {
         }
     end,
 
+    ---@param options NeorgCalendarOptions
     open_window = function(options)
         local MIN_HEIGHT = 14
 
@@ -96,6 +105,9 @@ module.public = {
         module.private.views[name] = details
     end,
 
+    ---@param buffer number
+    ---@param window number
+    ---@param options NeorgCalendarOptions
     create_calendar = function(buffer, window, options)
         local callback_and_close = function(result)
             if options.callback ~= nil then
@@ -118,6 +130,7 @@ module.public = {
         view.setup(ui_info, mode, options.date or os.date("*t"), options)
     end,
 
+    ---@param options NeorgCalendarOptions
     open = function(options)
         local buffer, window = module.private.open_window(options)
 
@@ -126,6 +139,7 @@ module.public = {
         return module.public.create_calendar(buffer, window, options)
     end,
 
+    ---@param options NeorgCalendarOptions
     select_date = function(options)
         local buffer, window = module.private.open_window(options)
 
@@ -134,6 +148,7 @@ module.public = {
         return module.public.create_calendar(buffer, window, options)
     end,
 
+    ---@param options NeorgCalendarOptions
     select_date_range = function(options)
         local buffer, window = module.private.open_window(options)